diff --git a/.clippy.toml b/.clippy.toml
new file mode 100644
index 000000000..87702c79e
--- /dev/null
+++ b/.clippy.toml
@@ -0,0 +1,21 @@
+msrv = "1.67"
+
+missing-docs-in-crate-items = true
+disallowed-macros = [
+    "std::column",
+    "std::env",
+    "std::file",
+    "std::include_bytes",
+    "std::include_str",
+    "std::include",
+    "std::line",
+    "std::module_path",
+    "std::option_env",
+]
+disallowed-names = ["alpha", "beta", "gamma", "delta"]
+matches-for-let-else = "AllTypes"
+enforced-import-renames = [
+    { path = "std::time::Duration", rename = "StdDuration" },
+    { path = "std::time::Instant", rename = "StdInstant" },
+]
+semicolon-outside-block-ignore-multiline = true
diff --git a/.deny.toml b/.deny.toml
new file mode 100644
index 000000000..fd6be8eb1
--- /dev/null
+++ b/.deny.toml
@@ -0,0 +1,6 @@
+[licenses]
+allow = [
+    "MIT",
+    "Apache-2.0",
+    "Unicode-DFS-2016",
+]
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 000000000..74e8d6fb9
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.yaml]
+indent_size = 2
diff --git a/.github/codecov.yaml b/.github/codecov.yaml
new file mode 100644
index 000000000..045fa4bd1
--- /dev/null
+++ b/.github/codecov.yaml
@@ -0,0 +1,13 @@
+codecov:
+  max_report_age: 1
+  require_ci_to_pass: false
+  notify:
+    wait_for_ci: false
+
+coverage:
+  precision: 1
+  round: "nearest"
+  status:
+    project:
+      default:
+        informational: true
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
new file mode 100644
index 000000000..dca25cc65
--- /dev/null
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,341 @@
+name: Build
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}
+  cancel-in-progress: true
+
+env:
+  TYPE_CHECK_TARGETS: '{
+    "no_std": [
+    "thumbv7em-none-eabihf"
+    ],
+    "std_no_offset": [
+    "x86_64-unknown-netbsd",
+    "x86_64-unknown-illumos",
+    "wasm32-wasi"
+    ],
+    "std_with_offset": [
+    "x86_64-unknown-linux-gnu",
+    "x86_64-apple-darwin",
+    "x86_64-pc-windows-gnu"
+    ]
+    }'
+
+defaults:
+  run:
+    shell: bash
+
+on:
+  push:
+    branches: ["**"]
+    tags-ignore: ["**"]
+    paths-ignore:
+      - "**.md"
+      - LICENSE-Apache
+      - LICENSE-MIT
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "**/LICENSE-Apache"
+      - "**/LICENSE-MIT"
+      - .github/FUNDING.yml
+      - .editorconfig
+      - .gitignore
+      - logo.svg
+
+jobs:
+  check-targets:
+    name: Type checking (${{ matrix.rust.name }}, ${{ matrix.kind.name }})
+    runs-on: ubuntu-latest
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+    strategy:
+      matrix:
+        rust:
+          - { version: "1.67.0", name: MSRV }
+          - { version: stable, name: stable }
+        kind:
+          - name: no_std
+            query: .no_std + .std_no_offset + .std_with_offset
+            exclude-features:
+              - std
+              - formatting
+              - serde-human-readable
+              - serde-well-known
+              - local-offset
+              - quickcheck
+            group-features: []
+          - name: std_no_offset
+            query: .std_no_offset + .std_with_offset
+            exclude-features: [local-offset]
+            enable-features: [std]
+            group-features:
+              - [formatting, parsing]
+              - [serde-human-readable, serde-well-known]
+          - name: std_with_offset
+            query: .std_with_offset
+            enable-features: [std, local-offset]
+            group-features:
+              - [formatting, parsing]
+              - [serde-human-readable, serde-well-known]
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Generate target list
+        run: |
+          echo $TYPE_CHECK_TARGETS \
+          | jq -r '${{ matrix.kind.query }} | join(",") | "TARGETS=" + .' >> $GITHUB_ENV
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ matrix.rust.version }}
+          targets: ${{ env.TARGETS }}
+
+      - name: Install cargo-hack
+        uses: taiki-e/install-action@cargo-hack
+
+      - name: Check feature powerset
+        env:
+          GROUP_FEATURES: ${{ toJSON(matrix.kind.group-features) }}
+        run: |
+          echo $GROUP_FEATURES \
+          | jq -r '[.[] | join(",")] | map("--group-features " + .) | join(" ")' \
+          | xargs -d" " \
+          | ( \
+          echo $TYPE_CHECK_TARGETS \
+          | jq -r '${{ matrix.kind.query }} | map("--target " + .) | join(" ")' \
+          | xargs -d" " \
+          cargo hack check \
+          -p time \
+          --no-dev-deps \
+          --feature-powerset \
+          --optional-deps \
+          --group-features serde,rand \
+          --exclude-features default,wasm-bindgen,${{ join(matrix.kind.exclude-features) }} \
+          --features macros,${{ join(matrix.kind.enable-features) }} \
+          --exclude-all-features \
+          )
+
+  check-benchmarks:
+    name: Type-check benchmarks
+    runs-on: ubuntu-latest
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Type-check benchmarks
+        run: cargo check -p time --benches --all-features
+        env:
+          RUSTFLAGS: --cfg bench
+
+  test:
+    name: Test (${{ matrix.os.name }}, ${{ matrix.rust.name }})
+    runs-on: ${{ matrix.os.value }}
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+    strategy:
+      matrix:
+        rust:
+          - { version: "1.67.0", name: MSRV }
+          - { version: stable, name: stable }
+        os:
+          - { name: Ubuntu, value: ubuntu-latest }
+          - { name: Windows, value: windows-latest }
+          - { name: MacOS, value: macOS-latest }
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ matrix.rust.version }}
+
+      - name: Test
+        run: cargo test -p time --all-features
+
+  miri:
+    name: Test (miri)
+    runs-on: ubuntu-latest
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: miri
+
+      - name: Test
+        run: cargo miri test -p time --all-features
+        env:
+          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-strict-provenance -Zmiri-symbolic-alignment-check
+          QUICKCHECK_MAX_TESTS: 100
+
+  cross-build:
+    name: Cross-build
+    runs-on: ubuntu-latest
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: x86_64-pc-windows-gnu
+
+      - name: Install dependencies
+        run: sudo apt install gcc-mingw-w64
+
+      # We're testing the linking, so running `cargo check` is insufficient.
+      - name: Cross-build tests
+        run: cargo build -p time --tests --all-features --target x86_64-pc-windows-gnu
+
+  fmt:
+    name: Formatting
+    runs-on: ubuntu-latest
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt
+
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+        env:
+          RUSTFLAGS: --cfg bench
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+          targets: x86_64-unknown-linux-gnu,aarch64-apple-darwin,x86_64-pc-windows-gnu,x86_64-unknown-netbsd,x86_64-unknown-illumos,wasm32-wasi
+
+      - name: Run clippy
+        run: |
+          cargo clippy \
+          --all-features \
+          --all-targets \
+          --target x86_64-unknown-linux-gnu \
+          --target aarch64-apple-darwin \
+          --target x86_64-pc-windows-gnu \
+          --target x86_64-unknown-netbsd \
+          --target x86_64-unknown-illumos \
+          --target wasm32-wasi
+        env:
+          RUSTFLAGS: --cfg bench
+
+  documentation:
+    name: Documentation
+    runs-on: ubuntu-latest
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@nightly
+
+      - name: Generate documentation
+        run: cargo doc --workspace --all-features --no-deps
+        env:
+          RUSTDOCFLAGS: --cfg docsrs
+
+  publish-documentation:
+    name: Publish docs
+    needs:
+      - documentation
+      - check-targets
+      - check-benchmarks
+      - test
+      - cross-build
+      - fmt
+      - clippy
+    if: github.event_name == 'push' && github.ref == format('refs/heads/{0}', github.event.repository.master_branch)
+    uses: time-rs/time-rs.github.io/.github/workflows/trigger-deploy.yaml@main
+    secrets: inherit
+    permissions:
+      actions: write
+
+  coverage:
+    name: Coverage
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    if: (github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork) || github.event_name == 'push'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Cache cargo output
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+
+      - name: Generate coverage report
+        run: |
+          cargo llvm-cov clean --workspace
+          cargo llvm-cov test -p time --no-report --all-features -- --test-threads=1
+          cargo llvm-cov report --lcov > lcov.txt
+        env:
+          RUSTFLAGS: --cfg __ui_tests
+
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v4
+        with:
+          files: ./lcov.txt
diff --git a/.github/workflows/dependency-audit.yaml b/.github/workflows/dependency-audit.yaml
new file mode 100644
index 000000000..52590928d
--- /dev/null
+++ b/.github/workflows/dependency-audit.yaml
@@ -0,0 +1,17 @@
+name: Dependency audit
+
+on:
+  schedule:
+    - cron: "0 0 * * 1" # midnight on Monday
+  workflow_dispatch:
+
+jobs:
+  security-audit:
+    name: Dependency audit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Audit dependencies
+        uses: EmbarkStudios/cargo-deny-action@v1
diff --git a/.github/workflows/github-release.yaml b/.github/workflows/github-release.yaml
new file mode 100644
index 000000000..de83de5d2
--- /dev/null
+++ b/.github/workflows/github-release.yaml
@@ -0,0 +1,24 @@
+name: GitHub release
+
+on:
+  workflow_call:
+    inputs:
+      prerelease:
+        required: false
+        type: boolean
+
+jobs:
+  release:
+    name: Create release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Create release
+        uses: ncipollo/release-action@v1
+        with:
+          body: See the [changelog](https://github.com/time-rs/time/blob/main/CHANGELOG.md) for details.
+          prerelease: ${{ inputs.prerelease }}
diff --git a/.github/workflows/powerset.yaml b/.github/workflows/powerset.yaml
new file mode 100644
index 000000000..479c036bf
--- /dev/null
+++ b/.github/workflows/powerset.yaml
@@ -0,0 +1,111 @@
+name: "Check powerset"
+
+env:
+  RUSTFLAGS: -Dwarnings
+  TARGETS: '{
+    "no_std": [
+    "thumbv7em-none-eabihf"
+    ],
+    "std_no_offset": [
+    ],
+    "std_with_offset": [
+    "aarch64-unknown-linux-gnu",
+    "i686-pc-windows-gnu",
+    "i686-pc-windows-msvc",
+    "i686-unknown-linux-gnu",
+    "x86_64-apple-darwin",
+    "x86_64-pc-windows-gnu",
+    "x86_64-pc-windows-msvc",
+    "x86_64-unknown-linux-gnu",
+    "aarch64-linux-android",
+    "wasm32-wasi",
+    "x86_64-linux-android",
+    "x86_64-unknown-netbsd",
+    "x86_64-unknown-illumos"
+    ]
+    }'
+
+concurrency:
+  group: powerset-${{ github.head_ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+"
+      - "v[0-9]+.[0-9]+.[0-9]+-alpha.[0-9]+"
+      - "v[0-9]+.[0-9]+.[0-9]+-beta.[0-9]+"
+      - "v[0-9]+.[0-9]+.[0-9]+-rc.[0-9]+"
+  workflow_dispatch:
+
+jobs:
+  check:
+    name: Type checking (${{ matrix.kind.name }}, ${{ matrix.rust.name }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust:
+          - { version: "1.67.0", name: MSRV }
+          - { version: stable, name: stable }
+        kind:
+          - name: no_std
+            query: .no_std + .std_no_offset + .std_with_offset
+            exclude_features:
+              - std
+              - local-offset
+              - quickcheck
+              - formatting
+              - serde-human-readable
+              - serde-well-known
+          - name: std_no_offset
+            query: .std_no_offset + .std_with_offset
+            exclude_features: [local-offset]
+            enable_features: [std]
+          - name: std_with_offset
+            query: .std_with_offset
+            enable_features: [std, local-offset]
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Generate target list
+        run: |
+          echo $TARGETS \
+          | jq -r '${{ matrix.kind.query }} | join(",") | "TARGET_LIST=" + .' >> $GITHUB_ENV
+
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          targets: ${{ env.TARGET_LIST }}
+          toolchain: ${{ matrix.rust.version}}
+
+      - name: Install cargo-hack
+        uses: taiki-e/install-action@cargo-hack
+
+      - name: Check feature powerset
+        run: |
+          echo $TARGETS \
+          | jq -r '${{ matrix.kind.query }} | map("--target " + .) | join(" ")' \
+          | xargs -d" " \
+          cargo hack check \
+          -p time \
+          --no-dev-deps \
+          --feature-powerset \
+          --optional-deps \
+          --exclude-features default,wasm-bindgen,${{ join(matrix.kind.exclude_features) }} ${{
+          matrix.kind.enable_features && format('--features {0}', join(matrix.kind.enable_features)) }}
+
+  release:
+    name: Create release
+    if: startsWith(github.ref, 'refs/tags') && github.run_attempt == 1
+    needs: check
+    uses: ./.github/workflows/github-release.yaml
+    with:
+      prerelease: ${{ contains(github.ref, 'alpha') || contains(github.ref, 'beta') || contains(github.ref, 'rc') }}
+    permissions:
+      contents: write
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..ea8c4bf7f
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/target
diff --git a/.mailmap b/.mailmap
new file mode 100644
index 000000000..691d5e48a
--- /dev/null
+++ b/.mailmap
@@ -0,0 +1 @@
+Jacob Pratt <jacob@jhpratt.dev> <the.z.cuber@gmail.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 000000000..76390cc41
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,1186 @@
+# Changelog
+
+All notable changes to the time project will be documented in this file.
+
+The format is based on [Keep a Changelog]. This project adheres to [Semantic Versioning].
+
+---
+
+## 0.3.36 [2024-04-10]
+
+### # Fixed
+
+- `FormatItem` can be used as part of an import path. See [#675] for details.
+
+[#675]: https://github.com/time-rs/time/issues/675
+
+## 0.3.35 [2024-04-10]
+
+### Added
+
+- `Duration::checked_neg`
+- `ext::InstantExt`, which provides methods for using `time::Duration` with `std::time::Instant`
+
+### Changed
+
+- `Instant` is deprecated. It is recommended to use `std::time::Instant` directly, importing
+  `time::ext::InstantExt` for interoperability with `time::Duration`.
+- `FormatItem` has been renamed to `BorrowedFormatItem`, avoiding confusion with `OwnedFormatItem`.
+  An alias has been added for backwards compatibility.
+
+### Fixed
+
+- The weekday is optional when parsing RFC2822.
+- The range of sub-second values in `Duration` is documented correctly. The previous documentation
+  contained an off-by-one error.
+- Leap seconds are now correctly handled when parsing ISO 8601.
+
+## 0.3.34 [2024-02-03]
+
+### Fixed
+
+Computing the local offset on Windows works again. It was broken in some cases in v0.3.32 and
+v0.3.33.
+
+## 0.3.33 [2024-02-03]
+
+### Fixed
+
+Builds targeting `wasm32-unknown-unknown` now work again.
+
+## 0.3.32 [2024-02-01]
+
+### Added
+
+- Methods to replace the day of the year.
+  - `Date::replace_ordinal`
+  - `PrimitiveDateTime::replace_ordinal`
+  - `OffsetDateTime::replace_ordinal`
+- Modules to treat an `OffsetDateTime` as a Unix timestamp with subsecond precision for serde.
+  - `time::serde::timestamp::milliseconds`
+  - `time::serde::timestamp::microseconds`
+  - `time::serde::timestamp::nanoseconds`
+
+### Changed
+
+- `Duration::time_fn` is deprecated.
+
+## 0.3.31 [2023-12-19]
+
+### Added
+
+- `OffsetDateTime::new_in_offset`
+- `OffsetDateTime::new_utc`
+
+### Changed
+
+- The valid range of `UtcOffset` has been expanded from ±23:59:59 to ±25:59:59. This is to support
+  the full POSIX range while permitting infallible negation.
+
+## 0.3.30 [2023-10-13]
+
+### Added
+
+- `powerfmt::smart_display::SmartDisplay` has been added for the main types in the library. These
+  implementations ensure that values follow the requested fill, width, and alignment when using
+  `format!` or similar macros. `Display` is implemented in terms of `SmartDisplay`.
+
+### Fixed
+
+- Large values no longer wrap around in release mode when using `NumericalDuration` or
+  `NumericalStdDuration`.
+
+## 0.3.29 [2023-09-24]
+
+### Added
+
+- Niche value optimization for `Date` has been added. Both `Date` and `Option<Date>` are four bytes.
+- Unit conversions have been added. It is now possible to write `Second::per(Day)`, which returns
+  the number of seconds in one day. See the types in the [`time::convert` module] for more
+  information.
+
+  [`time::convert` module]: https://time-rs.github.io/api/time/convert/index.html
+
+### Changed
+
+- The diagnostic for `--cfg unsound_local_offset` has been removed.
+- `#![feature(no_coverage)]` was previously used internally for code coverage. It is no longer used,
+  so it has been removed.
+- The default value for `modifier::OffsetHour` has been changed. This was unintentionally changed in
+  v0.3.17 and went unnoticed until now. The sign is now only present if needed by default, as was
+  the case previously. This does not affect any situation where `format_description!` or
+  `format_description::parse` is used.
+
+### Fixed
+
+- Adding or subtracting a `std::time::Duration` to/from an `OffsetDateTime` will not result in
+  integer overflow internally. It will still panic if the result is out of range.
+
+## 0.3.28 [2023-08-27]
+
+### Added
+
+- More additional constants for the well-known `Iso8601` format description have been added. This
+  avoids the need to manually configure the format.
+- An `[end]` component has been added. This is ignored during formatting, but is used to indicate
+  the end of input when parsing. If any input remains after this component, an error is returned.
+  This is useful when using the `[first]` component, as it avoids the need to reorder variants.
+
+### Changed
+
+- The exemption for MacOS introduced in 0.3.20 has been removed. This is because some supported
+  versions of MacOS do not meet the requirements for the exemption.
+- The `UnexpectedTrailingCharacters` error variant has been moved to `ParseFromDescription`. All
+  previously-existing locations of this variant have been deprecated and will no longer be returned.
+
+## 0.3.27 [2023-08-22]
+
+This sets the `serde` dependency requirement to `>= 1.0.184` where the binaries have been removed.
+
+## 0.3.26 [2023-08-18]
+
+This release contains only a single change. `serde` is required to be a version prior to 1.0.171.
+This is due to the decision by the maintainer of `serde` to include pre-built binaries that are
+executed without the end user's knowledge. As of the time of publishing, the included binary has not
+even been reproduced. This is a security risk, and the `time` project strongly opposes this
+decision. While this may break some users' builds due to conflicting versions, it is a necessary
+step to ensure the security.
+
+## 0.3.25 [2023-08-02]
+
+### Fixed
+
+- Methods such as `Time::replace_milliseconds` would panic on some out-of-range values. This has
+  been fixed.
+
+## 0.3.24 [2023-07-30]
+
+### Added
+
+- The `subsecond` component is taken into account when parsing the `unix_timestamp` component. If
+  data is conflicting, the `subsecond` value takes precedence.
+- Parsing a `Time` with only the `hour` component is now supported. The `minute` and `second`, and
+  `subsecond` components are assumed to be zero.
+
+### Changed
+
+- The minimum supported Rust version is now 1.67.0.
+- The debug output for `Parsed` has been improved.
+- When parsing, invalid values are now rejected sooner. Previously, the entire input would be parsed
+  before being rejected in the final step. Now, invalid values are rejected as soon as they are
+  encountered. This affects the error variant returned, which may cause minor breakage for any code
+  (incorrectly) relying on the exact error variant.
+- When parsing a `Time`, an error is returned if components are present but not consecutive. For
+  example, if `hours` and `seconds` are present, `minutes` will not be assumed to be zero.
+
+### Fixed
+
+- The implementation of `Duration::checked_div` could return a slightly incorrect result in some
+  cases. This has been fixed.
+
+## 0.3.23 [2023-07-08]
+
+### Added
+
+- `Date::next_occurrence`
+- `Date::prev_occurrence`
+- `Date::nth_next_occurrence`
+- `Date::nth_prev_occurrence`
+- `Weekday::nth_prev`
+- `Month::nth_next`
+- `Month::nth_prev`
+
+### Changed
+
+**The minimum supported Rust version policy has been updated.** See [the README][msrv-policy] for
+details.
+
+[msrv-policy]: https://github.com/time-rs/time#minimum-rust-version-policy
+
+### Fixed
+
+- `Duration::abs` correctly returns `Duration::MAX` when near the minimum value. The nanoseconds
+  value was previously incorrect.
+- Compliance with ISO 8601 has been improved. Previously, a UTC offset would be incorrectly rejected
+  in some cases.
+
+## 0.3.22 [2023-06-07]
+
+### Added
+
+- `OffsetDateTime::checked_to_offset`
+
+## 0.3.21 [2023-05-05]
+
+### Added
+
+- Any formattable/parsable type can now be used with the `time::serde::format_description!` macro.
+- `Weekday::nth_next`
+
+### Changed
+
+- The minimum supported Rust version is now 1.65.0.
+
+## 0.3.20 [2023-02-24]
+
+### Changed
+
+- The minimum supported Rust version is now 1.63.0.
+- On Unix-based operating systems with known thread-safe environments, functions obtaining the local
+  offset no longer require a check that the program is single-threaded. This currently includes
+  MacOS, illumos, and NetBSD.
+
+### Added
+
+- `[ignore]` component in format descriptions. A `count` modifier is required, indicating the number
+  of bytes to ignore when parsing.
+- `[unix_timestamp]` component in format descriptions. This is currently only usable with
+  `OffsetDateTime`. Users can choose between seconds, milliseconds, microseconds, and nanoseconds,
+  and whether the sign is mandatory or optional.
+
+### Fixed
+
+- The API for declaring soundness now uses stricter atomic orderings internally.
+
+## 0.3.19 [2023-02-16]
+
+### Fixed
+
+This includes the update to the `format_description!` macro, which was supposed to be included in
+0.3.18.
+
+## 0.3.18 [2023-02-16]
+
+### Changed
+
+- The minimum supported Rust version is now 1.62.0.
+
+### Added
+
+- `[first]` and `[optional]` items can now be included in format descriptions. To parse this at
+  runtime, you must use the `format_description::parse_owned` method.
+- `format_description::parse_borrowed`
+- An API has been added to opt out of soundness checks for obtaining the local offset. This replaces
+  the previous, officially unsupported `RUSTFLAGS="--cfg unsound_local_offset"`. End users may call
+  `time::util::local_offset::set_soundness(time::util::local_offset::Soundness::Unsound)`. This
+  method is `unsafe` because it enables undefined behavior if its safety requirements are not
+  upheld. Note that libraries **must not** set this to `Unsound`, as it is impossible for a library
+  to guarantee end users uphold the required invariants.
+
+### Fixed
+
+- Correctly parse offset sign when hour is zero. The parse was previously unconditionally positive,
+  even if the sign indicated otherwise.
+- Compilation is fixed for WebAssembly.
+
+## 0.3.17 [2022-11-06]
+
+### Changed
+
+- The amount of code generated by `time::serde::format_description!` is reduced if not all feature
+  flags are active.
+- `cargo test --tests` works with any configuration of feature flags. This occurs by spawning a
+  subprocess that passes `--all-features`. `cargo test --doc` works with most combinations of
+  feature flags, including the default. The combination of these changes means that crater will now
+  run on `time`.
+- `libc` and `num_threads` are only included as dependencies when needed. They were previously
+  unconditionally included.
+
+### Added
+
+- `time::format_description::parse_owned`, which returns an `OwnedFormatItem`. This avoids "lifetime
+  hell", where all your structs now need a lifetime because a single field has one. Note that when
+  possible, the borrowed format item (just called `FormatItem`) is still preferred, as it has
+  significantly fewer allocations. The new `OwnedFormatItem` is usable for both formatting and
+  parsing, as you would expect.
+
+### Compatibility
+
+- The parser for runtime format descriptions has been rewritten. A side effect of this is that some
+  errors have slightly changed. No existing API has been altered, so this is not a breaking change.
+  However, you may notice different errors, which are hopefully better! The parser for compile-time
+  format descriptions has not yet been swapped out. If you notice any bugs, please file an issue.
+
+## 0.3.16 [2022-10-24]
+
+### Changed
+
+- The minimum supported Rust version is now 1.60.0.
+- The `serde-well-known` feature flag is deprecated. The necessary features for an item to be
+  enabled are indicated in documentation.
+- Feature gates have been loosened for well-known formats.
+
+### Added
+
+- `const`s can now be provided as the format description for `time::serde::format_description!`. The
+  `const` must be of type `&[FormatItem<'_>]`, which is what is returned by the
+  `time::macros::format_description!` macro.
+
+  ```rust
+  const TIME_FORMAT_ALT: &[FormatItem<'_>] = time::macros::format_description!("[hour]:[minute]");
+  time::serde::format_description!(time_format_alt, Time, TIME_FORMAT_ALT);
+  ```
+
+### Compatibility
+
+- Some feature flags have been removed. None of these have ever been documented as flags, so any use
+  was unsupported. These flags are:
+  - `js-sys`
+  - `quickcheck-dep`
+  - `itoa`
+  - `time-macros`
+
+## 0.3.15 [2022-10-03]
+
+### Changed
+
+- Better gating for `tm_gmtoff` extension. This should eliminate build failures on some untested
+  platforms.
+- `Debug` output for types are now human-readable. While this should not be relied upon, it is
+  currently the same as the output with `Display`.
+- Eliminate overflows in the constructors for `Duration. When there is an overflow, the methods now
+  panic. This was previously only the case in debug mode.
+- Panic if `NaN` is passed to `Duration::from_secs_f32` or `Duration::from_secs_f64`.
+
+### Fixed
+
+- Fix error when deserializing data types from bytes. This affects formats such as JSON.
+- Eliminate a panic in an edge case when converting `OffsetDateTime` to another `UtcOffset`. This
+  occurred due to an old assumption in code that was no longer the case.
+
+## 0.3.14 [2022-08-24]
+
+### Changed
+
+- The minimum supported Rust version is now 1.59.0.
+- `Duration::unsigned_abs` is now `const fn`.
+- The const parameter for `time::format_description::well_known::Iso8601` now has a default. This
+  means `Iso8601` is the same as `Iso8601::DEFAULT`.
+- The `Parsed` struct has been reduced in size from 56 to 32 bytes (a 43% reduction).
+
+## 0.3.13 [2022-08-09]
+
+### Fixed
+
+- wasm builds other than those using `wasm-bindgen` work again.
+
+## 0.3.12 [2022-08-01]
+
+### Added
+
+- `js-sys` now supports obtaining the system's local UTC offset.
+
+### Changed
+
+- Performance of many `Date` operations has improved when using the `large-dates` feature.
+- While an internal change, `OffsetDateTime` now stores the value in the attached `UtcOffset`, not
+  UTC. This leads to significant performance gains on nearly all `OffsetDateTime` methods.
+
+### Fixed
+
+- Subtracting two `Time`s can no longer panic. This previously occurred in some situations where the
+  result was invalid.
+- ISO 8601 parsing rounds the subseconds to avoid incorrectly truncating the value.
+
+## 0.3.11 [2022-06-21]
+
+### Fixed
+
+- [#479]: regression when parsing optional values with `serde`
+- [#481]: `Time` subtracted from `Time` can panic. This was caused by a bug that has always existed,
+  in that an internal invariant was not upheld. Memory safety was not violated.
+
+[#479]: https://github.com/time-rs/time/issues/479
+[#481]: https://github.com/time-rs/time/issues/481
+
+## 0.3.10 [2022-06-19]
+
+### Added
+
+- Serde support for non-self-describing formats
+- `Duration::unsigned_abs`, which returns a `std::time::Duration`
+- ISO 8601 well-known format
+- `Duration` can now be formatted with a `.N` specifier, providing a shorter representation when
+  using `Display`.
+- Parse `null` as `None` on serde structs
+
+### Fixed
+
+- Fix incorrect parsing of UTC offset in `Rfc3339`.
+
+### Changed
+
+- The minimum supported Rust version is now 1.57.0.
+- Performance for `Rfc2822` has been improved.
+- Debug assertions have been added in a few places. This should have no user facing impact, as it
+  only serves to catch bugs and is disabled in release mode.
+
+## 0.3.9 [2022-03-22]
+
+### Added
+
+- `time::serde::format_description!`
+  - This macro is similar to `time::format_description!`, but it generates a module that can be used
+    in `#[serde(with = "foo")]`. This makes it far easier to serialize/deserialize a custom format.
+- `Date::replace_year`
+- `Date::replace_month`
+- `Date::replace_day`
+- `Time::replace_hour`
+- `Time::replace_minute`
+- `Time::replace_second`
+- `Time::replace_millisecond`
+- `Time::replace_microsecond`
+- `Time::replace_nanosecond`
+- `PrimitiveDateTime::replace_year`
+- `PrimitiveDateTime::replace_month`
+- `PrimitiveDateTime::replace_day`
+- `PrimitiveDateTime::replace_hour`
+- `PrimitiveDateTime::replace_minute`
+- `PrimitiveDateTime::replace_second`
+- `PrimitiveDateTime::replace_millisecond`
+- `PrimitiveDateTime::replace_microsecond`
+- `PrimitiveDateTime::replace_nanosecond`
+- `OffsetDateTime::replace_year`
+- `OffsetDateTime::replace_month`
+- `OffsetDateTime::replace_day`
+- `OffsetDateTime::replace_hour`
+- `OffsetDateTime::replace_minute`
+- `OffsetDateTime::replace_second`
+- `OffsetDateTime::replace_millisecond`
+- `OffsetDateTime::replace_microsecond`
+- `OffsetDateTime::replace_nanosecond`
+- `Parsed::offset_minute_signed`
+- `Parsed::offset_second_signed`
+- `Parsed::set_offset_minute_signed`
+- `Parsed::set_offset_second_signed`
+- `Parsed::with_offset_minute_signed`
+- `Parsed::with_offset_second_signed`
+- `error::InvalidVariant`
+- `impl FromStr` for `Weekday`
+- `impl FromStr` for `Month`
+- `impl Display for Duration`
+
+### Deprecated
+
+The following methods have been deprecated in favor of the new, signed equivalent methods. The
+pre-existing methods
+
+- `Parsed::offset_minute`
+- `Parsed::offset_second`
+- `Parsed::set_offset_minute`
+- `Parsed::set_offset_second`
+- `Parsed::with_offset_minute`
+- `Parsed::with_offset_second`
+
+### Changed
+
+- Well-known formats that support leap seconds now return the `TryFromParsed::ComponentRange` error
+  variant if the leap second could not occur at that given moment.
+
+## 0.3.8 [2022-02-22] [YANKED]
+
+This release is broken and has been yanked.
+
+## 0.3.7 [2022-01-26]
+
+### Fixed
+
+Solaris and Illumos build again.
+
+## 0.3.6 [2022-01-20]
+
+### Added
+
+- `Date::saturating_add`
+- `Date::saturating_sub`
+- `PrimitiveDateTime::saturating_add`
+- `PrimitiveDateTime::saturating_sub`
+- `OffsetDateTime::saturating_add`
+- `OffsetDateTime::saturating_sub`
+- `PrimitiveDatetime::MIN`
+- `PrimitiveDatetime::MAX`
+- `Rfc2822` format description
+- Serde support for well-known formats
+  - This is placed behind the new `serde-well-known` feature flag.
+
+### Changed
+
+- MacOS and FreeBSD are supported obtaining the local offset when single-threaded.
+  - Starting with this version, this is delegated to the `num_threads` crate.
+- Leap seconds are now parsed as the final nanosecond of the preceding second.
+- The minimum supported Rust version is now 1.53.0.
+- Deserializers for human readable formats will fall back to the binary format if the human readable
+  format fails to deserialize.
+
+### Fixed
+
+- Deserialization will no longer fail when given a non-borrowed string.
+
+## 0.3.5 [2021-11-12]
+
+### Added
+
+- `Date::checked_add`
+- `Date::checked_sub`
+- `PrimitiveDateTime::checked_add`
+- `PrimitiveDateTime::checked_sub`
+- `OffsetDateTime::checked_add`
+- `OffsetDateTime::checked_sub`
+
+### Changed
+
+- Attempts to obtain the local UTC offset will now succeed on Linux if the process is
+  single-threaded. This does not affect other Unix platforms. As a reminder, the relevant methods
+  are fallible and may return an `Err` value for any reason.
+
+## 0.3.4 [2021-10-26]
+
+### Added
+
+- `error::DifferentVariant` and `Error::DifferentVariant`
+- `impl From<Component> for FormatItem<'_>`
+- `impl TryFrom<FormatItem<'_>> for Component`
+- `impl<'a> From<&'a [FormatItem<'_>]> for FormatItem<'a>`
+- `impl<'a> TryFrom<FormatItem<'a>> for &[FormatItem<'a>]`
+- `impl PartialEq<Component> for FormatItem<'_>`
+- `impl PartialEq<FormatItem<'_>> for Component`
+- `impl PartialEq<&[FormatItem<'_>]> for FormatItem<'_>`
+- `impl PartialEq<FormatItem<'_>> for &[FormatItem<'_>]`
+- `impl TryFrom<Error> for error::TryFromParsed`
+- `impl TryFrom<Error> for error::Parse`
+- `impl TryFrom<Error> for error::ParseFromDescription`
+- `impl TryFrom<Error> for error::InvalidFormatDescription`
+- `impl TryFrom<Error> for error::IndeterminateOffset`
+- `impl TryFrom<Error> for error::Format`
+- `impl TryFrom<Error> for error::ConversionRange`
+- `impl TryFrom<Error> for error::ComponentRange`
+- `impl TryFrom<error::TryFromParsed> for error::ComponentRange`
+- `impl TryFrom<error::Parse> for error::TryFromParsed`
+- `impl TryFrom<error::Parse> for error::ParseFromDescription`
+- `impl TryFrom<error::Format> for std::io::Error`
+- `impl Sum for Duration`
+- `impl Sum<&Duration> for Duration`
+- A `const fn default()` has been added to all modifiers that are `struct`s. These methods exist to
+  permit construction in `const` contexts and may be removed (without being considered a breaking
+  change) once `impl const Default` is stabilized.
+- `FormatItem::Optional`, which will consume the contained value if present but still succeed
+  otherwise.
+- `FormatItem::First`, which will consume the first successful parse, ignoring any prior errors.
+
+### Fixed
+
+- Cross-building to Windows now succeeds.
+- A parse error on a `UtcOffset` component now indicates the error comes from the offset.
+- Some arithmetic no longer panics in edge cases.
+
+## 0.3.3 [2021-09-25]
+
+### Added
+
+- `Parsed::parse_item`
+- `Parsed::parse_items`
+- `Parsed::parse_literal`
+- Builder methods for `Parsed`
+- The `format_description!` macro now supports the `case_sensitive` modifier.
+
+### Changed
+
+The minimum supported version is now 1.51.0.
+
+## 0.3.2 [2021-08-25]
+
+### Added
+
+- `Instant` is now `#[repr(transparent)]`
+
+### Fixed
+
+- Constructing a `Date` from its ISO year, week, and weekday now returns the correct value in all
+  circumstances. Previously, dates with an ISO year less than zero may have returned incorrect
+  values. This affects both the `Date::from_iso_week_date` method and the `date!` macro.
+
+## 0.3.1 [2021-08-06]
+
+### Added
+
+- `Month` now implements `TryFrom<u8>`
+- `From<Month>` is now implemented for `u8`
+- The parser now accepts "5 PM" and similar as a valid time. Only the 12-hour clock hour and the
+  AM/PM suffix may be present; any other components representing a time will cause an error (this
+  exact behavior is not guaranteed).
+- The `time!` macro accepts the "5 PM" syntax with the same restriction.
+
+### Fixed
+
+- Macros that have a time component (`time!` and `datetime!`) no longer accept "0:00 AM" and
+  similar. This was previously erroneously accepted.
+
+## 0.3.0 [2021-07-30]
+
+### Added
+
+- `datetime!` macro, which allows the construction of a statically verified `PrimitiveDateTime` or
+  `OffsetDateTime`.
+- `PrimitiveDateTime::replace_time`
+- `PrimitiveDateTime::replace_date`
+- `OffsetDateTime::replace_time`
+- `OffsetDateTime::replace_date`
+- `OffsetDateTime::replace_date_time`
+- `OffsetDateTime::replace_offset`
+- `#![no_alloc]` support
+- `Date::to_iso_week_date`, replacing `Date::iso_year_week`
+- `Date::MIN`
+- `Date::MAX`
+- `UtcOffset::from_hms`
+- `UtcOffset::from_whole_seconds`
+- `UtcOffset::as_hms`
+- `UtcOffset::whole_hours`
+- `UtcOffset::whole_minutes`
+- `UtcOffset::minutes_past_hour`
+- `UtcOffset::seconds_past_minute`
+- `UtcOffset::is_utc`
+- `UtcOffset::is_positive`
+- `UtcOffset::is_negative`
+- `OffsetDateTime::sunday_based_week`
+- `OffsetDateTime::monday_based_week`
+- `PrimitiveDateTime::to_calendar_date`
+- `PrimitiveDateTime::to_ordinal_date`
+- `PrimitiveDateTime::to_iso_week_date`
+- `PrimitiveDateTime::to_julian_day`
+- `OffsetDateTime::to_calendar_date`
+- `OffsetDateTime::to_ordinal_date`
+- `OffsetDateTime::to_iso_week_date`
+- `OffsetDateTime::to_julian_day`
+- `Time::as_hms`
+- `Time::as_hms_milli`
+- `Time::as_hms_micro`
+- `Time::as_hms_nano`
+- `PrimitiveDateTime::as_hms`
+- `PrimitiveDateTime::as_hms_milli`
+- `PrimitiveDateTime::as_hms_micro`
+- `PrimitiveDateTime::as_hms_nano`
+- `OffsetDateTime::to_hms`
+- `OffsetDateTime::to_hms_milli`
+- `OffsetDateTime::to_hms_micro`
+- `OffsetDateTime::to_hms_nano`
+- `Duration::saturating_add`
+- `Duration::saturating_sub`
+- `Duration::saturating_mul`
+- `util::days_in_year_month`
+- `Month`
+- `Instant::into_inner`
+- `impl AsRef<StdInstant>` and `impl Borrow<StdInstant>` for `Instant`
+- Support for obtaining the local UTC offset on Unix-like systems has been re-added under a
+  user-provided flag. This functionality is not tested in any way and is not guaranteed to work.
+  Library authors are unable to enable this feature, as it must be passed via `RUSTFLAGS`. Further
+  information is available in the documentation.
+
+### Changed
+
+- The minimum supported Rust version is now 1.48.0. Per the policy in the README, this may be bumped
+  within the 0.3 series without being a breaking change.
+- rand has been updated to 0.8.
+- quickcheck has been updated to 1.0.
+- Macros are placed behind the `macros` feature flag.
+- Renamed
+  - `OffsetDatetime::timestamp` → `OffsetDateTime::unix_timestamp`
+  - `OffsetDatetime::timestamp_nanos` → `OffsetDateTime::unix_timestamp_nanos`
+  - `Date::try_from_ymd` → `Date::from_calendar_date`
+  - `Date::try_from_yo` → `Date::from_ordinal_date`
+  - `Date::try_from_iso_ywd` → `Date::from_iso_week_date`
+  - `Date::as_ymd` → `Date::to_calendar_date`
+  - `Date::as_yo` → `Date::to_ordinal_date`
+  - `Date::try_with_hms` → `Date::with_hms`
+  - `Date::try_with_hms_milli` → `Date::with_hms_milli`
+  - `Date::try_with_hms_micro` → `Date::with_hms_micro`
+  - `Date::try_with_hms_nano` → `Date::with_hms_nano`
+  - `Time::try_from_hms` → `Time::from_hms`
+  - `Time::try_from_hms_milli` → `Time::from_hms_milli`
+  - `Time::try_from_hms_micro` → `Time::from_hms_micro`
+  - `Time::try_from_hms_nano` → `Time::from_hms_nano`
+  - `UtcOffset::try_local_offset_at` → `UtcOffset::local_offset_at`
+  - `UtcOffset::as_seconds` → `UtcOffset::whole_seconds`
+  - `OffsetDateTime::try_now_local` → `OffsetDateTime::now_local`
+  - `Date::week` → `Date::iso_week`
+  - `PrimitiveDateTime::week` → `PrimitiveDateTime::iso_week`
+  - `OffsetDateTime::week` → `OffsetDateTime::iso_week`
+  - `Date::julian_day` → `Date::to_julian_day`
+  - All `Duration` unit values, as well as the minimum and maximum, are now associated constants.
+  - `OffsetDateTime::unix_epoch()` → `OffsetDateTime::UNIX_EPOCH`
+  - `Time::midnight()` → `Time::MIDNIGHT`
+- Now `const fn` (on at least newer compilers)
+  - `Date::weekday`
+  - `Date::next_day`
+  - `Date::previous_day`
+  - `PrimitiveDateTime::assume_offset`
+  - `PrimitiveDateTime::weekday`
+  - `Duration::checked_add`
+  - `Duration::checked_sub`
+  - `Duration::checked_mul`
+  - `OffsetDateTime::from_unix_timestamp`
+  - `OffsetDateTime::from_unix_timestamp_nanos`
+  - `OffsetDateTime::date`
+  - `OffsetDateTime::time`
+  - `OffsetDateTime::year`
+  - `OffsetDateTime::month`
+  - `OffsetDateTime::day`
+  - `OffsetDateTime::ordinal`
+  - `OffsetDateTime::to_iso_week_date`
+  - `OffsetDateTime::week`
+  - `OffsetDateTime::weekday`
+  - `OffsetDateTime::hour`
+  - `OffsetDateTime::minute`
+  - `OffsetDateTime::second`
+  - `OffsetDateTime::millisecond`
+  - `OffsetDateTime::microsecond`
+  - `OffsetDateTime::nanosecond`
+  - `OffsetDateTime::unix_timestamp`
+  - `OffsetDateTime::unix_timestamp_nanos`
+- The following functions now return a `Result`:
+  - `Date::from_julian_day`
+  - `OffsetDateTime::from_unix_timestamp`
+  - `OffsetDateTime::from_unix_timestamp_nanos`
+- The following functions now return an `Option`:
+  - `Date::next_day`
+  - `Date::previous_day`
+- The range of valid years has changed. By default, it is ±9999. When using the `large-dates`
+  feature, this is increased to ±999,999. Enabling the feature has performance implications and
+  introduces ambiguities when parsing.
+- The following are now gated under the `local-offset` feature:
+  - `UtcOffset::local_offset_at`
+  - `OffsetDateTime::now_local`
+- `Instant` is now guaranteed to be represented as a tuple struct containing a `std::time::Instant`.
+- Macros are guaranteed to be evaluated at compile time.
+- `Date::to_julian_day` now returns an `i32` (was `i64`).
+- `Date::from_julian_day` now accepts an `i32` (was `i64`).
+- Extension traits are only implemented for some types and are now sealed. As they are intended to
+  be used with value literals, the breakage caused by this should be minimal.
+- The new `Month` enum is used instead of numerical values where appropriate.
+
+### Removed
+
+- v0.1 APIs, previously behind an enabled-by-default feature flag
+  - `PreciseTime`
+  - `SteadyTime`
+  - `precise_time_ns`
+  - `precise_time_s`
+  - `Instant::to`
+  - `Duration::num_weeks`
+  - `Duration::num_days`
+  - `Duration::num_hours`
+  - `Duration::num_minutes`
+  - `Duration::num_seconds`
+  - `Duration::num_milliseconds`
+  - `Duration::num_microseconds`
+  - `Duration::num_nanoseconds`
+  - `Duration::span`
+  - `Duration::from_std`
+  - `Duration::to_std`
+- Panicking APIs, previously behind a non-default feature flag
+  - `Date::from_ymd`
+  - `Date::from_yo`
+  - `Date::from_iso_ywd`
+  - `Date::with_hms`
+  - `Date::with_hms_milli`
+  - `Date::with_hms_micro`
+  - `Date::with_hms_nano`
+  - `Time::from_hms`
+  - `Time::from_hms_milli`
+  - `Time::from_hms_micro`
+  - `Time::from_hms_nano`
+- APIs that assumed an offset of UTC, previously enabled unconditionally
+  - `Date::today`
+  - `Time::now`
+  - `PrimitiveDateTime::now`
+  - `PrimitiveDateTime::unix_epoch`
+  - `PrimitiveDateTime::from_unix_timestamp`
+  - `PrimitiveDateTime::timestamp`
+  - `OffsetDateTime::now`
+  - `impl Sub<SystemTime> for PrimitiveDateTime`
+  - `impl Sub<PrimitiveDateTime> for SystemTime`
+  - `impl PartialEq<SystemTime> for PrimitiveDateTime`
+  - `impl PartialEq<PrimitiveDateTime> for SystemTime`
+  - `impl PartialOrd<SystemTime> for PrimitiveDateTime`
+  - `impl PartialOrd<PrimitiveDateTime> for SystemTime`
+  - `impl From<SystemTime> for PrimitiveDateTime`
+  - `impl From<PrimitiveDateTime> for SystemTime`
+  - `UtcOffset::local_offset_at` — assumed UTC if unable to determine local offset
+  - `OffsetDateTime::now_local` — assumed UTC if unable to determine local offset
+- Other APIs deprecated during the course of 0.2, previously enabled unconditionally
+  - `Duration::sign`
+  - `PrimitiveDateTime::using_offset`
+  - `Sign`
+- Re-exports of APIs moved during the course of 0.2
+  - `days_in_year`
+  - `is_leap_year`
+  - `validate_format_string`
+  - `weeks_in_year`
+  - `ComponentRangeError`
+  - `ConversionRangeError`
+  - `IndeterminateOffsetError`
+  - `ParseError`
+  - `NumericalDuration`
+  - `NumericalStdDuration`
+  - `NumericalStdDurationShort`
+  - All top-level macros
+- Lazy formatting, which was unidiomatic as a failure would have returned `fmt::Error`, indicating
+  an error unrelated to the time crate.
+  - `Time::lazy_format`
+  - `Date::lazy_format`
+  - `UtcOffset::lazy_format`
+  - `PrimitiveDateTime::lazy_format`
+  - `OffsetDateTime::lazy_format`
+- Support for stdweb has been removed, as the crate is unmaintained.
+- The `prelude` module has been removed in its entirety.
+- `Date::iso_year_week` in favor of `Date::to_iso_week_date`
+- `PrimitiveDateTime::iso_year_week`
+- `OffsetDateTime::iso_year_week`
+- `UtcOffset::east_hours`
+- `UtcOffset::west_hours`
+- `UtcOffset::hours`
+- `UtcOffset::east_minutes`
+- `UtcOffset::west_minutes`
+- `UtcOffset::minutes`
+- `UtcOffset::east_seconds`
+- `UtcOffset::west_seconds`
+- `UtcOffset::seconds`
+- `Date::month_day`
+- `PrimitiveDateTime::month_day`
+- `OffsetDateTime::month_day`
+- `Weekday::iso_weekday_number` (identical to `Weekday::number_from_monday`)
+- `ext::NumericalStdDurationShort`
+
+## 0.2.26 [2021-03-16]
+
+### Fixed
+
+- #316, where the build script was wrongly unable to determine the correct compiler version
+- Dependencies have been bumped to the latest patch version, ensuring compatibility.
+
+## 0.2.25 [2021-01-24]
+
+### Fixed
+
+- Fix #309, which can cause panics in certain situations.
+
+## 0.2.24 [2021-01-08]
+
+### Fixed
+
+- The implementation of `OffsetDateTime::timestamp`, `OffsetDateTime::unix_timestamp`,
+  `PrimitiveDatetime::timestamp`, and `OffsetDateTime::unix_timestamp` have been corrected. This
+  affects all negative timestamps with a nonzero subsecond value.
+
+## 0.2.23 [2020-11-17]
+
+### Compatibility notes
+
+Due to #293, any method that requires knowledge of the local offset will now
+_fail_ on Linux. For `try_` methods, this means returning an error. For others,
+it means assuming UTC.
+
+### Deprecated
+
+- `UtcOffset::timestamp` (moved to `UtcOffset::unix_timestamp`)
+- `UtcOffset::timestamp_nanos` (moved to `UtcOffset::unix_timestamp_nanos`)
+- `date` (moved to `macros::date`)
+- `time` (moved to `macros::time`)
+- `offset` (moved to `macros::offset`)
+- `OffsetDateTime::now_local` (assumes UTC if unable to be determined)
+- `UtcOffset::local_offset_at` (assumes UTC if unable to be determined)
+- `UtcOffset::current_local_offset` (assumes UTC if unable to be determined)
+
+## 0.2.22 [2020-09-25]
+
+### Fixed
+
+- Solaris & Illumos now successfully build.
+- `Duration::new` could previously result in an inconsistent internal state. This led to some odd
+  situations where a `Duration` could be both positive and negative. This has been fixed such that
+  the internal state maintains its invariants.
+
+## 0.2.21 [2020-09-20]
+
+### Changed
+
+- Implementation details of some error types have been exposed. This means that data about a
+  component being out of range can be directly obtained, while an invalid offset or conversion error
+  is guaranteed to be a zero-sized type.
+- The following functions are `const fn` on rustc ≥ 1.46:
+  - `Date::try_from_iso_ywd`
+  - `Date::iso_year_week`
+  - `Date::week`
+  - `Date::sunday_based_week`
+  - `Date::monday_based_week`
+  - `Date::try_with_hms`
+  - `Date::try_with_hms_milli`
+  - `Date::try_with_hms_micro`
+  - `Date::try_with_hms_nano`
+  - `PrimitiveDateTime::iso_year_week`
+  - `PrimitiveDateTime::week`
+  - `PrimitiveDateTime::sunday_based_week`
+  - `PrimitiveDateTime::monday_based_week`
+  - `util::weeks_in_year`
+
+## 0.2.20 [2020-09-16]
+
+### Added
+
+- `OffsetDateTime::timestamp_nanos`
+- `OffsetDateTime::from_unix_timestamp_nanos`
+
+### Fixed
+
+A bug with far-reaching consequences has been fixed. See #276 for complete details, but the gist is
+that the constructing a `Date` from a valid Julian day may result in an invalid value or even panic.
+As a consequence of implementation details, this affects nearly all arithmetic with `Date`s (and as
+a result also `PrimitiveDateTime`s and `OffsetDateTime`s).
+
+### Improvements
+
+- Document how to construct an `OffsetDateTime` from a timestamp-nanosecond pair
+
+## 0.2.19 [2020-09-12]
+
+### Fixed
+
+- The build script now declares a dependency on the `COMPILING_UNDER_CARGO_WEB` environment
+  variable.
+- Parsing the `%D` specifier no longer requires padding on the month. Previously,
+  `Err(InvalidMonth)` was incorrectly returned.
+- A `std::time::Duration` that is larger than `time::Duration::max_value()` now correctly returns
+  `Ordering::Greater` when compared.
+- Multiplying and assigning an integer by `Sign::Zero` now sets the integer to be zero. This
+  previously left the integer unmodified.
+
+## 0.2.18 [2020-09-08]
+
+### Changed
+
+- The following functions are `const fn` on rustc ≥ 1.46:
+  - `Date::try_from_ymd`
+  - `Date::try_from_yo`
+  - `Time::try_from_hms`
+  - `Time::try_from_hms_milli`
+  - `Time::try_from_hms_micro`
+  - `Time::try_from_hms_nano`
+- An `error` module has been created where all existing error types are contained. The `Error`
+  suffix has been dropped from these types.
+- An `ext` module has been created where extension traits are contained.
+- A `util` module has been created where utility functions are contained.
+- `error::ComponentRange` now implements `Copy`.
+
+For back-compatibility, all items that were moved to newly-contained modules have been re-exported
+from their previous locations (and in the case of the `error` module, with their previous name).
+
+### Fixes
+
+Parsing `format::Rfc3339` now correctly handles the UTC offset (#274).
+
+## 0.2.17 [2020-09-01]
+
+### Changed
+
+The following functions are `const fn` on rustc ≥ 1.46:
+
+- `Date::year`
+- `Date::month`
+- `Date::day`
+- `Date::month_day`
+- `Date::ordinal`
+- `Date::as_ymd`
+- `Date::as_yo`
+- `Date::julian_day`
+- `Duration::checked_div`
+- `PrimitiveDateTime::year`
+- `PrimitiveDateTime::month`
+- `PrimitiveDateTime::day`
+- `PrimitiveDateTime::month_day`
+- `PrimitiveDateTime::ordinal`
+- `Weekday::previous`
+- `Weekday::next`
+
+### Improvements
+
+- `size_of::<Date>()` has been reduced from 8 to 4. As a consequence,
+  `size_of::<PrimitiveDatetime>()` went from 16 to 12 and `size_of::<OffsetDateTime>()` from 20
+  to 16. This change also results in a performance improvement of approximately 30% on the
+  `Date::year` and `Date::ordinal` methods.
+- `cfg-if` has been removed as a dependency.
+
+### Fixed
+
+- `cfg` flags passed to rustc will no longer collide with other crates (at least unless they're
+  doing something very stupid).
+- The crate will successfully compile with any combination of feature flags. Previously, some
+  combinations would fail.
+
+## 0.2.16 [2020-05-12]
+
+### Added
+
+`OffsetDateTime`s can now be represented as Unix timestamps with serde. To do this, you can use the
+`time::serde::timestamp` and `time::serde::timestamp::option` modules.
+
+## 0.2.15 [2020-05-04]
+
+### Fixed
+
+`cargo-web` support works, and is now explicitly checked in CI. A previous change was made that made
+a method call ambiguous.
+
+## 0.2.14 [2020-05-02]
+
+### Fixed
+
+Adding/subtracting a `core::time::Duration` now correctly takes subsecond values into account. This
+also affects `PrimitiveDateTime` and `OffsetDateTime`.
+
+## 0.2.13 [2020-05-01]
+
+### Fixed
+
+Panicking APIs are re-exposed.
+
+## 0.2.12 [2020-04-30]
+
+### Fixed
+
+Subtracting `Instant`s can correctly result in a negative duration, rather than resulting in the
+absolute value of it.
+
+## 0.2.11 [2020-04-27]
+
+### Added
+
+- `OffsetDateTime::now_utc`
+
+### Deprecated
+
+- `OffsetDateTime::now` due to the offset not being clear from the method name alone.
+
+### Fixed
+
+`Date`s are now uniformly random when using the `rand` crate. Previously, both the year and day
+within the year were uniform, but this meant that any given day in a leap year was slightly less
+likely to be chosen than a day in a non-leap year.
+
+### Changed
+
+- MSRV is lowered to 1.32.0.
+
+## 0.2.10 [2020-04-19]
+
+### Added
+
+- Support for formatting and parsing `OffsetDateTime`s as RFC3339.
+- Lazy formatting. To avoid exposing implementation details, we're just returning `impl Display`,
+  rather than a concrete type.
+- Add support for Illumos.
+
+### Fixed
+
+- Deprecated APIs from time v0.1 are public again. They were previously hidden by accident in 0.2.9.
+
+## 0.2.9 [2020-03-13]
+
+### Fixed
+
+`cfg-if` now has a mandatory minimum of 0.1.10, rather than just 0.1. This is because compilation
+fails when using 0.1.9.
+
+## 0.2.8 [2020-03-12]
+
+### Added
+
+- `cargo_web` support has been added for getting a local offset. A general catch-all defaulting to
+  UTC has also been added.
+- `Error::source` has been implemented for the wrapper `time::Error`.
+- `UtcOffset::try_local_offset`, `UtcOffset::try_current_local_offset`,
+  `OffsetDateTime::try_now_local()` provide fallible alternatives when the default of UTC is not
+  desired. To facilitate this change, `IndeterminateOffsetError` has been added.
+- Support for parsing and formatting subsecond nanoseconds.
+
+### Changed
+
+- `#[non_exhaustive]` is simulated on compilers prior to 1.40.0.
+
+## 0.2.7 [2020-02-22]
+
+### Added
+
+- `Display` has been implemented for `Date`, `OffsetDateTime`, `PrimitiveDateTime`, `Time`,
+  `UtcOffset`, and `Weekday`.
+- `Hash` is now derived for `Duration`.
+- `SystemTime` can be converted to and from `OffsetDateTime`. The following trait implementations
+  have been made for interoperability:
+  - `impl Sub<SystemTime> for OffsetDateTime`
+  - `impl Sub<OffsetDateTime> for SystemTime`
+  - `impl PartialEq<SystemTime> for OffsetDateTime`
+  - `impl PartialEq<OffsetDateTime> for SystemTime`
+  - `impl PartialOrd<SystemTime> for OffsetDateTime`
+  - `impl PartialOrd<OffsetDateTime> for SystemTime`
+  - `impl From<SystemTime> for OffsetDateTime`
+  - `impl From<OffsetDateTime> for SystemTime`
+- All structs now `impl Duration<T> for Standard`, allowing usage with the `rand` crate. This is
+  gated behind the `rand` feature flag.
+- Documentation can now be built on stable. Some annotations will be missing if you do this.
+- `NumericalDuration` has been implemented for `f32` and `f64`. `NumericalStdDuration` and
+  `NumericalStdDurationShort` have been implemented for `f64` only.
+- `UtcOffset::local_offset_at(OffsetDateTime)`, which will obtain the system's local offset at the
+  provided moment in time.
+  - `OffsetDateTime::now_local()` is equivalent to calling
+    `OffsetDateTime::now().to_offset(UtcOffset::local_offset_at(OffsetDateTime::now()))` (but more
+    efficient).
+  - `UtcOffset::current_local_offset()` will return the equivalent of
+    `OffsetDateTime::now_local().offset()`.
+
+### Changed
+
+- All formatting and parsing methods now accept `impl AsRef<str>` as parameters, rather than just
+  `&str`. `time::validate_format_string` does this as well.
+- The requirement of a `Date` being between the years -100,000 and +100,000 (inclusive) is now
+  strictly enforced.
+- Overflow checks for `Duration` are now enabled by default. This behavior is the identical to what
+  the standard library does.
+- The `time`, `date`, and `offset` macros have been added to the prelude.
+
+### Deprecated
+
+- `Sign` has been deprecated in its entirety, along with `Duration::sign`.
+
+  To obtain the sign of a `Duration`, you can use the `Duration::is_positive`,
+  `Duration::is_negative`, and `Duration::is_zero` methods.
+
+- A number of functions and trait implementations that implicitly assumed a timezone (generally UTC)
+  have been deprecated. These are:
+  - `Date::today`
+  - `Time::now`
+  - `PrimitiveDateTime::now`
+  - `PrimitiveDateTime::unix_epoch`
+  - `PrimitiveDateTime::from_unix_timestamp`
+  - `PrimitiveDateTime::timestamp`
+  - `impl Sub<SystemTime> for PrimitiveDateTime`
+  - `impl Sub<PrimitiveDateTime> for SystemTime`
+  - `impl PartialEq<SystemTime> for PrimitiveDateTime`
+  - `impl PartialEq<PrimitiveDateTime> for SystemTime>`
+  - `impl PartialOrd<SystemTime> for PrimitiveDateTime`
+  - `impl PartialOrd<PrimitiveDateTime> for SystemTime>`
+  - `impl From<SystemTime> for PrimitiveDateTime`
+  - `impl From<PrimitiveDateTime> for SystemTime`
+
+### Fixed
+
+- Avoid panics when parsing an empty string (#215).
+- The nanoseconds component of a `Duration` is now always in range. Previously, it was possible (via
+  addition and/or subtraction) to obtain a value that was not internally consistent.
+- `Time::parse` erroneously returned an `InvalidMinute` error when it was actually the second that
+  was invalid.
+- `Date::parse("0000-01-01", "%Y-%m-%d")` incorrectly returned an `Err` (#221).
+
+## Pre-0.2.7
+
+Prior to v0.2.7, changes were listed in GitHub releases.
+
+[keep a changelog]: https://keepachangelog.com/en/1.0.0/
+[semantic versioning]: https://semver.org/spec/v2.0.0.html
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 000000000..fac6b886d
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,814 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstyle"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "basic-toml"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2db21524cad41c5591204d22d75e1970a2d1f71060214ca931dc7d5afe2c14e5"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+
+[[package]]
+name = "bumpalo"
+version = "3.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "4.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e578d6ec4194633722ccf9544794b71b1385c3c027efe0c55db226fc880865c"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4df4df40ec50c46000231c914968278b1eb05098cf8f1b3a518a95030e71d1c7"
+dependencies = [
+ "anstyle",
+ "clap_lex",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+ "quickcheck",
+ "rand",
+ "serde",
+]
+
+[[package]]
+name = "either"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+
+[[package]]
+name = "errno"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "half"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc52e53916c08643f1b56ec082790d1e86a32e58dc5268f897f313fbae7b4872"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d3d0e0f38255e7fa3cf31335b3a56f05febd18025f4db5ef7a0cfb4f8da651f"
+
+[[package]]
+name = "is-terminal"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bad00257d07be169d870ab665980b06cdb366d792ad690bf2e76876dc503455"
+dependencies = [
+ "hermit-abi",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
+
+[[package]]
+name = "js-sys"
+version = "0.3.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a1d36f1235bc969acba30b7f5990b864423a6068a10f7c90ae8f0112e3a59d1"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.152"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
+[[package]]
+name = "memchr"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "num-traits"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quickcheck"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
+dependencies = [
+ "rand",
+]
+
+[[package]]
+name = "quickcheck_macros"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b22a693222d716a9587786f37ac3f6b4faedb5b80c23914e7303ff5a1d8016e9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
+[[package]]
+name = "relative-path"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e898588f33fdd5b9420719948f9f2a32c922a246964576f71ba7f24f80610fbc"
+
+[[package]]
+name = "rstest"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97eeab2f3c0a199bc4be135c36c924b6590b88c377d416494288c14f2db30199"
+dependencies = [
+ "rstest_macros",
+ "rustc_version",
+]
+
+[[package]]
+name = "rstest_macros"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d428f8247852f894ee1be110b375111b586d4fa431f6c46e64ba5a0dcccbe605"
+dependencies = [
+ "cfg-if",
+ "glob",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn 2.0.48",
+ "unicode-ident",
+]
+
+[[package]]
+name = "rstest_reuse"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88530b681abe67924d42cca181d070e3ac20e0740569441a9e35a7cedd2b34a4"
+dependencies = [
+ "quote",
+ "rand",
+ "rustc_version",
+ "syn 2.0.48",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "322394588aaf33c24007e8bb3238ee3e4c5c09c084ab32bc73890b99ff326bca"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0"
+
+[[package]]
+name = "serde"
+version = "1.0.196"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.196"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.48",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d1bd37ce2324cf3bf85e5a25f96eb4baf0d5aa6eba43e7ae8958870c4ec48ed"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_test"
+version = "1.0.176"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a2f49ace1498612d14f7e0b8245519584db8299541dfe31a06374a828d620ab"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "time"
+version = "0.3.36"
+dependencies = [
+ "criterion",
+ "deranged",
+ "itoa",
+ "js-sys",
+ "libc",
+ "num-conv",
+ "num_threads",
+ "powerfmt",
+ "quickcheck",
+ "quickcheck_macros",
+ "rand",
+ "rstest",
+ "rstest_reuse",
+ "serde",
+ "serde_json",
+ "serde_test",
+ "time-core",
+ "time-macros",
+ "trybuild",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+
+[[package]]
+name = "time-macros"
+version = "0.2.18"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "trybuild"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a9d3ba662913483d6722303f619e75ea10b7855b0f8e0d72799cf8621bb488f"
+dependencies = [
+ "basic-toml",
+ "glob",
+ "once_cell",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "termcolor",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "walkdir"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1223296a201415c7fad14792dbefaace9bd52b62d33453ade1c5b5f07555406"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcdc935b63408d58a32f8cc9738a0bffd8f05cc7c002086c6ef20b7312ad9dcd"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.48",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e4c238561b2d428924c49815533a8b9121c664599558a5d9ec51f8a1740a999"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bae1abb6806dc1ad9e560ed242107c0f6c84335f1749dd4e8ddb012ebd5e25a7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.48",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d91413b1c31d7539ba5ef2451af3f0b833a005eb27a631cec32bc0635a8602b"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 000000000..a9adaa426
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,126 @@
+[workspace]
+default-members = ["time"]
+members = ["time", "time-core", "time-macros"]
+resolver = "2"
+
+[workspace.dependencies]
+time-core = { path = "time-core", version = "=0.1.2" }
+time-macros = { path = "time-macros", version = "=0.2.18" }
+
+criterion = { version = "0.5.1", default-features = false }
+deranged = { version = "0.3.9", default-features = false, features = [
+    "powerfmt",
+] }
+itoa = "1.0.1"
+js-sys = "0.3.58"
+libc = "0.2.98"
+num-conv = "0.1.0"
+num_threads = "0.1.2"
+powerfmt = { version = "0.2.0", default-features = false }
+quickcheck = { version = "1.0.3", default-features = false }
+quickcheck_macros = "1.0.0"
+rand = { version = "0.8.4", default-features = false }
+rstest = { version = "0.18.2", default-features = false }
+rstest_reuse = "0.6.0"
+# ^1.0.184 due to serde-rs/serde#2538
+serde = { version = "1.0.184", default-features = false }
+serde_json = "1.0.68"
+serde_test = "1.0.126"
+trybuild = "1.0.68"
+
+[profile.dev]
+debug = 0
+
+[profile.test]
+debug = 2
+
+# Deny-by-default lints: These are lints that indicate a lack of compiler guarantees, future
+# incompatibility (with no guarantees in the meantime) introduce surprising behavior, or are likely
+# to cause undesired behavior. Code that trigger these lints should only be allowed with a
+# compelling reason that is clearly documented.
+
+# Warn-by-default lints: These are lints that indicate possible errors, future incompatibility
+# (with guaranteed behavior in the meantime), or other stylistic issues (including idioms). Code
+# that trigger these lints should not cause undesired behavior and may be allowed as necessary.
+
+# All overrides need higher priority. Any overrides that are for a specific crate need to be done
+# the "traditional" way of using attributes at the crate root.
+
+[workspace.lints.rust]
+ambiguous-glob-reexports = "deny"
+clashing-extern-declarations = "deny"
+const-item-mutation = "deny"
+deref-nullptr = "deny"
+drop-bounds = "deny"
+future-incompatible = "deny"
+hidden-glob-reexports = "deny"
+improper-ctypes = "deny"
+improper-ctypes-definitions = "deny"
+invalid-from-utf8 = "deny"
+invalid-macro-export-arguments = "deny"
+invalid-nan-comparisons = "deny"
+invalid-reference-casting = "deny"
+invalid-value = "deny"
+named-arguments-used-positionally = "deny"
+non-ascii-idents = "deny"
+opaque-hidden-inferred-bound = "deny"
+overlapping-range-endpoints = "deny"
+suspicious-double-ref-op = "deny"
+temporary-cstring-as-ptr = "deny"
+unconditional-recursion = "deny"
+unnameable-test-items = "deny"
+unsafe-op-in-unsafe-fn = "deny"
+unstable-syntax-pre-expansion = "deny"
+
+keyword-idents = "warn"
+let-underscore = "warn"
+macro-use-extern-crate = "warn"
+meta-variable-misuse = "warn"
+missing-abi = "warn"
+missing-copy-implementations = "warn"
+missing-debug-implementations = "warn"
+missing-docs = "warn"
+noop-method-call = "warn"
+single-use-lifetimes = "warn"
+trivial-casts = "warn"
+trivial-numeric-casts = "warn"
+unreachable-pub = "warn"
+unused = { level = "warn", priority = -1 }
+unused-import-braces = "warn"
+unused-lifetimes = "warn"
+unused-qualifications = "warn"
+variant-size-differences = "warn"
+
+unstable-name-collisions = { level = "allow", priority = 1 } # overrides #![deny(future_incompatible)], temporary while `.cast_{un}signed()` is unstable
+
+[workspace.lints.clippy]
+alloc-instead-of-core = "deny"
+std-instead-of-core = "deny"
+undocumented-unsafe-blocks = "deny"
+
+missing-docs-in-private-items = "warn"
+all = { level = "warn", priority = -1 }
+dbg-macro = "warn"
+decimal-literal-representation = "warn"
+explicit-auto-deref = "warn"
+get-unwrap = "warn"
+manual-let-else = "warn"
+missing-enforced-import-renames = "warn"
+nursery = { level = "warn", priority = -1 }
+obfuscated-if-else = "warn"
+print-stdout = "warn"
+semicolon-outside-block = "warn"
+todo = "warn"
+unimplemented = "warn"
+uninlined-format-args = "warn"
+unnested-or-patterns = "warn"
+unwrap-in-result = "warn"
+unwrap-used = "warn"
+use-debug = "warn"
+
+option-if-let-else = { level = "allow", priority = 1 }  # suggests terrible code, overrides #![warn(clippy::nursery)]
+redundant-pub-crate = { level = "allow", priority = 1 } # rust-lang/rust-clippy#5369, overrides #![warn(clippy::nursery)]
+
+[workspace.lints.rustdoc]
+private-doc-tests = "warn"
+unescaped-backticks = "warn"
diff --git a/LICENSE-Apache b/LICENSE-Apache
new file mode 100644
index 000000000..c763a0c9d
--- /dev/null
+++ b/LICENSE-Apache
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 Jacob Pratt et al.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/LICENSE-MIT b/LICENSE-MIT
new file mode 100644
index 000000000..5cc097f1c
--- /dev/null
+++ b/LICENSE-MIT
@@ -0,0 +1,19 @@
+Copyright (c) 2024 Jacob Pratt et al.
+
+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.
diff --git a/README.md b/README.md
new file mode 100644
index 000000000..b2991f93d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,51 @@
+# time
+
+[![minimum rustc: 1.67](https://img.shields.io/badge/minimum%20rustc-1.67-yellowgreen?logo=rust&style=flat-square)](https://www.whatrustisit.com)
+[![version](https://img.shields.io/crates/v/time?color=blue&logo=rust&style=flat-square)](https://crates.io/crates/time)
+[![build status](https://img.shields.io/github/actions/workflow/status/time-rs/time/build.yaml?branch=main&style=flat-square)](https://github.com/time-rs/time/actions)
+[![codecov](https://codecov.io/gh/time-rs/time/branch/main/graph/badge.svg?token=yt4XSmQNKQ)](https://codecov.io/gh/time-rs/time)
+
+Documentation:
+
+- [latest release](https://docs.rs/time)
+- [main branch](https://time-rs.github.io/api/time)
+- [book](https://time-rs.github.io/book)
+
+## Minimum Rust version policy
+
+`time` is guaranteed to compile with the latest stable release of Rust in addition to the two prior
+minor releases. For example, if the latest stable Rust release is 1.70, then `time` is guaranteed to
+compile with Rust 1.68, 1.69, and 1.70.
+
+The minimum supported Rust version may be increased to one of the aforementioned versions if doing
+so provides the end user a benefit. However, the minimum supported Rust version may also be bumped
+to a version four minor releases prior to the most recent stable release if doing so improves code
+quality or maintainability.
+
+For interoperability with third-party crates, it is guaranteed that there exists a version of that
+crate that supports the minimum supported Rust version of `time`. This does not mean that the latest
+version of the third-party crate supports the minimum supported Rust version of `time`.
+
+## Contributing
+
+Contributions are always welcome! If you have an idea, it's best to float it by me before working on
+it to ensure no effort is wasted. If there's already an open issue for it, knock yourself out.
+Internal documentation can be viewed [here](https://time-rs.github.io/internal-api/time).
+
+If you have any questions, feel free to use [Discussions]. Don't hesitate to ask questions — that's
+what I'm here for!
+
+[Discussions]: https://github.com/time-rs/time/discussions
+
+## License
+
+This project is licensed under either of
+
+- [Apache License, Version 2.0](https://github.com/time-rs/time/blob/main/LICENSE-Apache)
+- [MIT license](https://github.com/time-rs/time/blob/main/LICENSE-MIT)
+
+at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in
+time by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
+additional terms or conditions.
diff --git a/benchmarks/date.rs b/benchmarks/date.rs
new file mode 100644
index 000000000..fc1f45015
--- /dev/null
+++ b/benchmarks/date.rs
@@ -0,0 +1,330 @@
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::date;
+use time::{Date, Month, Time, Weekday};
+
+setup_benchmark! {
+    "Date",
+
+    // region: constructors
+    fn from_calendar_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| Date::from_calendar_date(2019, Month::January, 1));
+        ben.iter(|| Date::from_calendar_date(2019, Month::December, 31));
+        ben.iter(|| Date::from_calendar_date(2020, Month::January, 1));
+        ben.iter(|| Date::from_calendar_date(2020, Month::December, 31));
+    }
+
+    fn from_ordinal_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| Date::from_ordinal_date(2019, 1));
+        ben.iter(|| Date::from_ordinal_date(2019, 365));
+        ben.iter(|| Date::from_ordinal_date(2020, 1));
+        ben.iter(|| Date::from_ordinal_date(2020, 366));
+    }
+
+    fn from_iso_week_date(ben: &mut Bencher<'_>) {
+        use Weekday::*;
+        ben.iter(|| Date::from_iso_week_date(2019, 1, Tuesday));
+        ben.iter(|| Date::from_iso_week_date(2020, 1, Tuesday));
+        ben.iter(|| Date::from_iso_week_date(2020, 1, Wednesday));
+        ben.iter(|| Date::from_iso_week_date(2020, 53, Thursday));
+    }
+
+    fn from_julian_day(ben: &mut Bencher<'_>) {
+        ben.iter(|| Date::from_julian_day(-34_803_190));
+        ben.iter(|| Date::from_julian_day(0));
+        ben.iter(|| Date::from_julian_day(2_459_753));
+    }
+    // endregion constructors
+
+    // region: getters
+    fn year(ben: &mut Bencher<'_>) {
+        let d = date!(2019-002);
+        ben.iter(|| d.year());
+    }
+
+    fn month(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).month());
+        ben.iter(|| date!(2019-02-01).month());
+        ben.iter(|| date!(2019-03-01).month());
+        ben.iter(|| date!(2019-04-01).month());
+        ben.iter(|| date!(2019-05-01).month());
+        ben.iter(|| date!(2019-06-01).month());
+        ben.iter(|| date!(2019-07-01).month());
+        ben.iter(|| date!(2019-08-01).month());
+        ben.iter(|| date!(2019-09-01).month());
+        ben.iter(|| date!(2019-10-01).month());
+        ben.iter(|| date!(2019-11-01).month());
+        ben.iter(|| date!(2019-12-01).month());
+    }
+
+    fn day(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).day());
+        ben.iter(|| date!(2019-02-01).day());
+        ben.iter(|| date!(2019-03-01).day());
+        ben.iter(|| date!(2019-04-01).day());
+        ben.iter(|| date!(2019-05-01).day());
+        ben.iter(|| date!(2019-06-01).day());
+        ben.iter(|| date!(2019-07-01).day());
+        ben.iter(|| date!(2019-08-01).day());
+        ben.iter(|| date!(2019-09-01).day());
+        ben.iter(|| date!(2019-10-01).day());
+        ben.iter(|| date!(2019-11-01).day());
+        ben.iter(|| date!(2019-12-01).day());
+    }
+
+    fn ordinal(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).ordinal());
+        ben.iter(|| date!(2019-02-01).ordinal());
+        ben.iter(|| date!(2019-03-01).ordinal());
+        ben.iter(|| date!(2019-04-01).ordinal());
+        ben.iter(|| date!(2019-05-01).ordinal());
+        ben.iter(|| date!(2019-06-01).ordinal());
+        ben.iter(|| date!(2019-07-01).ordinal());
+        ben.iter(|| date!(2019-08-01).ordinal());
+        ben.iter(|| date!(2019-09-01).ordinal());
+        ben.iter(|| date!(2019-10-01).ordinal());
+        ben.iter(|| date!(2019-11-01).ordinal());
+        ben.iter(|| date!(2019-12-01).ordinal());
+    }
+
+    fn iso_week(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).iso_week());
+        ben.iter(|| date!(2019-02-01).iso_week());
+        ben.iter(|| date!(2019-03-01).iso_week());
+        ben.iter(|| date!(2019-04-01).iso_week());
+        ben.iter(|| date!(2019-05-01).iso_week());
+        ben.iter(|| date!(2019-06-01).iso_week());
+        ben.iter(|| date!(2019-07-01).iso_week());
+        ben.iter(|| date!(2019-08-01).iso_week());
+        ben.iter(|| date!(2019-09-01).iso_week());
+        ben.iter(|| date!(2019-10-01).iso_week());
+        ben.iter(|| date!(2019-11-01).iso_week());
+        ben.iter(|| date!(2019-12-01).iso_week());
+    }
+
+    fn sunday_based_week(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).sunday_based_week());
+        ben.iter(|| date!(2019-02-01).sunday_based_week());
+        ben.iter(|| date!(2019-03-01).sunday_based_week());
+        ben.iter(|| date!(2019-04-01).sunday_based_week());
+        ben.iter(|| date!(2019-05-01).sunday_based_week());
+        ben.iter(|| date!(2019-06-01).sunday_based_week());
+        ben.iter(|| date!(2019-07-01).sunday_based_week());
+        ben.iter(|| date!(2019-08-01).sunday_based_week());
+        ben.iter(|| date!(2019-09-01).sunday_based_week());
+        ben.iter(|| date!(2019-10-01).sunday_based_week());
+        ben.iter(|| date!(2019-11-01).sunday_based_week());
+        ben.iter(|| date!(2019-12-01).sunday_based_week());
+    }
+
+    fn monday_based_week(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).monday_based_week());
+        ben.iter(|| date!(2019-02-01).monday_based_week());
+        ben.iter(|| date!(2019-03-01).monday_based_week());
+        ben.iter(|| date!(2019-04-01).monday_based_week());
+        ben.iter(|| date!(2019-05-01).monday_based_week());
+        ben.iter(|| date!(2019-06-01).monday_based_week());
+        ben.iter(|| date!(2019-07-01).monday_based_week());
+        ben.iter(|| date!(2019-08-01).monday_based_week());
+        ben.iter(|| date!(2019-09-01).monday_based_week());
+        ben.iter(|| date!(2019-10-01).monday_based_week());
+        ben.iter(|| date!(2019-11-01).monday_based_week());
+        ben.iter(|| date!(2019-12-01).monday_based_week());
+    }
+
+    fn to_calendar_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).to_calendar_date());
+        ben.iter(|| date!(2019-02-01).to_calendar_date());
+        ben.iter(|| date!(2019-03-01).to_calendar_date());
+        ben.iter(|| date!(2019-04-01).to_calendar_date());
+        ben.iter(|| date!(2019-05-01).to_calendar_date());
+        ben.iter(|| date!(2019-06-01).to_calendar_date());
+        ben.iter(|| date!(2019-07-01).to_calendar_date());
+        ben.iter(|| date!(2019-08-01).to_calendar_date());
+        ben.iter(|| date!(2019-09-01).to_calendar_date());
+        ben.iter(|| date!(2019-10-01).to_calendar_date());
+        ben.iter(|| date!(2019-11-01).to_calendar_date());
+        ben.iter(|| date!(2019-12-01).to_calendar_date());
+    }
+
+    fn to_ordinal_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).to_ordinal_date());
+        ben.iter(|| date!(2019-02-01).to_ordinal_date());
+        ben.iter(|| date!(2019-03-01).to_ordinal_date());
+        ben.iter(|| date!(2019-04-01).to_ordinal_date());
+        ben.iter(|| date!(2019-05-01).to_ordinal_date());
+        ben.iter(|| date!(2019-06-01).to_ordinal_date());
+        ben.iter(|| date!(2019-07-01).to_ordinal_date());
+        ben.iter(|| date!(2019-08-01).to_ordinal_date());
+        ben.iter(|| date!(2019-09-01).to_ordinal_date());
+        ben.iter(|| date!(2019-10-01).to_ordinal_date());
+        ben.iter(|| date!(2019-11-01).to_ordinal_date());
+        ben.iter(|| date!(2019-12-01).to_ordinal_date());
+    }
+
+    fn to_iso_week_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).to_iso_week_date());
+        ben.iter(|| date!(2019-02-01).to_iso_week_date());
+        ben.iter(|| date!(2019-03-01).to_iso_week_date());
+        ben.iter(|| date!(2019-04-01).to_iso_week_date());
+        ben.iter(|| date!(2019-05-01).to_iso_week_date());
+        ben.iter(|| date!(2019-06-01).to_iso_week_date());
+        ben.iter(|| date!(2019-07-01).to_iso_week_date());
+        ben.iter(|| date!(2019-08-01).to_iso_week_date());
+        ben.iter(|| date!(2019-09-01).to_iso_week_date());
+        ben.iter(|| date!(2019-10-01).to_iso_week_date());
+        ben.iter(|| date!(2019-11-01).to_iso_week_date());
+        ben.iter(|| date!(2019-12-01).to_iso_week_date());
+    }
+
+    fn weekday(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).weekday());
+        ben.iter(|| date!(2019-02-01).weekday());
+        ben.iter(|| date!(2019-03-01).weekday());
+        ben.iter(|| date!(2019-04-01).weekday());
+        ben.iter(|| date!(2019-05-01).weekday());
+        ben.iter(|| date!(2019-06-01).weekday());
+        ben.iter(|| date!(2019-07-01).weekday());
+        ben.iter(|| date!(2019-08-01).weekday());
+        ben.iter(|| date!(2019-09-01).weekday());
+        ben.iter(|| date!(2019-10-01).weekday());
+        ben.iter(|| date!(2019-11-01).weekday());
+        ben.iter(|| date!(2019-12-01).weekday());
+    }
+
+    fn next_day(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).next_day());
+        ben.iter(|| date!(2019-02-01).next_day());
+        ben.iter(|| date!(2019-12-31).next_day());
+        ben.iter(|| date!(2020-12-31).next_day());
+        ben.iter(|| Date::MAX.next_day());
+    }
+
+    fn previous_day(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-02).previous_day());
+        ben.iter(|| date!(2019-02-01).previous_day());
+        ben.iter(|| date!(2020-01-01).previous_day());
+        ben.iter(|| date!(2021-01-01).previous_day());
+        ben.iter(|| Date::MIN.previous_day());
+    }
+
+    fn to_julian_day(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).to_julian_day());
+        ben.iter(|| date!(2019-02-01).to_julian_day());
+        ben.iter(|| date!(2019-03-01).to_julian_day());
+        ben.iter(|| date!(2019-04-01).to_julian_day());
+        ben.iter(|| date!(2019-05-01).to_julian_day());
+        ben.iter(|| date!(2019-06-01).to_julian_day());
+        ben.iter(|| date!(2019-07-01).to_julian_day());
+        ben.iter(|| date!(2019-08-01).to_julian_day());
+        ben.iter(|| date!(2019-09-01).to_julian_day());
+        ben.iter(|| date!(2019-10-01).to_julian_day());
+        ben.iter(|| date!(2019-11-01).to_julian_day());
+        ben.iter(|| date!(2019-12-01).to_julian_day());
+    }
+    // endregion getters
+
+    // region: attach time
+    fn midnight(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(1970-01-01).midnight());
+    }
+
+    fn with_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(1970-01-01).with_time(Time::MIDNIGHT));
+    }
+
+    fn with_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(1970-01-01).with_hms(0, 0, 0));
+    }
+
+    fn with_hms_milli(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(1970-01-01).with_hms_milli(0, 0, 0, 0));
+    }
+
+    fn with_hms_micro(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(1970-01-01).with_hms_micro(0, 0, 0, 0));
+    }
+
+    fn with_hms_nano(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(1970-01-01).with_hms_nano(0, 0, 0, 0));
+    }
+    // endregion attach time
+
+    // region: trait impls
+    fn add(ben: &mut Bencher<'_>) {
+        let dt = 5.days();
+        ben.iter(|| date!(2019-01-01) + dt);
+    }
+
+    fn add_std(ben: &mut Bencher<'_>) {
+        let dt = 5.std_days();
+        ben.iter(|| date!(2019-01-01) + dt);
+    }
+
+    fn add_assign(ben: &mut Bencher<'_>) {
+        let dt = 1.days();
+        iter_batched_ref!(
+            ben,
+            || date!(2019-12-31),
+            [|date| *date += dt]
+        );
+    }
+
+    fn add_assign_std(ben: &mut Bencher<'_>) {
+        let dt = 1.std_days();
+        iter_batched_ref!(
+            ben,
+            || date!(2019-12-31),
+            [|date| *date += dt]
+        );
+    }
+
+    fn sub(ben: &mut Bencher<'_>) {
+        let dt = 5.days();
+        ben.iter(|| date!(2019-01-06) - dt);
+    }
+
+    fn sub_std(ben: &mut Bencher<'_>) {
+        let dt = 5.std_days();
+        ben.iter(|| date!(2019-01-06) - dt);
+    }
+
+    fn sub_assign(ben: &mut Bencher<'_>) {
+        let dt = 1.days();
+        iter_batched_ref!(
+            ben,
+            || date!(2019-12-31),
+            [|date| *date -= dt]
+        );
+    }
+
+    fn sub_assign_std(ben: &mut Bencher<'_>) {
+        let dt = 1.std_days();
+        iter_batched_ref!(
+            ben,
+            || date!(2019-12-31),
+            [|date| *date -= dt]
+        );
+    }
+
+    fn sub_self(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-02) - date!(2019-01-01));
+    }
+
+    fn partial_ord(ben: &mut Bencher<'_>) {
+        let first = date!(2019-01-01);
+        let second = date!(2019-01-02);
+        ben.iter(|| first.partial_cmp(&first));
+        ben.iter(|| first.partial_cmp(&second));
+        ben.iter(|| second.partial_cmp(&first));
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        let first = date!(2019-01-01);
+        let second = date!(2019-01-02);
+        ben.iter(|| first.cmp(&first));
+        ben.iter(|| first.cmp(&second));
+        ben.iter(|| second.cmp(&first));
+    }
+    // endregion trait impls
+}
diff --git a/benchmarks/duration.rs b/benchmarks/duration.rs
new file mode 100644
index 000000000..558eba782
--- /dev/null
+++ b/benchmarks/duration.rs
@@ -0,0 +1,728 @@
+use std::time::Duration as StdDuration;
+
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::Duration;
+
+setup_benchmark! {
+    "Duration",
+
+    // region: is_{sign}
+    fn is_zero(ben: &mut Bencher<'_>) {
+        let a = (-1).nanoseconds();
+        let b = 0.seconds();
+        let c = 1.nanoseconds();
+        ben.iter(|| a.is_zero());
+        ben.iter(|| b.is_zero());
+        ben.iter(|| c.is_zero());
+    }
+
+    fn is_negative(ben: &mut Bencher<'_>) {
+        let a = (-1).seconds();
+        let b = 0.seconds();
+        let c = 1.seconds();
+        ben.iter(|| a.is_negative());
+        ben.iter(|| b.is_negative());
+        ben.iter(|| c.is_negative());
+    }
+
+    fn is_positive(ben: &mut Bencher<'_>) {
+        let a = (-1).seconds();
+        let b = 0.seconds();
+        let c = 1.seconds();
+        ben.iter(|| a.is_positive());
+        ben.iter(|| b.is_positive());
+        ben.iter(|| c.is_positive());
+    }
+    // endregion is_{sign}
+
+    // region: abs
+    fn abs(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.seconds();
+        let c = (-1).seconds();
+        ben.iter(|| a.abs());
+        ben.iter(|| b.abs());
+        ben.iter(|| c.abs());
+    }
+
+    fn unsigned_abs(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.seconds();
+        let c = (-1).seconds();
+        ben.iter(|| a.unsigned_abs());
+        ben.iter(|| b.unsigned_abs());
+        ben.iter(|| c.unsigned_abs());
+    }
+    // endregion abs
+
+    // region: constructors
+    fn new(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::new(1, 0));
+        ben.iter(|| Duration::new(-1, 0));
+        ben.iter(|| Duration::new(1, 2_000_000_000));
+
+        ben.iter(|| Duration::new(0, 0));
+        ben.iter(|| Duration::new(0, 1_000_000_000));
+        ben.iter(|| Duration::new(-1, 1_000_000_000));
+        ben.iter(|| Duration::new(-2, 1_000_000_000));
+
+        ben.iter(|| Duration::new(1, -1));
+        ben.iter(|| Duration::new(-1, 1));
+        ben.iter(|| Duration::new(1, 1));
+        ben.iter(|| Duration::new(-1, -1));
+        ben.iter(|| Duration::new(0, 1));
+        ben.iter(|| Duration::new(0, -1));
+
+        ben.iter(|| Duration::new(-1, 1_400_000_000));
+        ben.iter(|| Duration::new(-2, 1_400_000_000));
+        ben.iter(|| Duration::new(-3, 1_400_000_000));
+        ben.iter(|| Duration::new(1, -1_400_000_000));
+        ben.iter(|| Duration::new(2, -1_400_000_000));
+        ben.iter(|| Duration::new(3, -1_400_000_000));
+    }
+
+    fn weeks(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::weeks(1));
+        ben.iter(|| Duration::weeks(2));
+        ben.iter(|| Duration::weeks(-1));
+        ben.iter(|| Duration::weeks(-2));
+    }
+
+    fn days(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::days(1));
+        ben.iter(|| Duration::days(2));
+        ben.iter(|| Duration::days(-1));
+        ben.iter(|| Duration::days(-2));
+    }
+
+    fn hours(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::hours(1));
+        ben.iter(|| Duration::hours(2));
+        ben.iter(|| Duration::hours(-1));
+        ben.iter(|| Duration::hours(-2));
+    }
+
+    fn minutes(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::minutes(1));
+        ben.iter(|| Duration::minutes(2));
+        ben.iter(|| Duration::minutes(-1));
+        ben.iter(|| Duration::minutes(-2));
+    }
+
+    fn seconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::seconds(1));
+        ben.iter(|| Duration::seconds(2));
+        ben.iter(|| Duration::seconds(-1));
+        ben.iter(|| Duration::seconds(-2));
+    }
+
+    fn seconds_f64(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::seconds_f64(0.5));
+        ben.iter(|| Duration::seconds_f64(-0.5));
+    }
+
+    fn seconds_f32(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::seconds_f32(0.5));
+        ben.iter(|| Duration::seconds_f32(-0.5));
+    }
+
+    fn saturating_seconds_f64(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::saturating_seconds_f64(0.5));
+        ben.iter(|| Duration::saturating_seconds_f64(-0.5));
+    }
+
+    fn saturating_seconds_f32(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::saturating_seconds_f32(0.5));
+        ben.iter(|| Duration::saturating_seconds_f32(-0.5));
+    }
+
+    fn checked_seconds_f64(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::checked_seconds_f64(0.5));
+        ben.iter(|| Duration::checked_seconds_f64(-0.5));
+    }
+
+    fn checked_seconds_f32(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::checked_seconds_f32(0.5));
+        ben.iter(|| Duration::checked_seconds_f32(-0.5));
+    }
+
+    fn milliseconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::milliseconds(1));
+        ben.iter(|| Duration::milliseconds(-1));
+    }
+
+    fn microseconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::microseconds(1));
+        ben.iter(|| Duration::microseconds(-1));
+    }
+
+    fn nanoseconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::nanoseconds(1));
+        ben.iter(|| Duration::nanoseconds(-1));
+    }
+
+    fn whole_weeks(ben: &mut Bencher<'_>) {
+        let a = Duration::weeks(1);
+        let b = Duration::weeks(-1);
+        let c = Duration::days(6);
+        let d = Duration::days(-6);
+        ben.iter(|| a.whole_weeks());
+        ben.iter(|| b.whole_weeks());
+        ben.iter(|| c.whole_weeks());
+        ben.iter(|| d.whole_weeks());
+    }
+    // endregion constructors
+
+    // region: getters
+    fn whole_days(ben: &mut Bencher<'_>) {
+        let a = Duration::days(1);
+        let b = Duration::days(-1);
+        let c = Duration::hours(23);
+        let d = Duration::hours(-23);
+        ben.iter(|| a.whole_days());
+        ben.iter(|| b.whole_days());
+        ben.iter(|| c.whole_days());
+        ben.iter(|| d.whole_days());
+    }
+
+    fn whole_hours(ben: &mut Bencher<'_>) {
+        let a = Duration::hours(1);
+        let b = Duration::hours(-1);
+        let c = Duration::minutes(59);
+        let d = Duration::minutes(-59);
+        ben.iter(|| a.whole_hours());
+        ben.iter(|| b.whole_hours());
+        ben.iter(|| c.whole_hours());
+        ben.iter(|| d.whole_hours());
+    }
+
+    fn whole_minutes(ben: &mut Bencher<'_>) {
+        let a = 1.minutes();
+        let b = (-1).minutes();
+        let c = 59.seconds();
+        let d = (-59).seconds();
+        ben.iter(|| a.whole_minutes());
+        ben.iter(|| b.whole_minutes());
+        ben.iter(|| c.whole_minutes());
+        ben.iter(|| d.whole_minutes());
+    }
+
+    fn whole_seconds(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.minutes();
+        let d = (-1).minutes();
+        ben.iter(|| a.whole_seconds());
+        ben.iter(|| b.whole_seconds());
+        ben.iter(|| c.whole_seconds());
+        ben.iter(|| d.whole_seconds());
+    }
+
+    fn as_seconds_f64(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.minutes();
+        let d = (-1).minutes();
+        let e = 1.5.seconds();
+        let f = (-1.5).seconds();
+        ben.iter(|| a.as_seconds_f64());
+        ben.iter(|| b.as_seconds_f64());
+        ben.iter(|| c.as_seconds_f64());
+        ben.iter(|| d.as_seconds_f64());
+        ben.iter(|| e.as_seconds_f64());
+        ben.iter(|| f.as_seconds_f64());
+    }
+
+    fn as_seconds_f32(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.minutes();
+        let d = (-1).minutes();
+        let e = 1.5.seconds();
+        let f = (-1.5).seconds();
+        ben.iter(|| a.as_seconds_f32());
+        ben.iter(|| b.as_seconds_f32());
+        ben.iter(|| c.as_seconds_f32());
+        ben.iter(|| d.as_seconds_f32());
+        ben.iter(|| e.as_seconds_f32());
+        ben.iter(|| f.as_seconds_f32());
+    }
+
+    fn whole_milliseconds(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.milliseconds();
+        let d = (-1).milliseconds();
+        ben.iter(|| a.whole_milliseconds());
+        ben.iter(|| b.whole_milliseconds());
+        ben.iter(|| c.whole_milliseconds());
+        ben.iter(|| d.whole_milliseconds());
+    }
+
+    fn subsec_milliseconds(ben: &mut Bencher<'_>) {
+        let a = 1.4.seconds();
+        let b = (-1.4).seconds();
+        ben.iter(|| a.subsec_milliseconds());
+        ben.iter(|| b.subsec_milliseconds());
+    }
+
+    fn whole_microseconds(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = (-1).milliseconds();
+        let c = 1.microseconds();
+        let d = (-1).microseconds();
+        ben.iter(|| a.whole_microseconds());
+        ben.iter(|| b.whole_microseconds());
+        ben.iter(|| c.whole_microseconds());
+        ben.iter(|| d.whole_microseconds());
+    }
+
+    fn subsec_microseconds(ben: &mut Bencher<'_>) {
+        let a = 1.0004.seconds();
+        let b = (-1.0004).seconds();
+        ben.iter(|| a.subsec_microseconds());
+        ben.iter(|| b.subsec_microseconds());
+    }
+
+    fn whole_nanoseconds(ben: &mut Bencher<'_>) {
+        let a = 1.microseconds();
+        let b = (-1).microseconds();
+        let c = 1.nanoseconds();
+        let d = (-1).nanoseconds();
+        ben.iter(|| a.whole_nanoseconds());
+        ben.iter(|| b.whole_nanoseconds());
+        ben.iter(|| c.whole_nanoseconds());
+        ben.iter(|| d.whole_nanoseconds());
+    }
+
+    fn subsec_nanoseconds(ben: &mut Bencher<'_>) {
+        let a = 1.000_000_4.seconds();
+        let b = (-1.000_000_4).seconds();
+        ben.iter(|| a.subsec_nanoseconds());
+        ben.iter(|| b.subsec_nanoseconds());
+    }
+    // endregion getters
+
+    // region: checked arithmetic
+    fn checked_add(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MAX;
+        let c = (-5).seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = 5.seconds();
+
+        ben.iter(|| a.checked_add(a2));
+        ben.iter(|| b.checked_add(b2));
+        ben.iter(|| c.checked_add(c2));
+    }
+
+    fn checked_sub(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MIN;
+        let c = 5.seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = 10.seconds();
+
+        ben.iter(|| a.checked_sub(a2));
+        ben.iter(|| b.checked_sub(b2));
+        ben.iter(|| c.checked_sub(c2));
+    }
+
+    fn checked_mul(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MAX;
+        ben.iter(|| a.checked_mul(2));
+        ben.iter(|| b.checked_mul(2));
+    }
+
+    fn checked_div(ben: &mut Bencher<'_>) {
+        let a = 10.seconds();
+        ben.iter(|| a.checked_div(2));
+        ben.iter(|| a.checked_div(0));
+    }
+    // endregion checked arithmetic
+
+    // region: saturating arithmetic
+    fn saturating_add(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MAX;
+        let c = Duration::MIN;
+        let d = (-5).seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = (-1).nanoseconds();
+        let d2 = 5.seconds();
+
+        ben.iter(|| a.saturating_add(a2));
+        ben.iter(|| b.saturating_add(b2));
+        ben.iter(|| c.saturating_add(c2));
+        ben.iter(|| d.saturating_add(d2));
+    }
+
+    fn saturating_sub(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MIN;
+        let c = Duration::MAX;
+        let d = 5.seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = (-1).nanoseconds();
+        let d2 = 10.seconds();
+
+        ben.iter(|| a.saturating_sub(a2));
+        ben.iter(|| b.saturating_sub(b2));
+        ben.iter(|| c.saturating_sub(c2));
+        ben.iter(|| d.saturating_sub(d2));
+    }
+
+    fn saturating_mul(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = 5.seconds();
+        let c = 5.seconds();
+        let d = Duration::MAX;
+        let e = Duration::MIN;
+        let f = Duration::MAX;
+        let g = Duration::MIN;
+
+        ben.iter(|| a.saturating_mul(2));
+        ben.iter(|| b.saturating_mul(-2));
+        ben.iter(|| c.saturating_mul(0));
+        ben.iter(|| d.saturating_mul(2));
+        ben.iter(|| e.saturating_mul(2));
+        ben.iter(|| f.saturating_mul(-2));
+        ben.iter(|| g.saturating_mul(-2));
+    }
+    // endregion saturating arithmetic
+
+    // region: trait impls
+    fn try_from_std_duration(ben: &mut Bencher<'_>) {
+        let a = 0.std_seconds();
+        let b = 1.std_seconds();
+        ben.iter(|| Duration::try_from(a));
+        ben.iter(|| Duration::try_from(b));
+    }
+
+    fn try_to_std_duration(ben: &mut Bencher<'_>) {
+        let a = 0.seconds();
+        let b = 1.seconds();
+        let c = (-1).seconds();
+        ben.iter(|| StdDuration::try_from(a));
+        ben.iter(|| StdDuration::try_from(b));
+        ben.iter(|| StdDuration::try_from(c));
+    }
+
+    fn add(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 2.seconds();
+        let c = 500.milliseconds();
+        let d = (-1).seconds();
+        ben.iter(|| a + b + c + d);
+    }
+
+    fn add_std(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 2.std_seconds();
+        ben.iter(|| a + b);
+    }
+
+    fn std_add(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = 2.seconds();
+        ben.iter(|| a + b);
+    }
+
+    fn add_assign(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 500.milliseconds();
+        let c = (-1).seconds();
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration += a,
+                |duration| *duration += b,
+                |duration| *duration += c,
+            ]
+        );
+    }
+
+    fn add_assign_std(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = 500.std_milliseconds();
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration += a,
+                |duration| *duration += b,
+            ]
+        );
+    }
+
+    fn neg(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 0.seconds();
+        ben.iter(|| -a);
+        ben.iter(|| -b);
+        ben.iter(|| -c);
+    }
+
+    fn sub(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 1.seconds();
+        let c = 1_500.milliseconds();
+        let d = 500.milliseconds();
+        let e = 1.seconds();
+        let f = (-1).seconds();
+        ben.iter(|| a - b);
+        ben.iter(|| b - c);
+        ben.iter(|| c - d);
+        ben.iter(|| d - e);
+        ben.iter(|| e - f);
+        ben.iter(|| f - a);
+    }
+
+    fn sub_std(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 2.std_seconds();
+        ben.iter(|| a - b);
+    }
+
+    fn std_sub(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = 2.seconds();
+        ben.iter(|| a - b);
+    }
+
+    fn sub_assign(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 500.milliseconds();
+        let c = (-1).seconds();
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration -= a,
+                |duration| *duration -= b,
+                |duration| *duration -= c,
+            ]
+        );
+    }
+
+    fn mul_int(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d * 2);
+        ben.iter(|| d * -2);
+    }
+
+    fn mul_int_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration *= 2,
+                |duration| *duration *= -2,
+            ]
+        );
+    }
+
+    fn int_mul(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| 2 * d);
+        ben.iter(|| -2 * d);
+    }
+
+    fn div_int(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d / 2);
+        ben.iter(|| d / -2);
+    }
+
+    fn div_int_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration /= 2,
+                |duration| *duration /= -2,
+            ]
+        );
+    }
+
+    fn div(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.5.seconds();
+        ben.iter(|| a / b);
+    }
+
+    fn mul_float(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d * 1.5_f32);
+        ben.iter(|| d * 2.5_f32);
+        ben.iter(|| d * -1.5_f32);
+        ben.iter(|| d * 0_f32);
+        ben.iter(|| d * 1.5_f64);
+        ben.iter(|| d * 2.5_f64);
+        ben.iter(|| d * -1.5_f64);
+        ben.iter(|| d * 0_f64);
+    }
+
+    fn float_mul(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| 1.5_f32 * d);
+        ben.iter(|| 2.5_f32 * d);
+        ben.iter(|| -1.5_f32 * d);
+        ben.iter(|| 0_f32 * d);
+        ben.iter(|| 1.5_f64 * d);
+        ben.iter(|| 2.5_f64 * d);
+        ben.iter(|| -1.5_f64 * d);
+        ben.iter(|| 0_f64 * d);
+    }
+
+    fn mul_float_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration *= 1.5_f32,
+                |duration| *duration *= 2.5_f32,
+                |duration| *duration *= -1.5_f32,
+                |duration| *duration *= 3.15_f32,
+                |duration| *duration *= 1.5_f64,
+                |duration| *duration *= 2.5_f64,
+                |duration| *duration *= -1.5_f64,
+                |duration| *duration *= 0_f64,
+            ]
+        );
+    }
+
+    fn div_float(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d / 1_f32);
+        ben.iter(|| d / 2_f32);
+        ben.iter(|| d / -1_f32);
+        ben.iter(|| d / 1_f64);
+        ben.iter(|| d / 2_f64);
+        ben.iter(|| d / -1_f64);
+    }
+
+    fn div_float_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 10.seconds(),
+            [
+                |duration| *duration /= 1_f32,
+                |duration| *duration /= 2_f32,
+                |duration| *duration /= -1_f32,
+                |duration| *duration /= 1_f64,
+                |duration| *duration /= 2_f64,
+                |duration| *duration /= -1_f64,
+            ]
+        );
+    }
+
+    fn partial_eq(ben: &mut Bencher<'_>) {
+        let a = 1.minutes();
+        let b = (-1).minutes();
+        let c = 40.seconds();
+        ben.iter(|| a == b);
+        ben.iter(|| c == a);
+    }
+
+    fn partial_eq_std(ben: &mut Bencher<'_>) {
+        let a = (-1).seconds();
+        let b = 1.std_seconds();
+        let c = (-1).minutes();
+        let d = 1.std_minutes();
+        let e = 40.seconds();
+        ben.iter(|| a == b);
+        ben.iter(|| c == d);
+        ben.iter(|| e == d);
+    }
+
+    fn std_partial_eq(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = (-1).seconds();
+        let c = 1.std_minutes();
+        let d = (-1).minutes();
+        let e = 40.std_seconds();
+        let f = 1.minutes();
+        ben.iter(|| a == b);
+        ben.iter(|| c == d);
+        ben.iter(|| e == f);
+    }
+
+    fn partial_ord(ben: &mut Bencher<'_>) {
+        let a = 0.seconds();
+        let b = 1.seconds();
+        let c = (-1).seconds();
+        let d = 1.minutes();
+        let e = (-1).minutes();
+        ben.iter(|| a.partial_cmp(&a));
+        ben.iter(|| b.partial_cmp(&a));
+        ben.iter(|| b.partial_cmp(&c));
+        ben.iter(|| c.partial_cmp(&b));
+        ben.iter(|| a.partial_cmp(&c));
+        ben.iter(|| a.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&a));
+        ben.iter(|| d.partial_cmp(&b));
+        ben.iter(|| e.partial_cmp(&c));
+    }
+
+    fn partial_ord_std(ben: &mut Bencher<'_>) {
+        let a = 0.seconds();
+        let b = 0.std_seconds();
+        let c = 1.seconds();
+        let d = (-1).seconds();
+        let e = 1.std_seconds();
+        let f = 1.minutes();
+        let g = u64::MAX.std_seconds();
+        ben.iter(|| a.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&b));
+        ben.iter(|| d.partial_cmp(&e));
+        ben.iter(|| a.partial_cmp(&e));
+        ben.iter(|| d.partial_cmp(&b));
+        ben.iter(|| f.partial_cmp(&e));
+        ben.iter(|| a.partial_cmp(&g));
+    }
+
+    fn std_partial_ord(ben: &mut Bencher<'_>) {
+        let a = 0.std_seconds();
+        let b = 0.seconds();
+        let c = 1.std_seconds();
+        let d = (-1).seconds();
+        let e = 1.seconds();
+        let f = 1.std_minutes();
+        ben.iter(|| a.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&d));
+        ben.iter(|| a.partial_cmp(&d));
+        ben.iter(|| a.partial_cmp(&e));
+        ben.iter(|| f.partial_cmp(&e));
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.seconds();
+        let c = (-1).seconds();
+        let d = 1.minutes();
+        let e = (-1).minutes();
+        ben.iter(|| a > b);
+        ben.iter(|| a > c);
+        ben.iter(|| c < a);
+        ben.iter(|| b > c);
+        ben.iter(|| b < a);
+        ben.iter(|| c < b);
+        ben.iter(|| d > a);
+        ben.iter(|| e < c);
+    }
+    // endregion trait impls
+}
diff --git a/benchmarks/formatting.rs b/benchmarks/formatting.rs
new file mode 100644
index 000000000..66dc5d179
--- /dev/null
+++ b/benchmarks/formatting.rs
@@ -0,0 +1,191 @@
+use std::io;
+
+use criterion::Bencher;
+use time::format_description;
+use time::format_description::well_known::{Rfc2822, Rfc3339};
+use time::macros::{date, datetime, format_description as fd, offset, time};
+
+setup_benchmark! {
+    "Formatting",
+
+    fn format_rfc3339(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($value:expr) => {
+                $value.format_into(&mut io::sink(), &Rfc3339)
+            }
+        }
+
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.1 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.12 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_4 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_45 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_7 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_78 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_789 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_789 -01:02)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_789 +01:02)));
+    }
+
+    fn format_rfc2822(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($value:expr) => {
+                $value.format_into(&mut io::sink(), &Rfc2822)
+            }
+        }
+
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 +06:07)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 -06:07)));
+    }
+
+
+    fn format_time(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($format:expr) => {
+                time!(13:02:03.456_789_012).format_into(
+                    &mut io::sink(),
+                    &$format,
+                )
+            }
+        }
+
+        ben.iter(|| item!(fd!("[hour]")));
+        ben.iter(|| item!(fd!("[hour repr:12]")));
+        ben.iter(|| item!(fd!("[hour repr:12 padding:none]")));
+        ben.iter(|| item!(fd!("[hour repr:12 padding:space]")));
+        ben.iter(|| item!(fd!("[hour repr:24]")));
+        ben.iter(|| item!(fd!("[hour repr:24]")));
+        ben.iter(|| item!(fd!("[hour repr:24 padding:none]")));
+        ben.iter(|| item!(fd!("[hour repr:24 padding:space]")));
+        ben.iter(|| item!(fd!("[minute]")));
+        ben.iter(|| item!(fd!("[minute padding:none]")));
+        ben.iter(|| item!(fd!("[minute padding:space]")));
+        ben.iter(|| item!(fd!("[minute padding:zero]")));
+        ben.iter(|| item!(fd!("[period]")));
+        ben.iter(|| item!(fd!("[period case:upper]")));
+        ben.iter(|| item!(fd!("[period case:lower]")));
+        ben.iter(|| item!(fd!("[second]")));
+        ben.iter(|| item!(fd!("[second padding:none]")));
+        ben.iter(|| item!(fd!("[second padding:space]")));
+        ben.iter(|| item!(fd!("[second padding:zero]")));
+        ben.iter(|| item!(fd!("[subsecond]")));
+        ben.iter(|| item!(fd!("[subsecond digits:1]")));
+        ben.iter(|| item!(fd!("[subsecond digits:2]")));
+        ben.iter(|| item!(fd!("[subsecond digits:3]")));
+        ben.iter(|| item!(fd!("[subsecond digits:4]")));
+        ben.iter(|| item!(fd!("[subsecond digits:5]")));
+        ben.iter(|| item!(fd!("[subsecond digits:6]")));
+        ben.iter(|| item!(fd!("[subsecond digits:7]")));
+        ben.iter(|| item!(fd!("[subsecond digits:8]")));
+        ben.iter(|| item!(fd!("[subsecond digits:9]")));
+        ben.iter(|| item!(fd!("[subsecond digits:1+]")));
+    }
+
+    fn display_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| time!(0:00).to_string());
+        ben.iter(|| time!(23:59).to_string());
+        ben.iter(|| time!(23:59:59).to_string());
+        ben.iter(|| time!(0:00:01).to_string());
+        ben.iter(|| time!(0:00:00.001).to_string());
+        ben.iter(|| time!(0:00:00.000_001).to_string());
+        ben.iter(|| time!(0:00:00.000_000_001).to_string());
+    }
+
+    fn format_date(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($format:expr) => {
+                date!(2019-12-31).format_into(&mut io::sink(), &$format)
+            }
+        }
+
+        ben.iter(|| item!(fd!("[day]")));
+        ben.iter(|| item!(fd!("[month]")));
+        ben.iter(|| item!(fd!("[month repr:short]")));
+        ben.iter(|| item!(fd!("[month repr:long]")));
+        ben.iter(|| item!(fd!("[ordinal]")));
+        ben.iter(|| item!(fd!("[weekday]")));
+        ben.iter(|| item!(fd!("[weekday repr:short]")));
+        ben.iter(|| item!(fd!("[weekday repr:sunday]")));
+        ben.iter(|| item!(fd!("[weekday repr:sunday one_indexed:false]")));
+        ben.iter(|| item!(fd!("[weekday repr:monday]")));
+        ben.iter(|| item!(fd!("[weekday repr:monday one_indexed:false]")));
+        ben.iter(|| item!(fd!("[week_number]")));
+        ben.iter(|| item!(fd!("[week_number padding:none]")));
+        ben.iter(|| item!(fd!("[week_number padding:space]")));
+        ben.iter(|| item!(fd!("[week_number repr:sunday]")));
+        ben.iter(|| item!(fd!("[week_number repr:monday]")));
+        ben.iter(|| item!(fd!("[year]")));
+        ben.iter(|| item!(fd!("[year base:iso_week]")));
+        ben.iter(|| item!(fd!("[year sign:mandatory]")));
+        ben.iter(|| item!(fd!("[year base:iso_week sign:mandatory]")));
+        ben.iter(|| item!(fd!("[year repr:last_two]")));
+        ben.iter(|| item!(fd!("[year base:iso_week repr:last_two]")));
+    }
+
+    fn display_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).to_string());
+        ben.iter(|| date!(2019-12-31).to_string());
+        ben.iter(|| date!(-4713-11-24).to_string());
+        ben.iter(|| date!(-0001-01-01).to_string());
+    }
+
+    fn format_offset(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($value:expr, $format:expr) => {
+                $value.format_into(&mut io::sink(), &$format)
+            }
+        }
+
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_hour sign:automatic]")));
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_hour sign:mandatory]")));
+        ben.iter(|| item!(offset!(-01:02:03), fd!("[offset_hour sign:automatic]")));
+        ben.iter(|| item!(offset!(-01:02:03), fd!("[offset_hour sign:mandatory]")));
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_minute]")));
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_second]")));
+    }
+
+    fn display_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| offset!(UTC).to_string());
+        ben.iter(|| offset!(+0:00:01).to_string());
+        ben.iter(|| offset!(-0:00:01).to_string());
+        ben.iter(|| offset!(+1).to_string());
+        ben.iter(|| offset!(-1).to_string());
+        ben.iter(|| offset!(+23:59).to_string());
+        ben.iter(|| offset!(-23:59).to_string());
+        ben.iter(|| offset!(+23:59:59).to_string());
+        ben.iter(|| offset!(-23:59:59).to_string());
+    }
+
+    fn format_pdt(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            datetime!(1970-01-01 0:00).format_into(
+                &mut io::sink(),
+                fd!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]"),
+            )
+        });
+    }
+
+    fn display_pdt(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1970-01-01 0:00).to_string());
+        ben.iter(|| datetime!(1970-01-01 0:00:01).to_string());
+    }
+
+    fn format_odt(ben: &mut Bencher<'_>) {
+        // We can't currently handle escaped line breaks in the format description macro.
+        let format_description = format_description::parse(
+            "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond] [offset_hour \
+            sign:mandatory]:[offset_minute]:[offset_second]",
+        ).expect("invalid format description");
+
+        ben.iter(|| {
+            datetime!(1970-01-01 0:00 UTC).format_into(&mut io::sink(), &format_description)
+        });
+    }
+
+    fn display_odt(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1970-01-01 0:00 UTC).to_string());
+    }
+}
diff --git a/benchmarks/instant.rs b/benchmarks/instant.rs
new file mode 100644
index 000000000..f05af3487
--- /dev/null
+++ b/benchmarks/instant.rs
@@ -0,0 +1,93 @@
+#![allow(deprecated)]
+
+use std::time::Instant as StdInstant;
+
+use criterion::Bencher;
+use time::ext::NumericalDuration;
+use time::{Duration, Instant};
+
+setup_benchmark! {
+    "Instant",
+
+    // region: checked arithmetic
+    fn checked_add(ben: &mut Bencher<'_>) {
+        let instant = Instant::now();
+        let dt = 5.seconds();
+        ben.iter(|| instant.checked_add(dt));
+    }
+
+    fn checked_sub(ben: &mut Bencher<'_>) {
+        let instant = Instant::now();
+        let dt = 5.seconds();
+        ben.iter(|| instant.checked_sub(dt));
+    }
+    // endregion checked arithmetic
+
+    // region: trait impls
+    fn sub(ben: &mut Bencher<'_>) {
+        let start: Instant = Instant::now();
+        let end: Instant = start + 1.milliseconds();
+        ben.iter(|| end - start);
+    }
+
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let start = Instant::now();
+        let dt: Duration = 1.seconds();
+        ben.iter(|| start + dt);
+    }
+
+    fn std_add_duration(ben: &mut Bencher<'_>) {
+        let start = StdInstant::now();
+        let dt: Duration = 1.milliseconds();
+        ben.iter(|| start + dt);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 1.milliseconds();
+        iter_batched_ref!(
+            ben,
+            Instant::now,
+            [|start| *start += dt]
+        );
+    }
+
+    fn std_add_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 1.milliseconds();
+        iter_batched_ref!(
+            ben,
+            StdInstant::now,
+            [|start| *start += dt]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let instant = Instant::now();
+        let dt: Duration = 100.milliseconds();
+        ben.iter(|| instant - dt);
+    }
+
+    fn std_sub_duration(ben: &mut Bencher<'_>) {
+        let instant = StdInstant::now();
+        let dt: Duration = 100.milliseconds();
+        ben.iter(|| instant - dt);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 100.milliseconds();
+        iter_batched_ref!(
+            ben,
+            Instant::now,
+            [|instant| *instant -= dt]
+        );
+    }
+
+    fn std_sub_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 100.milliseconds();
+        iter_batched_ref!(
+            ben,
+            StdInstant::now,
+            [|instant| *instant -= dt]
+        );
+    }
+    // endregion trait impls
+}
diff --git a/benchmarks/main.rs b/benchmarks/main.rs
new file mode 100644
index 000000000..c9cb497fa
--- /dev/null
+++ b/benchmarks/main.rs
@@ -0,0 +1,104 @@
+//! Benchmarks for `time`.
+//!
+//! These benchmarks are not very precise, but they're good enough to catch major performance
+//! regressions. Run them if you think that may be the case. CI **does not** run benchmarks.
+
+#![allow(
+    clippy::missing_docs_in_private_items,
+    clippy::std_instead_of_core, // irrelevant for benchmarks
+    clippy::std_instead_of_alloc, // irrelevant for benchmarks
+    clippy::alloc_instead_of_core, // irrelevant for benchmarks
+)]
+
+#[cfg(not(all(
+    feature = "default",
+    feature = "alloc",
+    feature = "formatting",
+    feature = "large-dates",
+    feature = "local-offset",
+    feature = "macros",
+    feature = "parsing",
+    feature = "quickcheck",
+    feature = "serde-human-readable",
+    feature = "serde-well-known",
+    feature = "std",
+    feature = "rand",
+    feature = "serde",
+    bench,
+)))]
+compile_error!(
+    "benchmarks must be run as `RUSTFLAGS=\"--cfg bench\" cargo criterion --all-features`"
+);
+
+macro_rules! setup_benchmark {
+    (
+        $group_prefix:literal,
+        $(
+            $(#[$fn_attr:meta])*
+            fn $fn_name:ident ($bencher:ident : $bencher_type:ty)
+            $code:block
+        )*
+    ) => {
+        $(
+            $(#[$fn_attr])*
+            fn $fn_name(
+                c: &mut ::criterion::Criterion
+            ) {
+                c.bench_function(
+                    concat!($group_prefix, ": ", stringify!($fn_name)),
+                    |$bencher: $bencher_type| $code
+                );
+            }
+        )*
+
+        ::criterion::criterion_group! {
+            name = benches;
+            config = ::criterion::Criterion::default()
+                // Set a stricter statistical significance threshold ("p-value")
+                // for deciding what's an actual performance change vs. noise.
+                // The more benchmarks, the lower this needs to be in order to
+                // not get lots of false positives.
+                .significance_level(0.0001)
+                // Ignore any performance change less than this (0.05 = 5%) as
+                // noise, regardless of statistical significance.
+                .noise_threshold(0.05)
+                // Reduce the time taken to run each benchmark
+                .warm_up_time(::std::time::Duration::from_millis(100))
+                .measurement_time(::std::time::Duration::from_millis(400));
+            targets = $($fn_name,)*
+        }
+    };
+}
+
+macro_rules! iter_batched_ref {
+    ($ben:ident, $initializer:expr,[$($routine:expr),+ $(,)?]) => {$(
+        $ben.iter_batched_ref(
+            $initializer,
+            $routine,
+            ::criterion::BatchSize::SmallInput,
+        );
+    )+};
+}
+
+macro_rules! mods {
+    ($(mod $mod:ident;)+) => {
+        $(mod $mod;)+
+        ::criterion::criterion_main!($($mod::benches),+);
+    }
+}
+
+mods![
+    mod date;
+    mod duration;
+    mod formatting;
+    mod instant;
+    mod month;
+    mod offset_date_time;
+    mod parsing;
+    mod primitive_date_time;
+    mod rand;
+    mod time;
+    mod utc_offset;
+    mod util;
+    mod weekday;
+];
diff --git a/benchmarks/month.rs b/benchmarks/month.rs
new file mode 100644
index 000000000..5bf4d10ee
--- /dev/null
+++ b/benchmarks/month.rs
@@ -0,0 +1,36 @@
+use criterion::Bencher;
+use time::Month::*;
+
+setup_benchmark! {
+    "Month",
+
+    fn previous(ben: &mut Bencher<'_>) {
+        ben.iter(|| January.previous());
+        ben.iter(|| February.previous());
+        ben.iter(|| March.previous());
+        ben.iter(|| April.previous());
+        ben.iter(|| May.previous());
+        ben.iter(|| June.previous());
+        ben.iter(|| July.previous());
+        ben.iter(|| August.previous());
+        ben.iter(|| September.previous());
+        ben.iter(|| October.previous());
+        ben.iter(|| November.previous());
+        ben.iter(|| December.previous());
+    }
+
+    fn next(ben: &mut Bencher<'_>) {
+        ben.iter(|| January.next());
+        ben.iter(|| February.next());
+        ben.iter(|| March.next());
+        ben.iter(|| April.next());
+        ben.iter(|| May.next());
+        ben.iter(|| June.next());
+        ben.iter(|| July.next());
+        ben.iter(|| August.next());
+        ben.iter(|| September.next());
+        ben.iter(|| October.next());
+        ben.iter(|| November.next());
+        ben.iter(|| December.next());
+    }
+}
diff --git a/benchmarks/offset_date_time.rs b/benchmarks/offset_date_time.rs
new file mode 100644
index 000000000..92a9695eb
--- /dev/null
+++ b/benchmarks/offset_date_time.rs
@@ -0,0 +1,429 @@
+use std::time::SystemTime;
+
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::{date, datetime, offset, time};
+use time::OffsetDateTime;
+
+setup_benchmark! {
+    "OffsetDateTime",
+
+    // region: now
+    fn now_utc(ben: &mut Bencher<'_>) {
+        ben.iter(OffsetDateTime::now_utc);
+    }
+
+    fn now_local(ben: &mut Bencher<'_>) {
+        ben.iter(OffsetDateTime::now_local);
+    }
+    // endregion now
+
+    fn to_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2000-01-01 0:00 +11).to_offset(offset!(-5)));
+        ben.iter(|| datetime!(2000-01-01 0:00 +11).to_offset(offset!(-8)));
+    }
+
+    // region: constructors
+    fn from_unix_timestamp(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::from_unix_timestamp(0));
+        ben.iter(|| OffsetDateTime::from_unix_timestamp(1_546_300_800));
+    }
+
+    fn from_unix_timestamp_nanos(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::from_unix_timestamp_nanos(0));
+        ben.iter(|| OffsetDateTime::from_unix_timestamp_nanos(1_546_300_800_000_000_000));
+    }
+    // endregion constructors
+
+    // region: getters
+    fn offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).offset());
+        ben.iter(|| datetime!(2019-01-01 0:00 +1).offset());
+        ben.iter(|| datetime!(2019-01-01 1:00 +1).offset());
+    }
+
+    fn unix_timestamp(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::UNIX_EPOCH.unix_timestamp());
+        ben.iter(|| datetime!(1970-01-01 1:00 +1).unix_timestamp());
+        ben.iter(|| datetime!(1970-01-01 0:00 -1).unix_timestamp());
+    }
+
+    fn unix_timestamp_nanos(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1970-01-01 0:00 UTC).unix_timestamp_nanos());
+        ben.iter(|| datetime!(1970-01-01 1:00 +1).unix_timestamp_nanos());
+        ben.iter(|| datetime!(1970-01-01 0:00 -1).unix_timestamp_nanos());
+    }
+
+    fn date(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).date());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).date());
+    }
+
+    fn time(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).time());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).time());
+    }
+
+    fn year(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).year());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).year());
+    }
+
+    fn ordinal(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).ordinal());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).ordinal());
+    }
+
+    fn hour(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).hour());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).hour());
+    }
+
+    fn minute(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).minute());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).minute());
+    }
+
+    fn second(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).second());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).second());
+    }
+    // endregion getters
+
+    // region: replacement
+    fn replace_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 5:00 UTC).replace_time(time!(12:00)));
+        ben.iter(|| datetime!(2020-01-01 12:00 -5).replace_time(time!(7:00)));
+        ben.iter(|| datetime!(2020-01-01 0:00 +1).replace_time(time!(12:00)));
+    }
+
+    fn replace_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 12:00 UTC).replace_date(date!(2020-01-30)));
+        ben.iter(|| datetime!(2020-01-01 0:00 +1).replace_date(date!(2020-01-30)));
+    }
+
+    fn replace_date_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 12:00 UTC).replace_date_time(datetime!(2020-01-30 16:00)));
+        ben.iter(|| datetime!(2020-01-01 12:00 +1).replace_date_time(datetime!(2020-01-30 0:00)));
+    }
+
+    fn replace_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)));
+    }
+    // endregion replacement
+
+    // region: trait impls
+    fn partial_eq(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1999-12-31 23:00 -1) == datetime!(2000-01-01 0:00 UTC));
+    }
+
+    fn partial_ord(ben: &mut Bencher<'_>) {
+        ben.iter(||
+            datetime!(2019-01-01 0:00 UTC).partial_cmp(&datetime!(1999-12-31 23:00 -1))
+        );
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) == datetime!(2018-12-31 23:00 -1));
+        ben.iter(|| datetime!(2019-01-01 0:00:00.000_000_001 UTC) > datetime!(2019-01-01 0:00 UTC));
+    }
+
+    fn hash(ben: &mut Bencher<'_>) {
+        use std::collections::hash_map::DefaultHasher;
+        use std::hash::Hash;
+
+        iter_batched_ref!(
+            ben,
+            DefaultHasher::new,
+            [
+                |hasher| datetime!(2019-01-01 0:00 UTC).hash(hasher),
+                |hasher| datetime!(2018-12-31 23:00 -1).hash(hasher),
+            ]
+        );
+    }
+
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+        let d = (-2).seconds();
+        let e = 1.hours();
+
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59 UTC) + c);
+        ben.iter(|| datetime!(2020-01-01 0:00:01 UTC) + d);
+        ben.iter(|| datetime!(1999-12-31 23:00 UTC) + e);
+    }
+
+    fn add_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59 UTC) + c);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn add_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+
+        ben.iter(|| datetime!(2019-01-06 0:00 UTC) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01 UTC) - c);
+    }
+
+    fn sub_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-06 0:00 UTC) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01 UTC) - c);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn std_add_duration(ben: &mut Bencher<'_>) {
+        let a1 = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let a2 = 0.seconds();
+        let b1 = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b2 = 5.days();
+        let c1 = SystemTime::from(datetime!(2019-12-31 0:00 UTC));
+        let c2 = 1.days();
+        let d1 = SystemTime::from(datetime!(2019-12-31 23:59:59 UTC));
+        let d2 = 2.seconds();
+        let e1 = SystemTime::from(datetime!(2020-01-01 0:00:01 UTC));
+        let e2 = (-2).seconds();
+        ben.iter(|| a1 + a2);
+        ben.iter(|| b1 + b2);
+        ben.iter(|| c1 + c2);
+        ben.iter(|| d1 + d2);
+        ben.iter(|| e1 + e2);
+    }
+
+    fn std_add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn std_sub_duration(ben: &mut Bencher<'_>) {
+        let a1 = SystemTime::from(datetime!(2019-01-06 0:00 UTC));
+        let a2 = 5.days();
+        let b1 = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let b2 = 1.days();
+        let c1 = SystemTime::from(datetime!(2020-01-01 0:00:01 UTC));
+        let c2 = 2.seconds();
+        let d1 = SystemTime::from(datetime!(2019-12-31 23:59:59 UTC));
+        let d2 = (-2).seconds();
+        ben.iter(|| a1 - a2);
+        ben.iter(|| b1 - b2);
+        ben.iter(|| c1 - c2);
+        ben.iter(|| d1 - d2);
+    }
+
+    fn std_sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_self(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-02 0:00 UTC) - datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) - datetime!(2019-01-02 0:00 UTC));
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - datetime!(2019-12-31 0:00 UTC));
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) - datetime!(2020-01-01 0:00 UTC));
+    }
+
+    fn std_sub(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let b = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let c = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let d = SystemTime::from(datetime!(2019-12-31 0:00 UTC));
+
+        ben.iter(|| a - datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| b - datetime!(2019-01-02 0:00 UTC));
+        ben.iter(|| c - datetime!(2019-12-31 0:00 UTC));
+        ben.iter(|| d - datetime!(2020-01-01 0:00 UTC));
+    }
+
+    fn sub_std(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let c = SystemTime::from(datetime!(2019-12-31 0:00 UTC));
+        let d = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+
+        ben.iter(|| datetime!(2019-01-02 0:00 UTC) - a);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - c);
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) - d);
+    }
+
+    fn eq_std(ben: &mut Bencher<'_>) {
+        let a = OffsetDateTime::now_utc();
+        let b = SystemTime::from(a);
+        ben.iter(|| a == b);
+    }
+
+    fn std_eq(ben: &mut Bencher<'_>) {
+        let a = OffsetDateTime::now_utc();
+        let b = SystemTime::from(a);
+        ben.iter(|| b == a);
+    }
+
+    fn ord_std(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let c = SystemTime::from(datetime!(2019-02-01 0:00 UTC));
+        let d = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let e = SystemTime::from(datetime!(2019-01-01 1:00:00 UTC));
+        let f = SystemTime::from(datetime!(2019-01-01 0:01:00 UTC));
+        let g = SystemTime::from(datetime!(2019-01-01 0:00:01 UTC));
+        let h = SystemTime::from(datetime!(2019-01-01 0:00:00.001 UTC));
+        let i = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let j = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let k = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let l = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let m = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let n = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let o = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) == a);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < b);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < c);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < d);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < e);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < f);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < g);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < h);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) > i);
+        ben.iter(|| datetime!(2019-02-01 0:00 UTC) > j);
+        ben.iter(|| datetime!(2019-01-02 0:00 UTC) > k);
+        ben.iter(|| datetime!(2019-01-01 1:00:00 UTC) > l);
+        ben.iter(|| datetime!(2019-01-01 0:01:00 UTC) > m);
+        ben.iter(|| datetime!(2019-01-01 0:00:01 UTC) > n);
+        ben.iter(|| datetime!(2019-01-01 0:00:00.000_000_001 UTC) > o);
+    }
+
+    fn std_ord(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let c = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let d = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let e = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let f = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let g = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let h = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let i = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let j = SystemTime::from(datetime!(2019-02-01 0:00 UTC));
+        let k = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let l = SystemTime::from(datetime!(2019-01-01 1:00:00 UTC));
+        let m = SystemTime::from(datetime!(2019-01-01 0:01:00 UTC));
+        let n = SystemTime::from(datetime!(2019-01-01 0:00:01 UTC));
+        let o = SystemTime::from(datetime!(2019-01-01 0:00:00.001 UTC));
+
+        ben.iter(|| a == datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| b < datetime!(2020-01-01 0:00 UTC));
+        ben.iter(|| c < datetime!(2019-02-01 0:00 UTC));
+        ben.iter(|| d < datetime!(2019-01-02 0:00 UTC));
+        ben.iter(|| e < datetime!(2019-01-01 1:00:00 UTC));
+        ben.iter(|| f < datetime!(2019-01-01 0:01:00 UTC));
+        ben.iter(|| g < datetime!(2019-01-01 0:00:01 UTC));
+        ben.iter(|| h < datetime!(2019-01-01 0:00:00.000_000_001 UTC));
+        ben.iter(|| i > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| j > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| k > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| l > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| m > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| n > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| o > datetime!(2019-01-01 0:00 UTC));
+    }
+
+    fn from_std(ben: &mut Bencher<'_>) {
+        let a = SystemTime::UNIX_EPOCH;
+        let b = SystemTime::UNIX_EPOCH - 1.std_days();
+        let c = SystemTime::UNIX_EPOCH + 1.std_days();
+        ben.iter(|| OffsetDateTime::from(a));
+        ben.iter(|| OffsetDateTime::from(b));
+        ben.iter(|| OffsetDateTime::from(c));
+    }
+
+    fn to_std(ben: &mut Bencher<'_>) {
+        let a = OffsetDateTime::UNIX_EPOCH;
+        let b = OffsetDateTime::UNIX_EPOCH + 1.days();
+        let c = OffsetDateTime::UNIX_EPOCH - 1.days();
+        ben.iter(|| SystemTime::from(a));
+        ben.iter(|| SystemTime::from(b));
+        ben.iter(|| SystemTime::from(c));
+    }
+    // endregion trait impls
+}
diff --git a/benchmarks/parsing.rs b/benchmarks/parsing.rs
new file mode 100644
index 000000000..da5dde9f5
--- /dev/null
+++ b/benchmarks/parsing.rs
@@ -0,0 +1,224 @@
+use criterion::Bencher;
+use time::format_description::well_known::{Rfc2822, Rfc3339};
+use time::format_description::{modifier, Component};
+use time::parsing::Parsed;
+use time::OffsetDateTime;
+
+macro_rules! component {
+    ($name:ident {$($field:ident : $value:expr),+ $(,)? }) => {{
+        const COMPONENT: Component = Component::$name({
+            let mut modifier = modifier::$name::default();
+            $(modifier.$field = $value;)+
+            modifier
+        });
+        COMPONENT
+    }};
+}
+
+setup_benchmark! {
+    "Parsing",
+
+    fn parse_component_year(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"2021", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::Full,
+                iso_week_based: false,
+                sign_is_mandatory: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"21", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::LastTwo,
+                iso_week_based: false,
+                sign_is_mandatory: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"2021", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::Full,
+                iso_week_based: true,
+                sign_is_mandatory: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"21", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::LastTwo,
+                iso_week_based: true,
+                sign_is_mandatory: false,
+            }))
+        });
+    }
+
+    fn parse_component_month(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b" 1", component!(Month {
+                padding: modifier::Padding::Space,
+                repr: modifier::MonthRepr::Numerical,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"Jan", component!(Month {
+                padding: modifier::Padding::None,
+                repr: modifier::MonthRepr::Short,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"January", component!(Month {
+                padding: modifier::Padding::None,
+                repr: modifier::MonthRepr::Long,
+            }))
+        });
+    }
+
+    fn parse_component_ordinal(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"012", component!(Ordinal {
+                padding: modifier::Padding::Zero,
+            }))
+        });
+    }
+
+    fn parse_component_weekday(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"Sun", component!(Weekday {
+                repr: modifier::WeekdayRepr::Short,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"Sunday", component!(Weekday {
+                repr: modifier::WeekdayRepr::Long,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"0", component!(Weekday {
+                repr: modifier::WeekdayRepr::Sunday,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"1", component!(Weekday {
+                repr: modifier::WeekdayRepr::Sunday,
+                one_indexed: true,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"6", component!(Weekday {
+                repr: modifier::WeekdayRepr::Monday,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"7", component!(Weekday {
+                repr: modifier::WeekdayRepr::Monday,
+                one_indexed: true,
+            }))
+        });
+    }
+
+    fn parse_component_week_number(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"2", component!(WeekNumber {
+                padding: modifier::Padding::None,
+                repr: modifier::WeekNumberRepr::Sunday,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"2", component!(WeekNumber {
+                padding: modifier::Padding::None,
+                repr: modifier::WeekNumberRepr::Monday,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"2", component!(WeekNumber {
+                padding: modifier::Padding::None,
+                repr: modifier::WeekNumberRepr::Iso,
+            }))
+        });
+    }
+
+    fn parse_component_subsecond(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"1", component!(Subsecond {
+                digits: modifier::SubsecondDigits::One,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"12", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Two,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Three,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"1234", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Four,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"12345", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Five,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123456", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Six,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"1234567", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Seven,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"12345678", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Eight,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123456789", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Nine,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123456789", component!(Subsecond {
+                digits: modifier::SubsecondDigits::OneOrMore,
+            }))
+        });
+    }
+
+    fn parse_rfc3339(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.1Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.12Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.1234Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.12345Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.1234567Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.12345678Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456789Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456789-01:02", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456789+01:02", &Rfc3339));
+    }
+
+    fn parse_rfc2822(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 +0000", &Rfc2822));
+        ben.iter(|| OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 +0607", &Rfc2822));
+        ben.iter(|| OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 -0607", &Rfc2822));
+    }
+}
diff --git a/benchmarks/primitive_date_time.rs b/benchmarks/primitive_date_time.rs
new file mode 100644
index 000000000..a45130ee2
--- /dev/null
+++ b/benchmarks/primitive_date_time.rs
@@ -0,0 +1,148 @@
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::{datetime, offset};
+
+setup_benchmark! {
+    "PrimitiveDateTime",
+
+    // All getters are trivially dispatched to the relevant field, and do not need to be benchmarked
+    // a second time.
+
+    // region: attach offset
+    fn assume_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00).assume_offset(offset!(UTC)));
+        ben.iter(|| datetime!(2019-01-01 0:00).assume_offset(offset!(-1)));
+    }
+
+    fn assume_utc(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00).assume_utc());
+    }
+    // endregion attach offset
+
+    // region: trait impls
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+        let d = (-2).seconds();
+        let e = 1.hours();
+
+        ben.iter(|| datetime!(2019-01-01 0:00) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59) + c);
+        ben.iter(|| datetime!(2020-01-01 0:00:01) + d);
+        ben.iter(|| datetime!(1999-12-31 23:00) + e);
+    }
+
+    fn add_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-01 0:00) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59) + c);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn add_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+        let d = (-2).seconds();
+        let e = (-1).hours();
+
+        ben.iter(|| datetime!(2019-01-06 0:00) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01) - c);
+        ben.iter(|| datetime!(2019-12-31 23:59:59) - d);
+        ben.iter(|| datetime!(1999-12-31 23:00) - e);
+    }
+
+    fn sub_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-06 0:00) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01) - c);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_datetime(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-02 0:00) - datetime!(2019-01-01 0:00));
+        ben.iter(|| datetime!(2019-01-01 0:00) - datetime!(2019-01-02 0:00));
+        ben.iter(|| datetime!(2020-01-01 0:00) - datetime!(2019-12-31 0:00));
+        ben.iter(|| datetime!(2019-12-31 0:00) - datetime!(2020-01-01 0:00));
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2020-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-02-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-02 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 1:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:01)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00:01)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00:00.000_000_001)));
+        ben.iter(|| datetime!(2020-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-02-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-02 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 1:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:01).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00:01).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00:00.000_000_001).partial_cmp(&datetime!(2019-01-01 0:00)));
+    }
+    // endregion trait impls
+}
diff --git a/benchmarks/rand.rs b/benchmarks/rand.rs
new file mode 100644
index 000000000..37a8df0e9
--- /dev/null
+++ b/benchmarks/rand.rs
@@ -0,0 +1,30 @@
+use criterion::Bencher;
+use rand::rngs::mock::StepRng;
+use rand::Rng;
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+macro_rules! bench_rand {
+    ($($name:ident : $type:ty),* $(,)?) => {
+        setup_benchmark! {
+            "Random",
+            $(fn $name(ben: &mut Bencher<'_>) {
+                iter_batched_ref!(
+                    ben,
+                    || StepRng::new(0, 1),
+                    [|rng| rng.r#gen::<$type>()]
+                );
+            })*
+        }
+    }
+}
+
+bench_rand![
+    time: Time,
+    date: Date,
+    utc_offset: UtcOffset,
+    primitive_date_time: PrimitiveDateTime,
+    offset_date_time: OffsetDateTime,
+    duration: Duration,
+    weekday: Weekday,
+    month: Month,
+];
diff --git a/benchmarks/time.rs b/benchmarks/time.rs
new file mode 100644
index 000000000..884e173e8
--- /dev/null
+++ b/benchmarks/time.rs
@@ -0,0 +1,271 @@
+use std::hint::black_box;
+
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::time;
+use time::Time;
+
+setup_benchmark! {
+    "Time",
+
+    // region: constructors
+    fn from_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms(1, 2, 3));
+    }
+
+    fn from_hms_milli(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms_milli(1, 2, 3, 4));
+    }
+
+    fn from_hms_micro(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms_micro(1, 2, 3, 4));
+    }
+
+    fn from_hms_nano(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms_nano(1, 2, 3, 4));
+    }
+    // endregion constructors
+
+    // region: getters
+    fn as_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms());
+    }
+
+    fn as_hms_milli(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms_milli());
+    }
+
+    fn as_hms_micro(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms_micro());
+    }
+
+    fn as_hms_nano(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms_nano());
+    }
+
+    fn hour(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.hour());
+    }
+
+    fn minute(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.minute());
+    }
+
+    fn second(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.second());
+    }
+
+    fn millisecond(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.millisecond());
+    }
+
+    fn microsecond(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.microsecond());
+    }
+
+    fn nanosecond(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.nanosecond());
+    }
+    // endregion getters
+
+    // region: trait impls
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        ben.iter(|| Time::MIDNIGHT + a);
+        ben.iter(|| Time::MIDNIGHT + b);
+        ben.iter(|| Time::MIDNIGHT + c);
+        ben.iter(|| Time::MIDNIGHT + d);
+        ben.iter(|| Time::MIDNIGHT + e);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time += a,
+                |time| *time += b,
+                |time| *time += c,
+                |time| *time += d,
+                |time| *time += e,
+            ]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        ben.iter(|| Time::MIDNIGHT - a);
+        ben.iter(|| Time::MIDNIGHT - b);
+        ben.iter(|| Time::MIDNIGHT - c);
+        ben.iter(|| Time::MIDNIGHT - d);
+        ben.iter(|| Time::MIDNIGHT - e);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time -= a,
+                |time| *time -= b,
+                |time| *time -= c,
+                |time| *time -= d,
+                |time| *time -= e,
+            ]
+        );
+    }
+
+    fn add_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        ben.iter(|| Time::MIDNIGHT + a);
+        ben.iter(|| Time::MIDNIGHT + b);
+        ben.iter(|| Time::MIDNIGHT + c);
+        ben.iter(|| Time::MIDNIGHT + d);
+        ben.iter(|| Time::MIDNIGHT + e);
+    }
+
+    fn add_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time += a,
+                |time| *time += b,
+                |time| *time += c,
+                |time| *time += d,
+                |time| *time += e,
+            ]
+        );
+    }
+
+    fn sub_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        ben.iter(|| Time::MIDNIGHT - a);
+        ben.iter(|| Time::MIDNIGHT - b);
+        ben.iter(|| Time::MIDNIGHT - c);
+        ben.iter(|| Time::MIDNIGHT - d);
+        ben.iter(|| Time::MIDNIGHT - e);
+    }
+
+    fn sub_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time -= a,
+                |time| *time -= b,
+                |time| *time -= c,
+                |time| *time -= d,
+                |time| *time -= e,
+            ]
+        );
+    }
+
+    fn sub_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT - time!(0:00:01));
+        ben.iter(|| time!(1:00) - Time::MIDNIGHT);
+        ben.iter(|| time!(1:00) - time!(0:00:01));
+    }
+
+    fn ordering(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT < time!(0:00:00.000_000_001));
+        ben.iter(|| Time::MIDNIGHT < time!(0:00:01));
+        ben.iter(|| time!(12:00) > time!(11:00));
+        ben.iter(|| Time::MIDNIGHT == time!(0:00:00.000_000_001));
+    }
+
+    fn sort_align_8(ben: &mut Bencher<'_>) {
+        ben.iter_batched_ref(
+            || {
+                #[repr(C,align(8))]
+                struct Padder {
+                    arr: [Time;4096],
+                }
+                let mut res = Padder {
+                    arr: [Time::MIDNIGHT;4096]
+                };
+                let mut last = Time::MIDNIGHT;
+                let mut last_hour = 0;
+                for t in &mut res.arr {
+                    *t = last;
+                    t.replace_hour(last_hour).expect("failed to replace hour");
+                    last += 997.std_milliseconds();
+                    last_hour = (last_hour + 5) % 24;
+                }
+                res.arr.sort_unstable_by_key(|t|
+                    (t.nanosecond(),t.second(),t.minute(),t.hour())
+                );
+                res
+            },
+            |v| black_box(v).arr.sort_unstable(),
+            criterion::BatchSize::SmallInput
+        )
+    }
+
+    fn sort_align_4(ben: &mut Bencher<'_>) {
+        ben.iter_batched_ref(
+            || {
+                #[repr(C,align(8))]
+                struct Padder {
+                    pad: u32,
+                    arr: [Time;4096],
+                }
+                let mut res = Padder {
+                    pad: 0,
+                    arr: [Time::MIDNIGHT;4096]
+                };
+                let mut last = Time::MIDNIGHT;
+                let mut last_hour = 0;
+                for t in &mut res.arr {
+                    *t = last;
+                    t.replace_hour(last_hour).expect("failed to replace hour");
+                    last += 997.std_milliseconds();
+                    last_hour = (last_hour + 5) % 24;
+                }
+                res.arr.sort_unstable_by_key(|t|
+                    (t.nanosecond(),t.second(),t.minute(),t.hour())
+                );
+                res
+            },
+            |v| black_box(v).arr.sort_unstable(),
+            criterion::BatchSize::SmallInput
+        )
+    }
+    // endregion trait impls
+}
diff --git a/benchmarks/utc_offset.rs b/benchmarks/utc_offset.rs
new file mode 100644
index 000000000..e96f7175d
--- /dev/null
+++ b/benchmarks/utc_offset.rs
@@ -0,0 +1,64 @@
+use criterion::Bencher;
+use time::{OffsetDateTime, UtcOffset};
+
+setup_benchmark! {
+    "UtcOffset",
+
+    // region: constructors
+    fn from_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::from_hms(0, 0, 0));
+    }
+
+    fn from_whole_seconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::from_whole_seconds(0));
+    }
+    // endregion constructors
+
+    // region: getters
+    fn as_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.as_hms());
+    }
+
+    fn whole_hours(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.whole_hours());
+    }
+
+    fn whole_minutes(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.whole_minutes());
+    }
+
+    fn minutes_past_hour(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.minutes_past_hour());
+    }
+
+    fn whole_seconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.whole_seconds());
+    }
+
+    fn seconds_past_minute(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.seconds_past_minute());
+    }
+    // endregion getters
+
+    // region: is_{sign}
+    fn is_utc(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.is_utc());
+    }
+
+    fn is_positive(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.is_positive());
+    }
+
+    fn is_negative(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.is_negative());
+    }
+    // endregion is_{sign}
+
+    fn local_offset_at(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::local_offset_at(OffsetDateTime::UNIX_EPOCH));
+    }
+
+    fn current_local_offset(ben: &mut Bencher<'_>) {
+        ben.iter(UtcOffset::current_local_offset);
+    }
+}
diff --git a/benchmarks/util.rs b/benchmarks/util.rs
new file mode 100644
index 000000000..b02bf6096
--- /dev/null
+++ b/benchmarks/util.rs
@@ -0,0 +1,60 @@
+use criterion::{black_box, Bencher};
+use time::{util, Month};
+
+setup_benchmark! {
+    "Utils",
+
+    fn days_in_year_month(ben: &mut Bencher<'_>) {
+        // Common year
+        ben.iter(|| util::days_in_year_month(2019, Month::January));
+        ben.iter(|| util::days_in_year_month(2019, Month::February));
+        ben.iter(|| util::days_in_year_month(2019, Month::March));
+        ben.iter(|| util::days_in_year_month(2019, Month::April));
+        ben.iter(|| util::days_in_year_month(2019, Month::May));
+        ben.iter(|| util::days_in_year_month(2019, Month::June));
+        ben.iter(|| util::days_in_year_month(2019, Month::July));
+        ben.iter(|| util::days_in_year_month(2019, Month::August));
+        ben.iter(|| util::days_in_year_month(2019, Month::September));
+        ben.iter(|| util::days_in_year_month(2019, Month::October));
+        ben.iter(|| util::days_in_year_month(2019, Month::November));
+        ben.iter(|| util::days_in_year_month(2019, Month::December));
+
+        // Leap year
+        ben.iter(|| util::days_in_year_month(2020, Month::January));
+        ben.iter(|| util::days_in_year_month(2020, Month::February));
+        ben.iter(|| util::days_in_year_month(2020, Month::March));
+        ben.iter(|| util::days_in_year_month(2020, Month::April));
+        ben.iter(|| util::days_in_year_month(2020, Month::May));
+        ben.iter(|| util::days_in_year_month(2020, Month::June));
+        ben.iter(|| util::days_in_year_month(2020, Month::July));
+        ben.iter(|| util::days_in_year_month(2020, Month::August));
+        ben.iter(|| util::days_in_year_month(2020, Month::September));
+        ben.iter(|| util::days_in_year_month(2020, Month::October));
+        ben.iter(|| util::days_in_year_month(2020, Month::November));
+        ben.iter(|| util::days_in_year_month(2020, Month::December));
+    }
+
+    fn is_leap_year(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for year in 0..400 {
+                black_box(util::is_leap_year(year));
+            }
+        });
+    }
+
+    fn days_in_year(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for year in 0..400 {
+                black_box(util::days_in_year(year));
+            }
+        });
+    }
+
+    fn weeks_in_year(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for year in 0..400 {
+                black_box(util::weeks_in_year(year));
+            }
+        });
+    }
+}
diff --git a/benchmarks/weekday.rs b/benchmarks/weekday.rs
new file mode 100644
index 000000000..e992d4d8c
--- /dev/null
+++ b/benchmarks/weekday.rs
@@ -0,0 +1,81 @@
+use criterion::Bencher;
+use time::Weekday::*;
+
+setup_benchmark! {
+    "Weekday",
+
+    fn previous(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.previous());
+        ben.iter(|| Monday.previous());
+        ben.iter(|| Tuesday.previous());
+        ben.iter(|| Wednesday.previous());
+        ben.iter(|| Thursday.previous());
+        ben.iter(|| Friday.previous());
+        ben.iter(|| Saturday.previous());
+    }
+
+    fn next(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.next());
+        ben.iter(|| Monday.next());
+        ben.iter(|| Tuesday.next());
+        ben.iter(|| Wednesday.next());
+        ben.iter(|| Thursday.next());
+        ben.iter(|| Friday.next());
+        ben.iter(|| Saturday.next());
+    }
+
+    fn nth(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.nth_next(0));
+        ben.iter(|| Sunday.nth_next(1));
+        ben.iter(|| Sunday.nth_next(2));
+        ben.iter(|| Sunday.nth_next(3));
+        ben.iter(|| Sunday.nth_next(4));
+        ben.iter(|| Sunday.nth_next(5));
+        ben.iter(|| Sunday.nth_next(6));
+
+        ben.iter(|| Sunday.nth_next(7));
+        ben.iter(|| Sunday.nth_next(u8::MAX));
+        ben.iter(|| Monday.nth_next(7));
+        ben.iter(|| Monday.nth_next(u8::MAX));
+    }
+
+    fn number_from_monday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Monday.number_from_monday());
+        ben.iter(|| Tuesday.number_from_monday());
+        ben.iter(|| Wednesday.number_from_monday());
+        ben.iter(|| Thursday.number_from_monday());
+        ben.iter(|| Friday.number_from_monday());
+        ben.iter(|| Saturday.number_from_monday());
+        ben.iter(|| Sunday.number_from_monday());
+    }
+
+    fn number_from_sunday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.number_from_sunday());
+        ben.iter(|| Monday.number_from_sunday());
+        ben.iter(|| Tuesday.number_from_sunday());
+        ben.iter(|| Wednesday.number_from_sunday());
+        ben.iter(|| Thursday.number_from_sunday());
+        ben.iter(|| Friday.number_from_sunday());
+        ben.iter(|| Saturday.number_from_sunday());
+    }
+
+    fn number_days_from_monday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Monday.number_days_from_monday());
+        ben.iter(|| Tuesday.number_days_from_monday());
+        ben.iter(|| Wednesday.number_days_from_monday());
+        ben.iter(|| Thursday.number_days_from_monday());
+        ben.iter(|| Friday.number_days_from_monday());
+        ben.iter(|| Saturday.number_days_from_monday());
+        ben.iter(|| Sunday.number_days_from_monday());
+    }
+
+    fn number_days_from_sunday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.number_days_from_sunday());
+        ben.iter(|| Monday.number_days_from_sunday());
+        ben.iter(|| Tuesday.number_days_from_sunday());
+        ben.iter(|| Wednesday.number_days_from_sunday());
+        ben.iter(|| Thursday.number_days_from_sunday());
+        ben.iter(|| Friday.number_days_from_sunday());
+        ben.iter(|| Saturday.number_days_from_sunday());
+    }
+}
diff --git a/logo.svg b/logo.svg
new file mode 100644
index 000000000..9c1ae5442
--- /dev/null
+++ b/logo.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 512 512"><g id="d"><g id="c"><g id="b"><path id="a" d="M276 73l-14-23c-3-5-9-5-12 0l-14 23m0 366l14 23c3 5 9 5 12 0l14-23"/><use xlink:href="#a" transform="rotate(11.3 256 256)" width="100%" height="100%"/></g><use xlink:href="#b" transform="rotate(22.5 256 256)" width="100%" height="100%"/></g><use xlink:href="#c" transform="rotate(45 256 256)" width="100%" height="100%"/></g><use xlink:href="#d" transform="rotate(90 256 256)" width="100%" height="100%"/><g id="f"><path id="e" d="M378 110a189 189 0 0 0-122-44c-46 0-88 16-121 43l26 25a154 154 0 0 1 67-30l20 20a10 10 0 0 0 16 0l21-18a154 154 0 0 1 76 37M256 84c17 0 16 25 0 25s-17-25 0-25"/><use xlink:href="#e" transform="rotate(72 256 256)" width="100%" height="100%"/></g><use xlink:href="#f" transform="rotate(144 256 256)" width="100%" height="100%"/><use xlink:href="#e" transform="rotate(-72 256 256)" width="100%" height="100%"/><circle cx="256" cy="256" r="12"/><path d="M256 256l107.964 28.929m-164.371-85.336L256 256" fill="none" stroke="#000" stroke-width="16" stroke-linecap="round"/></svg>
\ No newline at end of file
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 000000000..a4528c2ac
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1,17 @@
+newline_style = "unix"
+use_field_init_shorthand = true
+use_try_shorthand = true
+
+# Unstable features below
+unstable_features = true
+version = "Two"
+comment_width = 100
+error_on_line_overflow = true
+format_code_in_doc_comments = true
+format_macro_bodies = true
+format_macro_matchers = true
+format_strings = true
+imports_granularity = "Module"
+group_imports = "StdExternalCrate"
+normalize_doc_attributes = true
+wrap_comments = true
diff --git a/tests/compile-fail/invalid_date.rs b/tests/compile-fail/invalid_date.rs
new file mode 100644
index 000000000..3605ae80b
--- /dev/null
+++ b/tests/compile-fail/invalid_date.rs
@@ -0,0 +1,22 @@
+use time::macros::date;
+
+fn main() {
+    let _ = date!(+1_000_000-01-01);
+    let _ = date!(10_000 - 01 - 01);
+    let _ = date!(2021-W 60-1);
+    let _ = date!(2021-W 01-0);
+    let _ = date!(2021-W 01-8);
+    let _ = date!(2021 - 00 - 01);
+    let _ = date!(2021 - 13 - 01);
+    let _ = date!(2021 - 01 - 00);
+    let _ = date!(2021 - 01 - 32);
+    let _ = date!(2021 - 000);
+    let _ = date!(2021 - 366);
+    let _ = date!(0a);
+    let _ = date!(2021:);
+    let _ = date!(2021-W 0a);
+    let _ = date!(2021-W 01:);
+    let _ = date!(2021-W 01-0a);
+    let _ = date!(2021-0a);
+    let _ = date!(2021-01-0a);
+}
diff --git a/tests/compile-fail/invalid_date.stderr b/tests/compile-fail/invalid_date.stderr
new file mode 100644
index 000000000..3bf9d34eb
--- /dev/null
+++ b/tests/compile-fail/invalid_date.stderr
@@ -0,0 +1,107 @@
+error: invalid component: year was 1000000
+ --> $DIR/invalid_date.rs:4:19
+  |
+4 |     let _ = date!(+1_000_000-01-01);
+  |                   ^^^^^^^^^^
+
+error: years with more than four digits must have an explicit sign
+ --> $DIR/invalid_date.rs:5:19
+  |
+5 |     let _ = date!(10_000 - 01 - 01);
+  |                   ^^^^^^
+
+error: invalid component: week was 60
+ --> $DIR/invalid_date.rs:6:24
+  |
+6 |     let _ = date!(2021-W 60-1);
+  |                        ^^^^
+
+error: invalid component: day was 0
+ --> $DIR/invalid_date.rs:7:29
+  |
+7 |     let _ = date!(2021-W 01-0);
+  |                             ^
+
+error: invalid component: day was 8
+ --> $DIR/invalid_date.rs:8:29
+  |
+8 |     let _ = date!(2021-W 01-8);
+  |                             ^
+
+error: invalid component: month was 0
+ --> $DIR/invalid_date.rs:9:26
+  |
+9 |     let _ = date!(2021 - 00 - 01);
+  |                          ^^
+
+error: invalid component: month was 13
+  --> $DIR/invalid_date.rs:10:26
+   |
+10 |     let _ = date!(2021 - 13 - 01);
+   |                          ^^
+
+error: invalid component: day was 0
+  --> $DIR/invalid_date.rs:11:31
+   |
+11 |     let _ = date!(2021 - 01 - 00);
+   |                               ^^
+
+error: invalid component: day was 32
+  --> $DIR/invalid_date.rs:12:31
+   |
+12 |     let _ = date!(2021 - 01 - 32);
+   |                               ^^
+
+error: invalid component: ordinal was 0
+  --> $DIR/invalid_date.rs:13:26
+   |
+13 |     let _ = date!(2021 - 000);
+   |                          ^^^
+
+error: invalid component: ordinal was 366
+  --> $DIR/invalid_date.rs:14:26
+   |
+14 |     let _ = date!(2021 - 366);
+   |                          ^^^
+
+error: invalid component: year was 0a
+  --> $DIR/invalid_date.rs:15:19
+   |
+15 |     let _ = date!(0a);
+   |                   ^^
+
+error: unexpected token: :
+  --> $DIR/invalid_date.rs:16:23
+   |
+16 |     let _ = date!(2021:);
+   |                       ^
+
+error: invalid component: week was 0a
+  --> $DIR/invalid_date.rs:17:26
+   |
+17 |     let _ = date!(2021-W 0a);
+   |                          ^^
+
+error: unexpected token: :
+  --> $DIR/invalid_date.rs:18:28
+   |
+18 |     let _ = date!(2021-W 01:);
+   |                            ^
+
+error: invalid component: day was 0a
+  --> $DIR/invalid_date.rs:19:29
+   |
+19 |     let _ = date!(2021-W 01-0a);
+   |                             ^^
+
+error: invalid component: month or ordinal was 0a
+  --> $DIR/invalid_date.rs:20:24
+   |
+20 |     let _ = date!(2021-0a);
+   |                        ^^
+
+error: invalid component: day was 0a
+  --> $DIR/invalid_date.rs:21:27
+   |
+21 |     let _ = date!(2021-01-0a);
+   |                           ^^
diff --git a/tests/compile-fail/invalid_datetime.rs b/tests/compile-fail/invalid_datetime.rs
new file mode 100644
index 000000000..5fe4138ee
--- /dev/null
+++ b/tests/compile-fail/invalid_datetime.rs
@@ -0,0 +1,8 @@
+use time::macros::datetime;
+
+fn main() {
+    let _ = datetime!(2021 - 000 0:00);
+    let _ = datetime!(2021 - 001 24:00);
+    let _ = datetime!(2021 - 001 0:00 0);
+    let _ = datetime!(2021 - 001 0:00 UTC x);
+}
diff --git a/tests/compile-fail/invalid_datetime.stderr b/tests/compile-fail/invalid_datetime.stderr
new file mode 100644
index 000000000..d65e42760
--- /dev/null
+++ b/tests/compile-fail/invalid_datetime.stderr
@@ -0,0 +1,23 @@
+error: invalid component: ordinal was 0
+ --> $DIR/invalid_datetime.rs:4:30
+  |
+4 |     let _ = datetime!(2021 - 000 0:00);
+  |                              ^^^
+
+error: invalid component: hour was 24
+ --> $DIR/invalid_datetime.rs:5:34
+  |
+5 |     let _ = datetime!(2021 - 001 24:00);
+  |                                  ^^
+
+error: unexpected token: 0
+ --> $DIR/invalid_datetime.rs:6:39
+  |
+6 |     let _ = datetime!(2021 - 001 0:00 0);
+  |                                       ^
+
+error: unexpected token: x
+ --> $DIR/invalid_datetime.rs:7:43
+  |
+7 |     let _ = datetime!(2021 - 001 0:00 UTC x);
+  |                                           ^
diff --git a/tests/compile-fail/invalid_format_description.rs b/tests/compile-fail/invalid_format_description.rs
new file mode 100644
index 000000000..a77a31808
--- /dev/null
+++ b/tests/compile-fail/invalid_format_description.rs
@@ -0,0 +1,46 @@
+use time::macros::format_description;
+
+fn main() {
+    let _ = format_description!();
+    let _ = format_description!("[]");
+    let _ = format_description!("[foo]");
+    let _ = format_description!("[");
+    let _ = format_description!("[hour foo]");
+    let _ = format_description!("" x);
+    let _ = format_description!(x);
+    let _ = format_description!(0);
+    let _ = format_description!({});
+
+    let _ = format_description!("[ invalid ]");
+    let _ = format_description!("[");
+    let _ = format_description!("[ ");
+    let _ = format_description!("[]");
+    let _ = format_description!("[day sign:mandatory]");
+    let _ = format_description!("[day sign:]");
+    let _ = format_description!("[day :mandatory]");
+    let _ = format_description!("[day sign:mandatory");
+    let _ = format_description!("[day padding:invalid]");
+
+    let _ = format_description!(version);
+    let _ = format_description!(version "");
+    let _ = format_description!(version =);
+    let _ = format_description!(version = 0);
+    let _ = format_description!(version = 1);
+    let _ = format_description!(version = 3);
+    let _ = format_description!(version = two);
+
+    let _ = format_description!(version = 2, r"\a");
+    let _ = format_description!(version = 2, r"\");
+
+    let _ = format_description!(version = 2, "[year [month]]");
+    let _ = format_description!(version = 2, "[optional[]]");
+    let _ = format_description!(version = 2, "[first[]]");
+    let _ = format_description!(version = 2, "[optional []");
+    let _ = format_description!(version = 2, "[first []");
+    let _ = format_description!(version = 2, "[optional [");
+    let _ = format_description!(version = 2, "[optional [[year");
+    let _ = format_description!(version = 2, "[optional ");
+
+    let _ = format_description!("[ignore]");
+    let _ = format_description!("[ignore count:0]");
+}
diff --git a/tests/compile-fail/invalid_format_description.stderr b/tests/compile-fail/invalid_format_description.stderr
new file mode 100644
index 000000000..156665a38
--- /dev/null
+++ b/tests/compile-fail/invalid_format_description.stderr
@@ -0,0 +1,229 @@
+error: expected string literal
+ --> ../tests/compile-fail/invalid_format_description.rs:4:13
+  |
+4 |     let _ = format_description!();
+  |             ^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected component name
+ --> ../tests/compile-fail/invalid_format_description.rs:5:33
+  |
+5 |     let _ = format_description!("[]");
+  |                                 ^^^^
+
+error: invalid component
+ --> ../tests/compile-fail/invalid_format_description.rs:6:33
+  |
+6 |     let _ = format_description!("[foo]");
+  |                                 ^^^^^^^
+
+error: expected component name
+ --> ../tests/compile-fail/invalid_format_description.rs:7:33
+  |
+7 |     let _ = format_description!("[");
+  |                                 ^^^
+
+error: modifier must be of the form `key:value`
+ --> ../tests/compile-fail/invalid_format_description.rs:8:33
+  |
+8 |     let _ = format_description!("[hour foo]");
+  |                                 ^^^^^^^^^^^^
+
+error: unexpected token: x
+ --> ../tests/compile-fail/invalid_format_description.rs:9:36
+  |
+9 |     let _ = format_description!("" x);
+  |                                    ^
+
+error: expected string literal
+  --> ../tests/compile-fail/invalid_format_description.rs:10:33
+   |
+10 |     let _ = format_description!(x);
+   |                                 ^
+
+error: expected string literal
+  --> ../tests/compile-fail/invalid_format_description.rs:11:33
+   |
+11 |     let _ = format_description!(0);
+   |                                 ^
+
+error: expected string literal
+  --> ../tests/compile-fail/invalid_format_description.rs:12:33
+   |
+12 |     let _ = format_description!({});
+   |                                 ^^
+
+error: invalid component
+  --> ../tests/compile-fail/invalid_format_description.rs:14:33
+   |
+14 |     let _ = format_description!("[ invalid ]");
+   |                                 ^^^^^^^^^^^^^
+
+error: expected component name
+  --> ../tests/compile-fail/invalid_format_description.rs:15:33
+   |
+15 |     let _ = format_description!("[");
+   |                                 ^^^
+
+error: expected component name
+  --> ../tests/compile-fail/invalid_format_description.rs:16:33
+   |
+16 |     let _ = format_description!("[ ");
+   |                                 ^^^^
+
+error: expected component name
+  --> ../tests/compile-fail/invalid_format_description.rs:17:33
+   |
+17 |     let _ = format_description!("[]");
+   |                                 ^^^^
+
+error: invalid modifier key
+  --> ../tests/compile-fail/invalid_format_description.rs:18:33
+   |
+18 |     let _ = format_description!("[day sign:mandatory]");
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^
+
+error: expected modifier value
+  --> ../tests/compile-fail/invalid_format_description.rs:19:33
+   |
+19 |     let _ = format_description!("[day sign:]");
+   |                                 ^^^^^^^^^^^^^
+
+error: expected modifier key
+  --> ../tests/compile-fail/invalid_format_description.rs:20:33
+   |
+20 |     let _ = format_description!("[day :mandatory]");
+   |                                 ^^^^^^^^^^^^^^^^^^
+
+error: unclosed bracket
+  --> ../tests/compile-fail/invalid_format_description.rs:21:33
+   |
+21 |     let _ = format_description!("[day sign:mandatory");
+   |                                 ^^^^^^^^^^^^^^^^^^^^^
+
+error: invalid modifier value
+  --> ../tests/compile-fail/invalid_format_description.rs:22:33
+   |
+22 |     let _ = format_description!("[day padding:invalid]");
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: expected `=`
+  --> ../tests/compile-fail/invalid_format_description.rs:24:13
+   |
+24 |     let _ = format_description!(version);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `=`
+  --> ../tests/compile-fail/invalid_format_description.rs:25:41
+   |
+25 |     let _ = format_description!(version "");
+   |                                         ^^
+
+error: expected 1 or 2
+  --> ../tests/compile-fail/invalid_format_description.rs:26:13
+   |
+26 |     let _ = format_description!(version =);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: invalid format description version
+  --> ../tests/compile-fail/invalid_format_description.rs:27:43
+   |
+27 |     let _ = format_description!(version = 0);
+   |                                           ^
+
+error: unexpected end of input
+  --> ../tests/compile-fail/invalid_format_description.rs:28:13
+   |
+28 |     let _ = format_description!(version = 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: invalid format description version
+  --> ../tests/compile-fail/invalid_format_description.rs:29:43
+   |
+29 |     let _ = format_description!(version = 3);
+   |                                           ^
+
+error: expected 1 or 2
+  --> ../tests/compile-fail/invalid_format_description.rs:30:43
+   |
+30 |     let _ = format_description!(version = two);
+   |                                           ^^^
+
+error: invalid escape sequence
+  --> ../tests/compile-fail/invalid_format_description.rs:32:46
+   |
+32 |     let _ = format_description!(version = 2, r"\a");
+   |                                              ^^^^^
+
+error: unexpected end of input
+  --> ../tests/compile-fail/invalid_format_description.rs:33:46
+   |
+33 |     let _ = format_description!(version = 2, r"\");
+   |                                              ^^^^
+
+error: modifier must be of the form `key:value`
+  --> ../tests/compile-fail/invalid_format_description.rs:35:46
+   |
+35 |     let _ = format_description!(version = 2, "[year [month]]");
+   |                                              ^^^^^^^^^^^^^^^^
+
+error: expected whitespace after `optional`
+  --> ../tests/compile-fail/invalid_format_description.rs:36:46
+   |
+36 |     let _ = format_description!(version = 2, "[optional[]]");
+   |                                              ^^^^^^^^^^^^^^
+
+error: expected whitespace after `first`
+  --> ../tests/compile-fail/invalid_format_description.rs:37:46
+   |
+37 |     let _ = format_description!(version = 2, "[first[]]");
+   |                                              ^^^^^^^^^^^
+
+error: unclosed bracket
+  --> ../tests/compile-fail/invalid_format_description.rs:38:46
+   |
+38 |     let _ = format_description!(version = 2, "[optional []");
+   |                                              ^^^^^^^^^^^^^^
+
+error: unclosed bracket
+  --> ../tests/compile-fail/invalid_format_description.rs:39:46
+   |
+39 |     let _ = format_description!(version = 2, "[first []");
+   |                                              ^^^^^^^^^^^
+
+error: unclosed bracket
+  --> ../tests/compile-fail/invalid_format_description.rs:40:46
+   |
+40 |     let _ = format_description!(version = 2, "[optional [");
+   |                                              ^^^^^^^^^^^^^
+
+error: unclosed bracket
+  --> ../tests/compile-fail/invalid_format_description.rs:41:46
+   |
+41 |     let _ = format_description!(version = 2, "[optional [[year");
+   |                                              ^^^^^^^^^^^^^^^^^^
+
+error: expected opening bracket
+  --> ../tests/compile-fail/invalid_format_description.rs:42:46
+   |
+42 |     let _ = format_description!(version = 2, "[optional ");
+   |                                              ^^^^^^^^^^^^
+
+error: missing required modifier
+  --> ../tests/compile-fail/invalid_format_description.rs:44:33
+   |
+44 |     let _ = format_description!("[ignore]");
+   |                                 ^^^^^^^^^^
+
+error: invalid modifier value
+  --> ../tests/compile-fail/invalid_format_description.rs:45:33
+   |
+45 |     let _ = format_description!("[ignore count:0]");
+   |                                 ^^^^^^^^^^^^^^^^^^
diff --git a/tests/compile-fail/invalid_offset.rs b/tests/compile-fail/invalid_offset.rs
new file mode 100644
index 000000000..b33cf498b
--- /dev/null
+++ b/tests/compile-fail/invalid_offset.rs
@@ -0,0 +1,12 @@
+use time::macros::offset;
+
+fn main() {
+    let _ = offset!(+26);
+    let _ = offset!(+0:60);
+    let _ = offset!(+0:00:60);
+    let _ = offset!(0);
+    let _ = offset!();
+    let _ = offset!(+0a);
+    let _ = offset!(+0:0a);
+    let _ = offset!(+0:00:0a);
+}
diff --git a/tests/compile-fail/invalid_offset.stderr b/tests/compile-fail/invalid_offset.stderr
new file mode 100644
index 000000000..7b66393aa
--- /dev/null
+++ b/tests/compile-fail/invalid_offset.stderr
@@ -0,0 +1,49 @@
+error: invalid component: hour was 26
+ --> ../tests/compile-fail/invalid_offset.rs:4:22
+  |
+4 |     let _ = offset!(+26);
+  |                      ^^
+
+error: invalid component: minute was 60
+ --> ../tests/compile-fail/invalid_offset.rs:5:24
+  |
+5 |     let _ = offset!(+0:60);
+  |                        ^^
+
+error: invalid component: second was 60
+ --> ../tests/compile-fail/invalid_offset.rs:6:27
+  |
+6 |     let _ = offset!(+0:00:60);
+  |                           ^^
+
+error: unexpected token: 0
+ --> ../tests/compile-fail/invalid_offset.rs:7:21
+  |
+7 |     let _ = offset!(0);
+  |                     ^
+
+error: missing component: sign
+ --> ../tests/compile-fail/invalid_offset.rs:8:13
+  |
+8 |     let _ = offset!();
+  |             ^^^^^^^^^
+  |
+  = note: this error originates in the macro `offset` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: invalid component: hour was 0a
+ --> ../tests/compile-fail/invalid_offset.rs:9:22
+  |
+9 |     let _ = offset!(+0a);
+  |                      ^^
+
+error: invalid component: minute was 0a
+  --> ../tests/compile-fail/invalid_offset.rs:10:24
+   |
+10 |     let _ = offset!(+0:0a);
+   |                        ^^
+
+error: invalid component: second was 0a
+  --> ../tests/compile-fail/invalid_offset.rs:11:27
+   |
+11 |     let _ = offset!(+0:00:0a);
+   |                           ^^
diff --git a/tests/compile-fail/invalid_serializer.rs b/tests/compile-fail/invalid_serializer.rs
new file mode 100644
index 000000000..284d0b783
--- /dev/null
+++ b/tests/compile-fail/invalid_serializer.rs
@@ -0,0 +1,16 @@
+use time::serde;
+
+serde::format_description!(); // unexpected end of input
+serde::format_description!("bad string", OffsetDateTime, "[year] [month]"); // module name is not ident
+serde::format_description!(my_format: OffsetDateTime, "[year] [month]"); // not a comma
+serde::format_description!(my_format,); // missing formattable and string
+serde::format_description!(my_format, "[year] [month]"); // missing formattable
+serde::format_description!(OffsetDateTime, "[year] [month]"); // missing ident
+serde::format_description!(my_format, OffsetDateTime); // missing string format
+serde::format_description!(my_format, OffsetDateTime,); // missing string format
+serde::format_description!(my_format, OffsetDateTime "[year] [month]"); // missing comma
+serde::format_description!(my_format, OffsetDateTime : "[year] [month]"); // not a comma
+serde::format_description!(my_format, OffsetDateTime, "[bad]"); // bad component name
+serde::format_description!(my_format, OffsetDateTime, not_string); // string format wrong type
+
+fn main() {}
diff --git a/tests/compile-fail/invalid_serializer.stderr b/tests/compile-fail/invalid_serializer.stderr
new file mode 100644
index 000000000..3579ac33c
--- /dev/null
+++ b/tests/compile-fail/invalid_serializer.stderr
@@ -0,0 +1,113 @@
+error: unexpected end of input
+ --> ../tests/compile-fail/invalid_serializer.rs:3:1
+  |
+3 | serde::format_description!(); // unexpected end of input
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `serde::format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unexpected token: "bad string"
+ --> ../tests/compile-fail/invalid_serializer.rs:4:28
+  |
+4 | serde::format_description!("bad string", OffsetDateTime, "[year] [month]"); // module name is not ident
+  |                            ^^^^^^^^^^^^
+
+error: unexpected token: :
+ --> ../tests/compile-fail/invalid_serializer.rs:5:37
+  |
+5 | serde::format_description!(my_format: OffsetDateTime, "[year] [month]"); // not a comma
+  |                                     ^
+
+error: unexpected end of input
+ --> ../tests/compile-fail/invalid_serializer.rs:6:1
+  |
+6 | serde::format_description!(my_format,); // missing formattable and string
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `serde::format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unexpected token: "[year] [month]"
+ --> ../tests/compile-fail/invalid_serializer.rs:7:39
+  |
+7 | serde::format_description!(my_format, "[year] [month]"); // missing formattable
+  |                                       ^^^^^^^^^^^^^^^^
+
+error: unexpected token: "[year] [month]"
+ --> ../tests/compile-fail/invalid_serializer.rs:8:44
+  |
+8 | serde::format_description!(OffsetDateTime, "[year] [month]"); // missing ident
+  |                                            ^^^^^^^^^^^^^^^^
+
+error: unexpected end of input
+ --> ../tests/compile-fail/invalid_serializer.rs:9:1
+  |
+9 | serde::format_description!(my_format, OffsetDateTime); // missing string format
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `serde::format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unexpected end of input
+  --> ../tests/compile-fail/invalid_serializer.rs:10:1
+   |
+10 | serde::format_description!(my_format, OffsetDateTime,); // missing string format
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `serde::format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unexpected token: "[year] [month]"
+  --> ../tests/compile-fail/invalid_serializer.rs:11:54
+   |
+11 | serde::format_description!(my_format, OffsetDateTime "[year] [month]"); // missing comma
+   |                                                      ^^^^^^^^^^^^^^^^
+
+error: unexpected token: :
+  --> ../tests/compile-fail/invalid_serializer.rs:12:54
+   |
+12 | serde::format_description!(my_format, OffsetDateTime : "[year] [month]"); // not a comma
+   |                                                      ^
+
+error: invalid component
+  --> ../tests/compile-fail/invalid_serializer.rs:13:55
+   |
+13 | serde::format_description!(my_format, OffsetDateTime, "[bad]"); // bad component name
+   |                                                       ^^^^^^^
+
+error[E0432]: unresolved import `not_string`
+  --> ../tests/compile-fail/invalid_serializer.rs:14:1
+   |
+14 | serde::format_description!(my_format, OffsetDateTime, not_string); // string format wrong type
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no external crate `not_string`
+   |
+   = note: this error originates in the macro `serde::format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0391]: cycle detected when computing type of opaque `my_format::description::{opaque#0}`
+  --> ../tests/compile-fail/invalid_serializer.rs:14:1
+   |
+14 | serde::format_description!(my_format, OffsetDateTime, not_string); // string format wrong type
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: ...which requires borrow-checking `my_format::description`...
+  --> ../tests/compile-fail/invalid_serializer.rs:14:1
+   |
+14 | serde::format_description!(my_format, OffsetDateTime, not_string); // string format wrong type
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires promoting constants in MIR for `my_format::description`...
+  --> ../tests/compile-fail/invalid_serializer.rs:14:1
+   |
+14 | serde::format_description!(my_format, OffsetDateTime, not_string); // string format wrong type
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires const checking `my_format::description`...
+  --> ../tests/compile-fail/invalid_serializer.rs:14:1
+   |
+14 | serde::format_description!(my_format, OffsetDateTime, not_string); // string format wrong type
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: ...which requires computing whether `my_format::description::{opaque#0}` is freeze...
+   = note: ...which requires evaluating trait selection obligation `my_format::description::{opaque#0}: core::marker::Freeze`...
+   = note: ...which again requires computing type of opaque `my_format::description::{opaque#0}`, completing the cycle
+note: cycle used when computing type of `my_format::description::{opaque#0}`
+  --> ../tests/compile-fail/invalid_serializer.rs:14:1
+   |
+14 | serde::format_description!(my_format, OffsetDateTime, not_string); // string format wrong type
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+   = note: this error originates in the macro `serde::format_description` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/compile-fail/invalid_time.rs b/tests/compile-fail/invalid_time.rs
new file mode 100644
index 000000000..514795245
--- /dev/null
+++ b/tests/compile-fail/invalid_time.rs
@@ -0,0 +1,17 @@
+use time::macros::time;
+
+fn main() {
+    let _ = time!(24:00);
+    let _ = time!(0:60);
+    let _ = time!(0:00:60);
+    let _ = time!(x);
+    let _ = time!(0:00:00 x);
+    let _ = time!("");
+    let _ = time!(0:);
+    let _ = time!(0,);
+    let _ = time!(0:00:0a);
+    let _ = time!(0:00 pm);
+    let _ = time!(0);
+    let _ = time!(0 pm);
+    let _ = time!(1 am :);
+}
diff --git a/tests/compile-fail/invalid_time.stderr b/tests/compile-fail/invalid_time.stderr
new file mode 100644
index 000000000..303f57327
--- /dev/null
+++ b/tests/compile-fail/invalid_time.stderr
@@ -0,0 +1,81 @@
+error: invalid component: hour was 24
+ --> $DIR/invalid_time.rs:4:19
+  |
+4 |     let _ = time!(24:00);
+  |                   ^^
+
+error: invalid component: minute was 60
+ --> $DIR/invalid_time.rs:5:21
+  |
+5 |     let _ = time!(0:60);
+  |                     ^^
+
+error: invalid component: second was 60
+ --> $DIR/invalid_time.rs:6:24
+  |
+6 |     let _ = time!(0:00:60);
+  |                        ^^
+
+error: unexpected token: x
+ --> $DIR/invalid_time.rs:7:19
+  |
+7 |     let _ = time!(x);
+  |                   ^
+
+error: unexpected token: x
+ --> $DIR/invalid_time.rs:8:27
+  |
+8 |     let _ = time!(0:00:00 x);
+  |                           ^
+
+error: invalid component: hour was ""
+ --> $DIR/invalid_time.rs:9:19
+  |
+9 |     let _ = time!("");
+  |                   ^^
+
+error: unexpected end of input
+  --> $DIR/invalid_time.rs:10:13
+   |
+10 |     let _ = time!(0:);
+   |             ^^^^^^^^^
+   |
+   = note: this error originates in the macro `time` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unexpected token: ,
+  --> $DIR/invalid_time.rs:11:20
+   |
+11 |     let _ = time!(0,);
+   |                    ^
+
+error: invalid component: second was 0a
+  --> $DIR/invalid_time.rs:12:24
+   |
+12 |     let _ = time!(0:00:0a);
+   |                        ^^
+
+error: invalid component: hour was 0
+  --> $DIR/invalid_time.rs:13:19
+   |
+13 |     let _ = time!(0:00 pm);
+   |                   ^^^^^^^
+
+error: unexpected end of input
+  --> $DIR/invalid_time.rs:14:13
+   |
+14 |     let _ = time!(0);
+   |             ^^^^^^^^
+   |
+   = note: this error originates in the macro `time` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: invalid component: hour was 0
+  --> $DIR/invalid_time.rs:15:19
+   |
+15 |     let _ = time!(0 pm);
+   |                   ^^^^
+
+error: unexpected token: :
+  --> $DIR/invalid_time.rs:16:24
+   |
+16 |     let _ = time!(1 am :);
+   |                        ^
diff --git a/tests/date.rs b/tests/date.rs
new file mode 100644
index 000000000..74ab27db0
--- /dev/null
+++ b/tests/date.rs
@@ -0,0 +1,1188 @@
+use std::cmp::Ordering;
+use std::collections::HashSet;
+
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::{date, datetime, time};
+use time::{util, Date, Duration, Month, Weekday};
+
+#[test]
+fn debug() {
+    assert_eq!(format!("{:?}", date!(2020 - 02 - 03)), "2020-02-03");
+}
+
+#[test]
+fn weeks_in_year_exhaustive() {
+    let years_with_53 = [
+        4, 9, 15, 20, 26, 32, 37, 43, 48, 54, 60, 65, 71, 76, 82, 88, 93, 99, 105, 111, 116, 122,
+        128, 133, 139, 144, 150, 156, 161, 167, 172, 178, 184, 189, 195, 201, 207, 212, 218, 224,
+        229, 235, 240, 246, 252, 257, 263, 268, 274, 280, 285, 291, 296, 303, 308, 314, 320, 325,
+        331, 336, 342, 348, 353, 359, 364, 370, 376, 381, 387, 392, 398,
+    ]
+    .iter()
+    .copied()
+    .collect::<HashSet<_>>();
+
+    for year in 0..400 {
+        assert_eq!(
+            util::weeks_in_year(year),
+            if years_with_53.contains(&year) {
+                53
+            } else {
+                52
+            }
+        );
+    }
+}
+
+// Test all dominical letters. For leap years, check the dates immediately preceding and after the
+// leap day.
+
+#[test]
+fn test_monday_based_week_dominical_a() {
+    assert_eq!(date!(2023 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2023 - 01 - 02).monday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 03).monday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 07).monday_based_week(), 1);
+}
+
+#[test]
+fn test_monday_based_week_dominical_b() {
+    assert_eq!(date!(2022 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2022 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2022 - 01 - 03).monday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 07).monday_based_week(), 1);
+}
+
+#[test]
+fn test_monday_based_week_dominical_c() {
+    assert_eq!(date!(2021 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2021 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2021 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2021 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2021 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2021 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2021 - 01 - 07).monday_based_week(), 1);
+}
+
+#[test]
+fn test_monday_based_week_dominical_d() {
+    assert_eq!(date!(2026 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2026 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2026 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2026 - 01 - 04).monday_based_week(), 0);
+    assert_eq!(date!(2026 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2026 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2026 - 01 - 07).monday_based_week(), 1);
+}
+
+#[test]
+fn test_monday_based_week_dominical_e() {
+    assert_eq!(date!(2025 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 04).monday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 05).monday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2025 - 01 - 07).monday_based_week(), 1);
+}
+
+#[test]
+fn test_monday_based_week_dominical_f() {
+    assert_eq!(date!(2019 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 04).monday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 05).monday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 06).monday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 07).monday_based_week(), 1);
+}
+
+#[test]
+fn test_monday_based_week_dominical_g() {
+    assert_eq!(date!(2018 - 01 - 01).monday_based_week(), 1);
+    assert_eq!(date!(2018 - 01 - 02).monday_based_week(), 1);
+    assert_eq!(date!(2018 - 01 - 03).monday_based_week(), 1);
+    assert_eq!(date!(2018 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2018 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2018 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2018 - 01 - 07).monday_based_week(), 1);
+}
+
+#[test]
+fn test_monday_based_week_dominical_ag() {
+    assert_eq!(date!(2012 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2012 - 01 - 02).monday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 03).monday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 07).monday_based_week(), 1);
+    assert_eq!(date!(2012 - 02 - 28).monday_based_week(), 9);
+    assert_eq!(date!(2012 - 02 - 29).monday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 01).monday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 02).monday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 03).monday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 04).monday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 05).monday_based_week(), 10);
+    assert_eq!(date!(2012 - 03 - 06).monday_based_week(), 10);
+    assert_eq!(date!(2012 - 03 - 07).monday_based_week(), 10);
+}
+
+#[test]
+fn test_monday_based_week_dominical_ba() {
+    assert_eq!(date!(2028 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2028 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2028 - 01 - 03).monday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 07).monday_based_week(), 1);
+    assert_eq!(date!(2028 - 02 - 28).monday_based_week(), 9);
+    assert_eq!(date!(2028 - 02 - 29).monday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 01).monday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 02).monday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 03).monday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 04).monday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 05).monday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 06).monday_based_week(), 10);
+    assert_eq!(date!(2028 - 03 - 07).monday_based_week(), 10);
+}
+
+#[test]
+fn test_monday_based_week_dominical_cb() {
+    assert_eq!(date!(2016 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2016 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2016 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2016 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2016 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2016 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2016 - 01 - 07).monday_based_week(), 1);
+    assert_eq!(date!(2016 - 02 - 28).monday_based_week(), 8);
+    assert_eq!(date!(2016 - 02 - 29).monday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 01).monday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 02).monday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 03).monday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 04).monday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 05).monday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 06).monday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 07).monday_based_week(), 10);
+}
+
+#[test]
+fn test_monday_based_week_dominical_dc() {
+    assert_eq!(date!(2032 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2032 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2032 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2032 - 01 - 04).monday_based_week(), 0);
+    assert_eq!(date!(2032 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2032 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2032 - 01 - 07).monday_based_week(), 1);
+    assert_eq!(date!(2032 - 02 - 28).monday_based_week(), 8);
+    assert_eq!(date!(2032 - 02 - 29).monday_based_week(), 8);
+    assert_eq!(date!(2032 - 03 - 01).monday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 02).monday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 03).monday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 04).monday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 05).monday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 06).monday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 07).monday_based_week(), 9);
+}
+
+#[test]
+fn test_monday_based_week_dominical_ed() {
+    assert_eq!(date!(2020 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 04).monday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 05).monday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2020 - 01 - 07).monday_based_week(), 1);
+    assert_eq!(date!(2020 - 02 - 28).monday_based_week(), 8);
+    assert_eq!(date!(2020 - 02 - 29).monday_based_week(), 8);
+    assert_eq!(date!(2020 - 03 - 01).monday_based_week(), 8);
+    assert_eq!(date!(2020 - 03 - 02).monday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 03).monday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 04).monday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 05).monday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 06).monday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 07).monday_based_week(), 9);
+}
+
+#[test]
+fn test_monday_based_week_dominical_fe() {
+    assert_eq!(date!(2036 - 01 - 01).monday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 02).monday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 03).monday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 04).monday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 05).monday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 06).monday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 07).monday_based_week(), 1);
+    assert_eq!(date!(2036 - 02 - 28).monday_based_week(), 8);
+    assert_eq!(date!(2036 - 02 - 29).monday_based_week(), 8);
+    assert_eq!(date!(2036 - 03 - 01).monday_based_week(), 8);
+    assert_eq!(date!(2036 - 03 - 02).monday_based_week(), 8);
+    assert_eq!(date!(2036 - 03 - 03).monday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 04).monday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 05).monday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 06).monday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 07).monday_based_week(), 9);
+}
+
+#[test]
+fn test_monday_based_week_dominical_gf() {
+    assert_eq!(date!(2024 - 01 - 01).monday_based_week(), 1);
+    assert_eq!(date!(2024 - 01 - 02).monday_based_week(), 1);
+    assert_eq!(date!(2024 - 01 - 03).monday_based_week(), 1);
+    assert_eq!(date!(2024 - 01 - 04).monday_based_week(), 1);
+    assert_eq!(date!(2024 - 01 - 05).monday_based_week(), 1);
+    assert_eq!(date!(2024 - 01 - 06).monday_based_week(), 1);
+    assert_eq!(date!(2024 - 01 - 07).monday_based_week(), 1);
+    assert_eq!(date!(2024 - 02 - 28).monday_based_week(), 9);
+    assert_eq!(date!(2024 - 02 - 29).monday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 01).monday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 02).monday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 03).monday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 04).monday_based_week(), 10);
+    assert_eq!(date!(2024 - 03 - 05).monday_based_week(), 10);
+    assert_eq!(date!(2024 - 03 - 06).monday_based_week(), 10);
+    assert_eq!(date!(2024 - 03 - 07).monday_based_week(), 10);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_a() {
+    assert_eq!(date!(2023 - 01 - 01).sunday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 02).sunday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 03).sunday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2023 - 01 - 07).sunday_based_week(), 1);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_b() {
+    assert_eq!(date!(2022 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2022 - 01 - 02).sunday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 03).sunday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2022 - 01 - 07).sunday_based_week(), 1);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_c() {
+    assert_eq!(date!(2021 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2021 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2021 - 01 - 03).sunday_based_week(), 1);
+    assert_eq!(date!(2021 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2021 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2021 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2021 - 01 - 07).sunday_based_week(), 1);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_d() {
+    assert_eq!(date!(2026 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2026 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2026 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2026 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2026 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2026 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2026 - 01 - 07).sunday_based_week(), 1);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_e() {
+    assert_eq!(date!(2025 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 04).sunday_based_week(), 0);
+    assert_eq!(date!(2025 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2025 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2025 - 01 - 07).sunday_based_week(), 1);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_f() {
+    assert_eq!(date!(2019 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 04).sunday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 05).sunday_based_week(), 0);
+    assert_eq!(date!(2019 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2019 - 01 - 07).sunday_based_week(), 1);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_g() {
+    assert_eq!(date!(2018 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2018 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2018 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2018 - 01 - 04).sunday_based_week(), 0);
+    assert_eq!(date!(2018 - 01 - 05).sunday_based_week(), 0);
+    assert_eq!(date!(2018 - 01 - 06).sunday_based_week(), 0);
+    assert_eq!(date!(2018 - 01 - 07).sunday_based_week(), 1);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_ag() {
+    assert_eq!(date!(2012 - 01 - 01).sunday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 02).sunday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 03).sunday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2012 - 01 - 07).sunday_based_week(), 1);
+    assert_eq!(date!(2012 - 02 - 28).sunday_based_week(), 9);
+    assert_eq!(date!(2012 - 02 - 29).sunday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 01).sunday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 02).sunday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 03).sunday_based_week(), 9);
+    assert_eq!(date!(2012 - 03 - 04).sunday_based_week(), 10);
+    assert_eq!(date!(2012 - 03 - 05).sunday_based_week(), 10);
+    assert_eq!(date!(2012 - 03 - 06).sunday_based_week(), 10);
+    assert_eq!(date!(2012 - 03 - 07).sunday_based_week(), 10);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_ba() {
+    assert_eq!(date!(2028 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2028 - 01 - 02).sunday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 03).sunday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2028 - 01 - 07).sunday_based_week(), 1);
+    assert_eq!(date!(2028 - 02 - 28).sunday_based_week(), 9);
+    assert_eq!(date!(2028 - 02 - 29).sunday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 01).sunday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 02).sunday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 03).sunday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 04).sunday_based_week(), 9);
+    assert_eq!(date!(2028 - 03 - 05).sunday_based_week(), 10);
+    assert_eq!(date!(2028 - 03 - 06).sunday_based_week(), 10);
+    assert_eq!(date!(2028 - 03 - 07).sunday_based_week(), 10);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_cb() {
+    assert_eq!(date!(2016 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2016 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2016 - 01 - 03).sunday_based_week(), 1);
+    assert_eq!(date!(2016 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2016 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2016 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2016 - 01 - 07).sunday_based_week(), 1);
+    assert_eq!(date!(2016 - 02 - 28).sunday_based_week(), 9);
+    assert_eq!(date!(2016 - 02 - 29).sunday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 01).sunday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 02).sunday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 03).sunday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 04).sunday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 05).sunday_based_week(), 9);
+    assert_eq!(date!(2016 - 03 - 06).sunday_based_week(), 10);
+    assert_eq!(date!(2016 - 03 - 07).sunday_based_week(), 10);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_dc() {
+    assert_eq!(date!(2032 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2032 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2032 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2032 - 01 - 04).sunday_based_week(), 1);
+    assert_eq!(date!(2032 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2032 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2032 - 01 - 07).sunday_based_week(), 1);
+    assert_eq!(date!(2032 - 02 - 28).sunday_based_week(), 8);
+    assert_eq!(date!(2032 - 02 - 29).sunday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 01).sunday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 02).sunday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 03).sunday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 04).sunday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 05).sunday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 06).sunday_based_week(), 9);
+    assert_eq!(date!(2032 - 03 - 07).sunday_based_week(), 10);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_ed() {
+    assert_eq!(date!(2020 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 04).sunday_based_week(), 0);
+    assert_eq!(date!(2020 - 01 - 05).sunday_based_week(), 1);
+    assert_eq!(date!(2020 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2020 - 01 - 07).sunday_based_week(), 1);
+    assert_eq!(date!(2020 - 02 - 28).sunday_based_week(), 8);
+    assert_eq!(date!(2020 - 02 - 29).sunday_based_week(), 8);
+    assert_eq!(date!(2020 - 03 - 01).sunday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 02).sunday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 03).sunday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 04).sunday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 05).sunday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 06).sunday_based_week(), 9);
+    assert_eq!(date!(2020 - 03 - 07).sunday_based_week(), 9);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_fe() {
+    assert_eq!(date!(2036 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 04).sunday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 05).sunday_based_week(), 0);
+    assert_eq!(date!(2036 - 01 - 06).sunday_based_week(), 1);
+    assert_eq!(date!(2036 - 01 - 07).sunday_based_week(), 1);
+    assert_eq!(date!(2036 - 02 - 28).sunday_based_week(), 8);
+    assert_eq!(date!(2036 - 02 - 29).sunday_based_week(), 8);
+    assert_eq!(date!(2036 - 03 - 01).sunday_based_week(), 8);
+    assert_eq!(date!(2036 - 03 - 02).sunday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 03).sunday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 04).sunday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 05).sunday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 06).sunday_based_week(), 9);
+    assert_eq!(date!(2036 - 03 - 07).sunday_based_week(), 9);
+}
+
+#[test]
+fn test_sunday_based_week_dominical_gf() {
+    assert_eq!(date!(2024 - 01 - 01).sunday_based_week(), 0);
+    assert_eq!(date!(2024 - 01 - 02).sunday_based_week(), 0);
+    assert_eq!(date!(2024 - 01 - 03).sunday_based_week(), 0);
+    assert_eq!(date!(2024 - 01 - 04).sunday_based_week(), 0);
+    assert_eq!(date!(2024 - 01 - 05).sunday_based_week(), 0);
+    assert_eq!(date!(2024 - 01 - 06).sunday_based_week(), 0);
+    assert_eq!(date!(2024 - 01 - 07).sunday_based_week(), 1);
+    assert_eq!(date!(2024 - 02 - 28).sunday_based_week(), 8);
+    assert_eq!(date!(2024 - 02 - 29).sunday_based_week(), 8);
+    assert_eq!(date!(2024 - 03 - 01).sunday_based_week(), 8);
+    assert_eq!(date!(2024 - 03 - 02).sunday_based_week(), 8);
+    assert_eq!(date!(2024 - 03 - 03).sunday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 04).sunday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 05).sunday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 06).sunday_based_week(), 9);
+    assert_eq!(date!(2024 - 03 - 07).sunday_based_week(), 9);
+}
+
+#[test]
+fn from_iso_week_date() {
+    use Weekday::*;
+    assert!(Date::from_iso_week_date(2019, 1, Monday).is_ok());
+    assert!(Date::from_iso_week_date(2019, 1, Tuesday).is_ok());
+    assert!(Date::from_iso_week_date(2020, 53, Friday).is_ok());
+    assert!(Date::from_iso_week_date(-9999, 1, Monday).is_ok());
+    // 2019 doesn't have 53 weeks.
+    assert!(Date::from_iso_week_date(2019, 53, Monday).is_err());
+    // Regression test. Year zero (1 BCE) has dominical letter BA.
+    assert_eq!(
+        Date::from_iso_week_date(-1, 52, Saturday),
+        Ok(date!(0000 - 01 - 01))
+    );
+    assert_eq!(date!(-0001-W 52-6), date!(0000 - 01 - 01));
+}
+
+#[test]
+fn year() {
+    assert_eq!(date!(2019 - 002).year(), 2019);
+    assert_eq!(date!(2020 - 002).year(), 2020);
+}
+
+#[test]
+fn month() {
+    assert_eq!(date!(2019 - 002).month(), Month::January);
+    assert_eq!(date!(2020 - 002).month(), Month::January);
+    assert_eq!(date!(2019 - 060).month(), Month::March);
+    assert_eq!(date!(2020 - 060).month(), Month::February);
+}
+
+#[test]
+fn day() {
+    assert_eq!(date!(2019 - 002).day(), 2);
+    assert_eq!(date!(2020 - 002).day(), 2);
+    assert_eq!(date!(2019 - 060).day(), 1);
+    assert_eq!(date!(2020 - 060).day(), 29);
+}
+
+#[test]
+fn iso_week() {
+    assert_eq!(date!(2019 - 01 - 01).iso_week(), 1);
+    assert_eq!(date!(2019 - 10 - 04).iso_week(), 40);
+    assert_eq!(date!(2020 - 01 - 01).iso_week(), 1);
+    assert_eq!(date!(2020 - 12 - 31).iso_week(), 53);
+    assert_eq!(date!(2021 - 01 - 01).iso_week(), 53);
+}
+
+#[test]
+fn to_calendar_date() {
+    assert_eq!(
+        date!(2019 - 01 - 02).to_calendar_date(),
+        (2019, Month::January, 2)
+    );
+    assert_eq!(
+        date!(2019 - 02 - 02).to_calendar_date(),
+        (2019, Month::February, 2)
+    );
+    assert_eq!(
+        date!(2019 - 03 - 02).to_calendar_date(),
+        (2019, Month::March, 2)
+    );
+    assert_eq!(
+        date!(2019 - 04 - 02).to_calendar_date(),
+        (2019, Month::April, 2)
+    );
+    assert_eq!(
+        date!(2019 - 05 - 02).to_calendar_date(),
+        (2019, Month::May, 2)
+    );
+    assert_eq!(
+        date!(2019 - 06 - 02).to_calendar_date(),
+        (2019, Month::June, 2)
+    );
+    assert_eq!(
+        date!(2019 - 07 - 02).to_calendar_date(),
+        (2019, Month::July, 2)
+    );
+    assert_eq!(
+        date!(2019 - 08 - 02).to_calendar_date(),
+        (2019, Month::August, 2)
+    );
+    assert_eq!(
+        date!(2019 - 09 - 02).to_calendar_date(),
+        (2019, Month::September, 2)
+    );
+    assert_eq!(
+        date!(2019 - 10 - 02).to_calendar_date(),
+        (2019, Month::October, 2)
+    );
+    assert_eq!(
+        date!(2019 - 11 - 02).to_calendar_date(),
+        (2019, Month::November, 2)
+    );
+    assert_eq!(
+        date!(2019 - 12 - 02).to_calendar_date(),
+        (2019, Month::December, 2)
+    );
+}
+
+#[test]
+fn to_ordinal_date() {
+    assert_eq!(date!(2019 - 01 - 01).to_ordinal_date(), (2019, 1));
+}
+
+#[test]
+fn to_iso_week_date() {
+    use Weekday::*;
+    assert_eq!(date!(2019 - 01 - 01).to_iso_week_date(), (2019, 1, Tuesday));
+    assert_eq!(date!(2019 - 10 - 04).to_iso_week_date(), (2019, 40, Friday));
+    assert_eq!(
+        date!(2020 - 01 - 01).to_iso_week_date(),
+        (2020, 1, Wednesday)
+    );
+    assert_eq!(
+        date!(2020 - 12 - 31).to_iso_week_date(),
+        (2020, 53, Thursday)
+    );
+    assert_eq!(date!(2021 - 01 - 01).to_iso_week_date(), (2020, 53, Friday));
+    assert_eq!(date!(0000 - 01 - 01).to_iso_week_date(), (-1, 52, Saturday));
+}
+
+#[test]
+fn weekday() {
+    use Weekday::*;
+    assert_eq!(date!(2019 - 01 - 01).weekday(), Tuesday);
+    assert_eq!(date!(2019 - 02 - 01).weekday(), Friday);
+    assert_eq!(date!(2019 - 03 - 01).weekday(), Friday);
+    assert_eq!(date!(2019 - 04 - 01).weekday(), Monday);
+    assert_eq!(date!(2019 - 05 - 01).weekday(), Wednesday);
+    assert_eq!(date!(2019 - 06 - 01).weekday(), Saturday);
+    assert_eq!(date!(2019 - 07 - 01).weekday(), Monday);
+    assert_eq!(date!(2019 - 08 - 01).weekday(), Thursday);
+    assert_eq!(date!(2019 - 09 - 01).weekday(), Sunday);
+    assert_eq!(date!(2019 - 10 - 01).weekday(), Tuesday);
+    assert_eq!(date!(2019 - 11 - 01).weekday(), Friday);
+    assert_eq!(date!(2019 - 12 - 01).weekday(), Sunday);
+}
+
+#[test]
+fn next_day() {
+    assert_eq!(
+        date!(2019 - 01 - 01).next_day(),
+        Some(date!(2019 - 01 - 02))
+    );
+    assert_eq!(
+        date!(2019 - 01 - 31).next_day(),
+        Some(date!(2019 - 02 - 01))
+    );
+    assert_eq!(
+        date!(2019 - 12 - 31).next_day(),
+        Some(date!(2020 - 01 - 01))
+    );
+    assert_eq!(
+        date!(2020 - 12 - 31).next_day(),
+        Some(date!(2021 - 01 - 01))
+    );
+    assert_eq!(Date::MAX.next_day(), None);
+}
+
+#[test]
+fn previous_day() {
+    assert_eq!(
+        date!(2019 - 01 - 02).previous_day(),
+        Some(date!(2019 - 01 - 01))
+    );
+    assert_eq!(
+        date!(2019 - 02 - 01).previous_day(),
+        Some(date!(2019 - 01 - 31))
+    );
+    assert_eq!(
+        date!(2020 - 01 - 01).previous_day(),
+        Some(date!(2019 - 12 - 31))
+    );
+    assert_eq!(
+        date!(2021 - 01 - 01).previous_day(),
+        Some(date!(2020 - 12 - 31))
+    );
+    assert_eq!(Date::MIN.previous_day(), None);
+}
+
+#[test]
+fn to_julian_day() {
+    assert_eq!(date!(-999_999 - 01 - 01).to_julian_day(), -363_521_074);
+    assert_eq!(date!(-9999 - 01 - 01).to_julian_day(), -1_930_999);
+    assert_eq!(date!(-4713 - 11 - 24).to_julian_day(), 0);
+    assert_eq!(date!(2000 - 01 - 01).to_julian_day(), 2_451_545);
+    assert_eq!(date!(2019 - 01 - 01).to_julian_day(), 2_458_485);
+    assert_eq!(date!(2019 - 12 - 31).to_julian_day(), 2_458_849);
+}
+
+#[test]
+fn from_julian_day() {
+    assert_eq!(
+        Date::from_julian_day(-363_521_074),
+        Ok(date!(-999_999 - 01 - 01))
+    );
+    assert_eq!(
+        Date::from_julian_day(-1_930_999),
+        Ok(date!(-9999 - 01 - 01))
+    );
+    assert_eq!(Date::from_julian_day(0), Ok(date!(-4713 - 11 - 24)));
+    assert_eq!(Date::from_julian_day(2_451_545), Ok(date!(2000 - 01 - 01)));
+    assert_eq!(Date::from_julian_day(2_458_485), Ok(date!(2019 - 01 - 01)));
+    assert_eq!(Date::from_julian_day(2_458_849), Ok(date!(2019 - 12 - 31)));
+    assert!(Date::from_julian_day(i32::MAX).is_err());
+}
+
+#[test]
+fn midnight() {
+    assert_eq!(date!(1970 - 01 - 01).midnight(), datetime!(1970-01-01 0:00));
+}
+
+#[test]
+fn with_time() {
+    assert_eq!(
+        date!(1970 - 01 - 01).with_time(time!(0:00)),
+        datetime!(1970-01-01 0:00),
+    );
+}
+
+#[test]
+fn with_hms() {
+    assert_eq!(
+        date!(1970 - 01 - 01).with_hms(0, 0, 0),
+        Ok(datetime!(1970-01-01 0:00)),
+    );
+    assert!(date!(1970 - 01 - 01).with_hms(24, 0, 0).is_err());
+}
+
+#[test]
+fn with_hms_milli() {
+    assert_eq!(
+        date!(1970 - 01 - 01).with_hms_milli(0, 0, 0, 0),
+        Ok(datetime!(1970-01-01 0:00)),
+    );
+    assert!(date!(1970 - 01 - 01).with_hms_milli(24, 0, 0, 0).is_err());
+}
+
+#[test]
+fn with_hms_micro() {
+    assert_eq!(
+        date!(1970 - 01 - 01).with_hms_micro(0, 0, 0, 0),
+        Ok(datetime!(1970-01-01 0:00)),
+    );
+    assert!(date!(1970 - 01 - 01).with_hms_micro(24, 0, 0, 0).is_err());
+}
+
+#[test]
+fn with_hms_nano() {
+    assert_eq!(
+        date!(1970 - 01 - 01).with_hms_nano(0, 0, 0, 0),
+        Ok(datetime!(1970-01-01 0:00)),
+    );
+    assert!(date!(1970 - 01 - 01).with_hms_nano(24, 0, 0, 0).is_err());
+}
+
+#[test]
+fn add() {
+    assert_eq!(date!(2019 - 01 - 01) + 5.days(), date!(2019 - 01 - 06));
+    assert_eq!(date!(2019 - 12 - 31) + 1.days(), date!(2020 - 01 - 01));
+}
+
+#[test]
+fn add_std() {
+    assert_eq!(date!(2019 - 01 - 01) + 5.std_days(), date!(2019 - 01 - 06));
+    assert_eq!(date!(2019 - 12 - 31) + 1.std_days(), date!(2020 - 01 - 01));
+}
+
+#[test]
+fn add_assign() {
+    let mut date = date!(2019 - 12 - 31);
+    date += 1.days();
+    assert_eq!(date, date!(2020 - 01 - 01));
+}
+
+#[test]
+fn add_assign_std() {
+    let mut date = date!(2019 - 12 - 31);
+    date += 1.std_days();
+    assert_eq!(date, date!(2020 - 01 - 01));
+}
+
+#[test]
+fn sub() {
+    assert_eq!(date!(2019 - 01 - 06) - 5.days(), date!(2019 - 01 - 01));
+    assert_eq!(date!(2020 - 01 - 01) - 1.days(), date!(2019 - 12 - 31));
+}
+
+#[test]
+fn sub_std() {
+    assert_eq!(date!(2019 - 01 - 06) - 5.std_days(), date!(2019 - 01 - 01));
+    assert_eq!(date!(2020 - 01 - 01) - 1.std_days(), date!(2019 - 12 - 31));
+}
+
+#[test]
+fn sub_assign() {
+    let mut date = date!(2020 - 01 - 01);
+    date -= 1.days();
+    assert_eq!(date, date!(2019 - 12 - 31));
+}
+
+#[test]
+fn sub_assign_std() {
+    let mut date = date!(2020 - 01 - 01);
+    date -= 1.std_days();
+    assert_eq!(date, date!(2019 - 12 - 31));
+}
+
+#[test]
+fn sub_self() {
+    assert_eq!(date!(2019 - 01 - 06) - date!(2019 - 01 - 01), 5.days());
+    assert_eq!(date!(2020 - 01 - 01) - date!(2019 - 12 - 31), 1.days());
+}
+
+#[test]
+fn partial_ord() {
+    let first = date!(2019 - 01 - 01);
+    let second = date!(2019 - 01 - 02);
+
+    assert_eq!(first.partial_cmp(&first), Some(Ordering::Equal));
+    assert_eq!(first.partial_cmp(&second), Some(Ordering::Less));
+    assert_eq!(second.partial_cmp(&first), Some(Ordering::Greater));
+}
+
+#[test]
+fn ord() {
+    let first = date!(2019 - 01 - 01);
+    let second = date!(2019 - 01 - 02);
+
+    assert_eq!(first.cmp(&first), Ordering::Equal);
+    assert_eq!(first.cmp(&second), Ordering::Less);
+    assert_eq!(second.cmp(&first), Ordering::Greater);
+}
+
+#[test]
+fn regression_check() {
+    let (year, week, weekday) = (date!(0063 - 365)).to_iso_week_date();
+    assert_eq!(year, 64);
+    assert_eq!(week, 1);
+    assert_eq!(weekday, Weekday::Monday);
+}
+
+#[test]
+fn checked_add_duration() {
+    // Adding subday duration
+    assert_eq!(
+        Date::MIN.checked_add(Duration::new(86_399, 999_999_999)),
+        Some(Date::MIN)
+    );
+    assert_eq!(
+        Date::MIN.checked_add(Duration::new(-86_399, -999_999_999)),
+        Some(Date::MIN)
+    );
+
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_add(Duration::new(86_399, 999_999_999)),
+        Some(date!(2021 - 10 - 25))
+    );
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_add(Duration::new(-86_399, -999_999_999)),
+        Some(date!(2021 - 10 - 25))
+    );
+
+    assert_eq!(
+        Date::MAX.checked_add(Duration::new(86_399, 999_999_999)),
+        Some(Date::MAX)
+    );
+    assert_eq!(
+        Date::MAX.checked_add(Duration::new(-86_399, -999_999_999)),
+        Some(Date::MAX)
+    );
+
+    // Adding 1 day duration
+    assert_eq!(Date::MIN.checked_add(Duration::DAY), Date::MIN.next_day());
+    assert_eq!(Date::MIN.checked_add(-Duration::DAY), None);
+
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_add(Duration::DAY),
+        Some(date!(2021 - 10 - 26))
+    );
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_add(-Duration::DAY),
+        Some(date!(2021 - 10 - 24))
+    );
+
+    assert_eq!(Date::MAX.checked_add(Duration::DAY), None);
+    assert_eq!(
+        Date::MAX.checked_add(-Duration::DAY),
+        Date::MAX.previous_day()
+    );
+
+    // Adding MIN/MAX duration
+    assert_eq!(Date::MIN.checked_add(Duration::MIN), None);
+    assert_eq!(Date::MAX.checked_add(Duration::MAX), None);
+}
+
+#[test]
+fn checked_sub_duration() {
+    // Subtracting subday duration
+    assert_eq!(
+        Date::MIN.checked_sub(Duration::new(86_399, 999_999_999)),
+        Some(Date::MIN)
+    );
+    assert_eq!(
+        Date::MIN.checked_sub(Duration::new(-86_399, -999_999_999)),
+        Some(Date::MIN)
+    );
+
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_sub(Duration::new(86_399, 999_999_999)),
+        Some(date!(2021 - 10 - 25))
+    );
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_sub(Duration::new(-86_399, -999_999_999)),
+        Some(date!(2021 - 10 - 25))
+    );
+
+    assert_eq!(
+        Date::MAX.checked_sub(Duration::new(86_399, 999_999_999)),
+        Some(Date::MAX)
+    );
+    assert_eq!(
+        Date::MAX.checked_sub(Duration::new(-86_399, -999_999_999)),
+        Some(Date::MAX)
+    );
+
+    // Subtracting 1 day duration
+    assert_eq!(Date::MIN.checked_sub(Duration::DAY), None);
+    assert_eq!(Date::MIN.checked_sub(-Duration::DAY), Date::MIN.next_day());
+
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_sub(Duration::DAY),
+        Some(date!(2021 - 10 - 24))
+    );
+    assert_eq!(
+        date!(2021 - 10 - 25).checked_sub(-Duration::DAY),
+        Some(date!(2021 - 10 - 26))
+    );
+
+    assert_eq!(
+        Date::MAX.checked_sub(Duration::DAY),
+        Date::MAX.previous_day()
+    );
+    assert_eq!(Date::MAX.checked_sub(-Duration::DAY), None);
+
+    // Subtracting MIN/MAX duration
+    assert_eq!(Date::MIN.checked_sub(Duration::MAX), None);
+    assert_eq!(Date::MAX.checked_sub(Duration::MIN), None);
+}
+
+#[test]
+fn saturating_add_duration() {
+    assert_eq!(
+        date!(2021 - 11 - 05).saturating_add(2.days()),
+        date!(2021 - 11 - 07)
+    );
+    assert_eq!(
+        date!(2021 - 11 - 05).saturating_add((-2).days()),
+        date!(2021 - 11 - 03)
+    );
+
+    // Adding with underflow
+    assert_eq!(Date::MIN.saturating_add((-10).days()), Date::MIN);
+
+    // Adding with overflow
+    assert_eq!(Date::MAX.saturating_add(10.days()), Date::MAX);
+
+    // Adding zero duration at boundaries
+    assert_eq!(Date::MIN.saturating_add(Duration::ZERO), Date::MIN);
+    assert_eq!(Date::MAX.saturating_add(Duration::ZERO), Date::MAX);
+}
+
+#[test]
+fn saturating_sub_duration() {
+    assert_eq!(
+        date!(2021 - 11 - 05).saturating_sub(2.days()),
+        date!(2021 - 11 - 03)
+    );
+    assert_eq!(
+        date!(2021 - 11 - 05).saturating_sub((-2).days()),
+        date!(2021 - 11 - 07)
+    );
+
+    // Subtracting with underflow
+    assert_eq!(Date::MIN.saturating_sub(10.days()), Date::MIN);
+
+    // Subtracting with overflow
+    assert_eq!(Date::MAX.saturating_sub((-10).days()), Date::MAX);
+
+    // Subtracting zero duration at boundaries
+    assert_eq!(Date::MIN.saturating_sub(Duration::ZERO), Date::MIN);
+    assert_eq!(Date::MAX.saturating_sub(Duration::ZERO), Date::MAX);
+}
+
+#[test]
+fn replace_year() {
+    assert_eq!(
+        date!(2022 - 02 - 18).replace_year(2019),
+        Ok(date!(2019 - 02 - 18))
+    );
+    assert!(date!(2022 - 02 - 18).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year
+    assert!(date!(2022 - 02 - 18).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid year
+
+    // Common to leap year, before leap day.
+    assert_eq!(
+        date!(2022 - 01 - 01).replace_year(2024),
+        Ok(date!(2024 - 01 - 01))
+    );
+    // Common to leap year, after leap day.
+    assert_eq!(
+        date!(2022 - 12 - 01).replace_year(2024),
+        Ok(date!(2024 - 12 - 01))
+    );
+    // Leap to common year, before leap day.
+    assert_eq!(
+        date!(2024 - 01 - 01).replace_year(2022),
+        Ok(date!(2022 - 01 - 01))
+    );
+    // Leap to common year, after leap day.
+    assert_eq!(
+        date!(2024 - 12 - 01).replace_year(2022),
+        Ok(date!(2022 - 12 - 01))
+    );
+    // Leap to common year, leap day.
+    assert!(date!(2024 - 02 - 29).replace_year(2022).is_err());
+    // Common to common year.
+    assert_eq!(
+        date!(2022 - 12 - 01).replace_year(2023),
+        Ok(date!(2023 - 12 - 01))
+    );
+    // Leap to leap year.
+    assert_eq!(
+        date!(2024 - 12 - 01).replace_year(2028),
+        Ok(date!(2028 - 12 - 01))
+    );
+}
+
+#[test]
+fn replace_month() {
+    assert_eq!(
+        date!(2022 - 02 - 18).replace_month(Month::January),
+        Ok(date!(2022 - 01 - 18))
+    );
+    assert!(
+        date!(2022 - 01 - 30)
+            .replace_month(Month::February)
+            .is_err()
+    ); // 30 isn't a valid day in February
+}
+
+#[test]
+fn replace_day() {
+    assert_eq!(
+        date!(2022 - 02 - 18).replace_day(1),
+        Ok(date!(2022 - 02 - 01))
+    );
+    assert!(date!(2022 - 02 - 18).replace_day(0).is_err()); // 0 isn't a valid day
+    assert!(date!(2022 - 02 - 18).replace_day(30).is_err()); // 30 isn't a valid day in February
+}
+
+#[test]
+fn replace_ordinal() {
+    assert_eq!(
+        date!(2022 - 02 - 18).replace_ordinal(1),
+        Ok(date!(2022 - 001))
+    );
+    assert_eq!(
+        date!(2024 - 02 - 29).replace_ordinal(366),
+        Ok(date!(2024 - 366))
+    );
+    assert!(date!(2022 - 049).replace_ordinal(0).is_err()); // 0 isn't a valid day
+    assert!(date!(2022 - 049).replace_ordinal(366).is_err()); // 2022 isn't a leap year
+    assert!(date!(2022 - 049).replace_ordinal(367).is_err()); // 367 isn't a valid day
+}
+
+#[test]
+fn next_occurrence_test() {
+    assert_eq!(
+        date!(2023 - 06 - 25).next_occurrence(Weekday::Monday),
+        date!(2023 - 06 - 26)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 26).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 03)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 27).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 03)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 28).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 03)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 29).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 03)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 30).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 03)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 01).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 03)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 02).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 03)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 03).next_occurrence(Weekday::Monday),
+        date!(2023 - 07 - 10)
+    );
+}
+
+#[test]
+fn prev_occurrence_test() {
+    assert_eq!(
+        date!(2023 - 07 - 07).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 07 - 06)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 06).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 29)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 05).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 29)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 04).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 29)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 03).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 29)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 02).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 29)
+    );
+    assert_eq!(
+        date!(2023 - 07 - 01).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 29)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 30).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 29)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 29).prev_occurrence(Weekday::Thursday),
+        date!(2023 - 06 - 22)
+    );
+}
+
+#[test]
+fn nth_next_occurrence_test() {
+    assert_eq!(
+        date!(2023 - 06 - 25).nth_next_occurrence(Weekday::Monday, 5),
+        date!(2023 - 07 - 24)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 26).nth_next_occurrence(Weekday::Monday, 5),
+        date!(2023 - 07 - 31)
+    );
+}
+
+#[test]
+fn nth_prev_occurrence_test() {
+    assert_eq!(
+        date!(2023 - 06 - 27).nth_prev_occurrence(Weekday::Monday, 3),
+        date!(2023 - 06 - 12)
+    );
+    assert_eq!(
+        date!(2023 - 06 - 26).nth_prev_occurrence(Weekday::Monday, 3),
+        date!(2023 - 06 - 05)
+    );
+}
+
+#[test]
+#[should_panic]
+fn next_occurrence_overflow_test() {
+    date!(+999999 - 12 - 25).next_occurrence(Weekday::Saturday);
+}
+
+#[test]
+#[should_panic]
+fn prev_occurrence_overflow_test() {
+    date!(-999999 - 01 - 07).prev_occurrence(Weekday::Sunday);
+}
+
+#[test]
+#[should_panic]
+fn nth_next_occurrence_overflow_test() {
+    date!(+999999 - 12 - 25).nth_next_occurrence(Weekday::Saturday, 1);
+}
+
+#[test]
+#[should_panic]
+fn nth_next_occurence_zeroth_occurence_test() {
+    date!(2023 - 06 - 25).nth_next_occurrence(Weekday::Monday, 0);
+}
+
+#[test]
+#[should_panic]
+fn nth_prev_occurence_zeroth_occurence_test() {
+    date!(2023 - 06 - 27).nth_prev_occurrence(Weekday::Monday, 0);
+}
+
+#[test]
+#[should_panic]
+fn nth_prev_occurrence_overflow_test() {
+    date!(-999999 - 01 - 07).nth_prev_occurrence(Weekday::Sunday, 1);
+}
diff --git a/tests/derives.rs b/tests/derives.rs
new file mode 100644
index 000000000..0165c0377
--- /dev/null
+++ b/tests/derives.rs
@@ -0,0 +1,201 @@
+use std::cmp::Ordering;
+use std::collections::hash_map::DefaultHasher;
+use std::hash::Hash;
+
+use time::error::{self, ConversionRange, IndeterminateOffset, TryFromParsed};
+use time::ext::NumericalDuration;
+use time::format_description::{self, modifier, well_known, Component, BorrowedFormatItem, OwnedFormatItem};
+use time::macros::{date, offset, time};
+use time::parsing::Parsed;
+use time::{Duration, Error, Month, Time, Weekday};
+#[allow(deprecated)]
+use time::Instant;
+use time_macros::datetime;
+
+macro_rules! assert_cloned_eq {
+    ($x:expr) => {
+        assert_eq!($x.clone(), $x)
+    };
+}
+
+fn component_range_error() -> error::ComponentRange {
+    Time::from_hms(24, 0, 0).expect_err("24 is not a valid hour")
+}
+
+fn invalid_format_description() -> error::InvalidFormatDescription {
+    format_description::parse("[").expect_err("format description is invalid")
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn clone() {
+    #[allow(deprecated)]
+    let instant = Instant::now();
+    assert_cloned_eq!(date!(2021 - 001));
+    assert_cloned_eq!(time!(0:00));
+    assert_cloned_eq!(offset!(UTC));
+    assert_cloned_eq!(datetime!(2021-001 0:00));
+    assert_cloned_eq!(datetime!(2021-001 0:00 UTC));
+    assert_cloned_eq!(Weekday::Monday);
+    assert_cloned_eq!(Month::January);
+    assert_cloned_eq!(Duration::ZERO);
+    assert_cloned_eq!(instant);
+    assert_cloned_eq!(IndeterminateOffset);
+    assert_cloned_eq!(ConversionRange);
+    assert_cloned_eq!(invalid_format_description());
+    assert_cloned_eq!(TryFromParsed::InsufficientInformation);
+    #[allow(clippy::clone_on_copy)] // needed for coverage
+    let _ = Parsed::new().clone();
+    assert_cloned_eq!(error::Parse::ParseFromDescription(
+        error::ParseFromDescription::InvalidComponent("foo")
+    ));
+    assert_cloned_eq!(error::DifferentVariant);
+    assert_cloned_eq!(error::InvalidVariant);
+    assert_cloned_eq!(error::ParseFromDescription::InvalidComponent("foo"));
+    assert_cloned_eq!(Component::OffsetSecond(modifier::OffsetSecond::default()));
+    assert_cloned_eq!(well_known::Rfc2822);
+    assert_cloned_eq!(well_known::Rfc3339);
+    assert_cloned_eq!(well_known::Iso8601::DEFAULT);
+    assert_cloned_eq!(well_known::iso8601::FormattedComponents::None);
+    assert_cloned_eq!(well_known::iso8601::DateKind::Calendar);
+    assert_cloned_eq!(well_known::iso8601::TimePrecision::Hour {
+        decimal_digits: None
+    });
+    assert_cloned_eq!(well_known::iso8601::OffsetPrecision::Hour);
+    assert_cloned_eq!(well_known::iso8601::FormattedComponents::None);
+    assert_cloned_eq!(component_range_error());
+    assert_cloned_eq!(BorrowedFormatItem::Literal(b""));
+    assert_cloned_eq!(time::util::local_offset::Soundness::Sound);
+
+    assert_cloned_eq!(modifier::Day::default());
+    assert_cloned_eq!(modifier::MonthRepr::default());
+    assert_cloned_eq!(modifier::Month::default());
+    assert_cloned_eq!(modifier::Ordinal::default());
+    assert_cloned_eq!(modifier::WeekdayRepr::default());
+    assert_cloned_eq!(modifier::Weekday::default());
+    assert_cloned_eq!(modifier::WeekNumberRepr::default());
+    assert_cloned_eq!(modifier::WeekNumber::default());
+    assert_cloned_eq!(modifier::YearRepr::default());
+    assert_cloned_eq!(modifier::Year::default());
+    assert_cloned_eq!(modifier::Hour::default());
+    assert_cloned_eq!(modifier::Minute::default());
+    assert_cloned_eq!(modifier::Period::default());
+    assert_cloned_eq!(modifier::Second::default());
+    assert_cloned_eq!(modifier::SubsecondDigits::default());
+    assert_cloned_eq!(modifier::Subsecond::default());
+    assert_cloned_eq!(modifier::OffsetHour::default());
+    assert_cloned_eq!(modifier::OffsetMinute::default());
+    assert_cloned_eq!(modifier::OffsetSecond::default());
+    assert_cloned_eq!(modifier::Padding::default());
+}
+
+#[test]
+fn hash() {
+    let mut hasher = DefaultHasher::new();
+    date!(2021 - 001).hash(&mut hasher);
+    time!(0:00).hash(&mut hasher);
+    offset!(UTC).hash(&mut hasher);
+    datetime!(2021-001 0:00).hash(&mut hasher);
+    datetime!(2021-001 0:00 UTC).hash(&mut hasher);
+    Weekday::Monday.hash(&mut hasher);
+    Month::January.hash(&mut hasher);
+    #[allow(deprecated)]
+    Instant::now().hash(&mut hasher);
+    Duration::ZERO.hash(&mut hasher);
+    component_range_error().hash(&mut hasher);
+}
+
+#[test]
+fn partial_ord() {
+    #[allow(deprecated)]
+    let instant = Instant::now();
+    assert_eq!(offset!(UTC).partial_cmp(&offset!(+1)), Some(Ordering::Less));
+    assert_eq!(
+        offset!(+1).partial_cmp(&offset!(UTC)),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(
+        (instant - 1.seconds()).partial_cmp(&instant),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        (instant + 1.seconds()).partial_cmp(&instant),
+        Some(Ordering::Greater)
+    );
+}
+
+#[test]
+fn ord() {
+    assert_eq!(offset!(UTC).cmp(&offset!(+1)), Ordering::Less);
+    assert_eq!(offset!(+1).cmp(&offset!(UTC)), Ordering::Greater);
+    assert_eq!(offset!(UTC).cmp(&offset!(UTC)), Ordering::Equal);
+}
+
+#[test]
+fn debug() {
+    macro_rules! debug_all {
+        () => {};
+        (#[$meta:meta] $x:expr; $($rest:tt)*) => {
+            #[$meta]
+            let _unused = format!("{:?}", $x);
+            debug_all!($($rest)*);
+        };
+        ($x:expr; $($rest:tt)*) => {
+            let _unused = format!("{:?}", $x);
+            debug_all!($($rest)*);
+        };
+    }
+
+    debug_all! {
+        Duration::ZERO;
+        IndeterminateOffset;
+        ConversionRange;
+        TryFromParsed::InsufficientInformation;
+        Parsed::new();
+        #[allow(deprecated)]
+        Instant::now();
+        error::ParseFromDescription::InvalidComponent("foo");
+        error::Format::InvalidComponent("foo");
+        well_known::Rfc2822;
+        well_known::Rfc3339;
+        well_known::Iso8601::DEFAULT;
+        well_known::iso8601::FormattedComponents::None;
+        well_known::iso8601::DateKind::Calendar;
+        well_known::iso8601::TimePrecision::Hour { decimal_digits: None };
+        well_known::iso8601::OffsetPrecision::Hour;
+        well_known::iso8601::Config::DEFAULT;
+        component_range_error();
+        Error::ConversionRange(ConversionRange);
+        time::util::local_offset::Soundness::Sound;
+
+        modifier::Day::default();
+        modifier::MonthRepr::default();
+        modifier::Month::default();
+        modifier::Ordinal::default();
+        modifier::WeekdayRepr::default();
+        modifier::Weekday::default();
+        modifier::WeekNumberRepr::default();
+        modifier::WeekNumber::default();
+        modifier::YearRepr::default();
+        modifier::Year::default();
+        modifier::Hour::default();
+        modifier::Minute::default();
+        modifier::Period::default();
+        modifier::Second::default();
+        modifier::SubsecondDigits::default();
+        modifier::Subsecond::default();
+        modifier::OffsetHour::default();
+        modifier::OffsetMinute::default();
+        modifier::OffsetSecond::default();
+        modifier::Padding::default();
+
+        BorrowedFormatItem::Literal(b"abcdef");
+        BorrowedFormatItem::Compound(&[BorrowedFormatItem::Component(Component::Day(modifier::Day::default()))]);
+        BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(&[]));
+        BorrowedFormatItem::First(&[]);
+        OwnedFormatItem::from(BorrowedFormatItem::Literal(b"abcdef"));
+        OwnedFormatItem::from(BorrowedFormatItem::Compound(&[BorrowedFormatItem::Component(Component::Day(modifier::Day::default()))]));
+        OwnedFormatItem::from(BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(&[])));
+        OwnedFormatItem::from(BorrowedFormatItem::First(&[]));
+    }
+}
diff --git a/tests/duration.rs b/tests/duration.rs
new file mode 100644
index 000000000..e1f46e25f
--- /dev/null
+++ b/tests/duration.rs
@@ -0,0 +1,1050 @@
+use std::cmp::Ordering;
+use std::cmp::Ordering::{Equal, Greater, Less};
+use std::time::Duration as StdDuration;
+
+use rstest::rstest;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::{error, Duration};
+
+#[rstest]
+#[case(Duration::ZERO, 0.seconds())]
+#[case(Duration::NANOSECOND, 1.nanoseconds())]
+#[case(Duration::MICROSECOND, 1.microseconds())]
+#[case(Duration::MILLISECOND, 1.milliseconds())]
+#[case(Duration::SECOND, 1.seconds())]
+#[case(Duration::MINUTE, 60.seconds())]
+#[case(Duration::HOUR, 3_600.seconds())]
+#[case(Duration::DAY, 86_400.seconds())]
+#[case(Duration::WEEK, 604_800.seconds())]
+fn unit_values(#[case] input: Duration, #[case] expected: Duration) {
+    assert_eq!(input, expected);
+}
+
+#[rstest]
+fn default() {
+    assert_eq!(Duration::default(), Duration::ZERO);
+}
+
+#[rstest]
+#[case((-1).seconds(), false)]
+#[case(0.seconds(), true)]
+#[case(1.seconds(), false)]
+fn is_zero(#[case] input: Duration, #[case] expected: bool) {
+    assert_eq!(input.is_zero(), expected);
+}
+
+#[rstest]
+#[case((-1).seconds(), true)]
+#[case(0.seconds(), false)]
+#[case(1.seconds(), false)]
+fn is_negative(#[case] input: Duration, #[case] expected: bool) {
+    assert_eq!(input.is_negative(), expected);
+}
+
+#[rstest]
+#[case((-1).seconds(), false)]
+#[case(0.seconds(), false)]
+#[case(1.seconds(), true)]
+fn is_positive(#[case] input: Duration, #[case] expected: bool) {
+    assert_eq!(input.is_positive(), expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.seconds())]
+#[case(0.seconds(), 0.seconds())]
+#[case((-1).seconds(), 1.seconds())]
+#[case(Duration::new(i64::MIN, 0), Duration::MAX)]
+fn abs(#[case] input: Duration, #[case] expected: Duration) {
+    assert_eq!(input.abs(), expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.std_seconds())]
+#[case(0.seconds(), 0.std_seconds())]
+#[case((-1).seconds(), 1.std_seconds())]
+fn unsigned_abs(#[case] input: Duration, #[case] expected: StdDuration) {
+    assert_eq!(input.unsigned_abs(), expected);
+}
+
+#[rstest]
+#[case(1, 0, 1.seconds())]
+#[case(-1, 0, (-1).seconds())]
+#[case(1, 2_000_000_000, 3.seconds())]
+#[case(0, 0, 0.seconds())]
+#[case(0, 1_000_000_000, 1.seconds())]
+#[case(-1, 1_000_000_000, 0.seconds())]
+#[case(-2, 1_000_000_000, (-1).seconds())]
+#[case(1, -1, 999_999_999.nanoseconds())]
+#[case(-1, 1, (-999_999_999).nanoseconds())]
+#[case(1, 1, 1_000_000_001.nanoseconds())]
+#[case(-1, -1, (-1_000_000_001).nanoseconds())]
+#[case(0, 1, 1.nanoseconds())]
+#[case(0, -1, (-1).nanoseconds())]
+#[case(-1, 1_400_000_000, 400.milliseconds())]
+#[case(-2, 1_400_000_000, (-600).milliseconds())]
+#[case(-3, 1_400_000_000, (-1_600).milliseconds())]
+#[case(1, -1_400_000_000, (-400).milliseconds())]
+#[case(2, -1_400_000_000, 600.milliseconds())]
+#[case(3, -1_400_000_000, 1_600.milliseconds())]
+fn new(#[case] secs: i64, #[case] nanos: i32, #[case] expected: Duration) {
+    assert_eq!(Duration::new(secs, nanos), expected);
+}
+
+#[rstest]
+#[case(i64::MAX, 1_000_000_000)]
+#[case(i64::MIN, -1_000_000_000)]
+#[should_panic]
+fn new_panic(#[case] secs: i64, #[case] nanos: i32) {
+    let _ = Duration::new(secs, nanos);
+}
+
+#[rstest]
+#[case(1, 604_800)]
+#[case(2, 2 * 604_800)]
+#[case(-1, -604_800)]
+#[case(-2, -2 * 604_800)]
+fn weeks(#[case] weeks_: i64, #[case] expected: i64) {
+    assert_eq!(Duration::weeks(weeks_), expected.seconds());
+}
+
+#[rstest]
+#[case(i64::MAX)]
+#[case(i64::MIN)]
+#[should_panic]
+fn weeks_panic(#[case] weeks: i64) {
+    let _ = Duration::weeks(weeks);
+}
+
+#[rstest]
+#[case(7, 1)]
+#[case(-7, -1)]
+#[case(6, 0)]
+#[case(-6, 0)]
+fn whole_weeks(#[case] days: i64, #[case] expected: i64) {
+    assert_eq!(Duration::days(days).whole_weeks(), expected);
+}
+
+#[rstest]
+#[case(1, 86_400)]
+#[case(2, 2 * 86_400)]
+#[case(-1, -86_400)]
+#[case(-2, -2 * 86_400)]
+fn days(#[case] days_: i64, #[case] expected: i64) {
+    assert_eq!(Duration::days(days_), expected.seconds());
+}
+
+#[rstest]
+#[case(i64::MAX)]
+#[case(i64::MIN)]
+#[should_panic]
+fn days_panic(#[case] days: i64) {
+    let _ = Duration::days(days);
+}
+
+#[rstest]
+#[case(24, 1)]
+#[case(-24, -1)]
+#[case(23, 0)]
+#[case(-23, 0)]
+fn whole_days(#[case] hours: i64, #[case] expected: i64) {
+    assert_eq!(Duration::hours(hours).whole_days(), expected);
+}
+
+#[rstest]
+#[case(1, 3_600)]
+#[case(2, 2 * 3_600)]
+#[case(-1, -3_600)]
+#[case(-2, -2 * 3_600)]
+fn hours(#[case] hours_: i64, #[case] expected: i64) {
+    assert_eq!(Duration::hours(hours_), expected.seconds());
+}
+
+#[rstest]
+#[case(i64::MAX)]
+#[case(i64::MIN)]
+#[should_panic]
+fn hours_panic(#[case] hours: i64) {
+    let _ = Duration::hours(hours);
+}
+
+#[rstest]
+#[case(60, 1)]
+#[case(-60, -1)]
+#[case(59, 0)]
+#[case(-59, 0)]
+fn whole_hours(#[case] minutes: i64, #[case] expected: i64) {
+    assert_eq!(Duration::minutes(minutes).whole_hours(), expected);
+}
+
+#[rstest]
+#[case(1, 60)]
+#[case(2, 2 * 60)]
+#[case(-1, -60)]
+#[case(-2, -2 * 60)]
+fn minutes(#[case] minutes_: i64, #[case] expected: i64) {
+    assert_eq!(Duration::minutes(minutes_), expected.seconds());
+}
+
+#[rstest]
+#[case(i64::MAX)]
+#[case(i64::MIN)]
+#[should_panic]
+fn minutes_panic(#[case] minutes: i64) {
+    let _ = Duration::minutes(minutes);
+}
+
+#[rstest]
+#[case(60, 1)]
+#[case(-60, -1)]
+#[case(59, 0)]
+#[case(-59, 0)]
+fn whole_minutes(#[case] seconds: i64, #[case] expected: i64) {
+    assert_eq!(Duration::seconds(seconds).whole_minutes(), expected);
+}
+
+#[rstest]
+#[case(1, 1_000)]
+#[case(2, 2 * 1_000)]
+#[case(-1, -1_000)]
+#[case(-2, -2 * 1_000)]
+fn seconds(#[case] seconds_: i64, #[case] expected: i64) {
+    assert_eq!(Duration::seconds(seconds_), expected.milliseconds());
+}
+
+#[rstest]
+#[case(1)]
+#[case(-1)]
+#[case(60)]
+#[case(-60)]
+fn whole_seconds(#[case] seconds: i64) {
+    assert_eq!(Duration::seconds(seconds).whole_seconds(), seconds);
+}
+
+#[rstest]
+#[case(0.5, Duration::milliseconds(500))]
+#[case(-0.5, Duration::milliseconds(-500))]
+#[case(123.250, Duration::milliseconds(123_250))]
+#[case(0.000_000_000_012, Duration::ZERO)]
+fn seconds_f64(#[case] seconds: f64, #[case] expected: Duration) {
+    assert_eq!(Duration::seconds_f64(seconds), expected);
+}
+
+#[rstest]
+#[case(f64::MAX)]
+#[case(f64::MIN)]
+#[case(f64::NAN)]
+#[should_panic]
+fn seconds_f64_panic(#[case] seconds: f64) {
+    let _ = Duration::seconds_f64(seconds);
+}
+
+#[rstest]
+#[case(0.5, Duration::milliseconds(500))]
+#[case(-0.5, Duration::milliseconds(-500))]
+#[case(123.250, Duration::milliseconds(123_250))]
+#[case(0.000_000_000_012, Duration::ZERO)]
+#[case(f64::MAX, Duration::MAX)]
+#[case(f64::MIN, Duration::MIN)]
+#[case(f64::NAN, Duration::ZERO)]
+fn saturating_seconds_f64(#[case] seconds: f64, #[case] expected: Duration) {
+    assert_eq!(Duration::saturating_seconds_f64(seconds), expected);
+}
+
+#[rstest]
+#[case(0.5, 0.5)]
+#[case(-0.5, -0.5)]
+#[case(123.250, 123.250)]
+#[case(0.000_000_000_012, 0.)]
+fn checked_seconds_f64_success(#[case] seconds: f64, #[case] expected: f64) {
+    assert_eq!(
+        Duration::checked_seconds_f64(seconds),
+        Some(expected.seconds())
+    );
+}
+
+#[rstest]
+#[case(f64::MAX)]
+#[case(f64::MIN)]
+#[case(f64::NAN)]
+fn checked_seconds_f64_edge_cases(#[case] seconds: f64) {
+    assert_eq!(Duration::checked_seconds_f64(seconds), None);
+}
+
+#[rstest]
+#[case(1.)]
+#[case(-1.)]
+#[case(60.)]
+#[case(-60.)]
+#[case(1.5)]
+#[case(-1.5)]
+fn as_seconds_f64(#[case] seconds: f64) {
+    assert_eq!(Duration::seconds_f64(seconds).as_seconds_f64(), seconds);
+}
+
+#[rstest]
+#[case(0.5, Duration::milliseconds(500))]
+#[case(-0.5, Duration::milliseconds(-500))]
+#[case(123.250, Duration::milliseconds(123_250))]
+#[case(0.000_000_000_012, Duration::ZERO)]
+fn seconds_f32_success(#[case] seconds: f32, #[case] expected: Duration) {
+    assert_eq!(Duration::seconds_f32(seconds), expected);
+}
+
+#[rstest]
+#[case(f32::MAX)]
+#[case(f32::MIN)]
+#[case(f32::NAN)]
+#[should_panic]
+fn seconds_f32_panic(#[case] seconds: f32) {
+    let _ = Duration::seconds_f32(seconds);
+}
+
+#[rstest]
+#[case(0.5, Duration::milliseconds(500))]
+#[case(-0.5, Duration::milliseconds(-500))]
+#[case(123.250, Duration::milliseconds(123_250))]
+#[case(0.000_000_000_012, Duration::ZERO)]
+#[case(f32::MAX, Duration::MAX)]
+#[case(f32::MIN, Duration::MIN)]
+#[case(f32::NAN, Duration::ZERO)]
+fn saturating_seconds_f32(#[case] seconds: f32, #[case] expected: Duration) {
+    assert_eq!(Duration::saturating_seconds_f32(seconds), expected);
+}
+
+#[rstest]
+#[case(0.5, 0.5)]
+#[case(-0.5, -0.5)]
+#[case(123.250, 123.250)]
+#[case(0.000_000_000_012, 0.0)]
+fn checked_seconds_f32_success(#[case] seconds: f32, #[case] expected: f64) {
+    assert_eq!(
+        Duration::checked_seconds_f32(seconds),
+        Some(expected.seconds())
+    );
+}
+
+#[rstest]
+#[case(f32::MAX)]
+#[case(f32::MIN)]
+#[case(f32::NAN)]
+fn checked_seconds_f32_none(#[case] seconds: f32) {
+    assert_eq!(Duration::checked_seconds_f32(seconds), None);
+}
+
+#[rstest]
+#[case(1.0, 1.0)]
+#[case(-1.0, -1.0)]
+#[case(60.0, 60.0)]
+#[case(-60.0, -60.0)]
+#[case(1.5, 1.5)]
+#[case(-1.5, -1.5)]
+fn as_seconds_f32(#[case] seconds: f32, #[case] expected: f32) {
+    assert_eq!(Duration::seconds_f32(seconds).as_seconds_f32(), expected);
+}
+
+#[rstest]
+#[case(1, 1_000)]
+#[case(-1, -1_000)]
+fn milliseconds(#[case] input: i64, #[case] expected: i64) {
+    assert_eq!(Duration::milliseconds(input), expected.microseconds());
+}
+
+#[rstest]
+#[case(1.seconds(), 1_000)]
+#[case((-1).seconds(), -1_000)]
+#[case(1.milliseconds(), 1)]
+#[case((-1).milliseconds(), -1)]
+fn whole_milliseconds(#[case] input: Duration, #[case] expected: i128) {
+    assert_eq!(input.whole_milliseconds(), expected);
+}
+
+#[rstest]
+#[case(1.4.seconds(), 400)]
+#[case((-1.4).seconds(), -400)]
+fn subsec_milliseconds(#[case] duration: Duration, #[case] expected: i16) {
+    assert_eq!(duration.subsec_milliseconds(), expected);
+}
+
+#[rstest]
+#[case(1, 1_000)]
+#[case(-1, -1_000)]
+fn microseconds(#[case] input: i64, #[case] expected: i64) {
+    assert_eq!(Duration::microseconds(input), expected.nanoseconds());
+}
+
+#[rstest]
+#[case(1.milliseconds(), 1_000)]
+#[case((-1).milliseconds(), -1_000)]
+#[case(1.microseconds(), 1)]
+#[case((-1).microseconds(), -1)]
+fn whole_microseconds(#[case] input: Duration, #[case] expected: i128) {
+    assert_eq!(input.whole_microseconds(), expected);
+}
+
+#[rstest]
+#[case(1.0004.seconds(), 400)]
+#[case((-1.0004).seconds(), -400)]
+fn subsec_microseconds(#[case] duration: Duration, #[case] expected: i32) {
+    assert_eq!(duration.subsec_microseconds(), expected);
+}
+
+#[rstest]
+#[case(1, 1.microseconds() / 1_000)]
+#[case(-1, (-1).microseconds() / 1_000)]
+fn nanoseconds(#[case] input: i64, #[case] expected: Duration) {
+    assert_eq!(Duration::nanoseconds(input), expected);
+}
+
+#[rstest]
+#[case(1.microseconds(), 1_000)]
+#[case((-1).microseconds(), -1_000)]
+#[case(1.nanoseconds(), 1)]
+#[case((-1).nanoseconds(), -1)]
+fn whole_nanoseconds(#[case] input: Duration, #[case] expected: i128) {
+    assert_eq!(input.whole_nanoseconds(), expected);
+}
+
+#[rstest]
+#[case(1.000_000_4.seconds(), 400)]
+#[case((-1.000_000_4).seconds(), -400)]
+fn subsec_nanoseconds(#[case] duration: Duration, #[case] expected: i32) {
+    assert_eq!(duration.subsec_nanoseconds(), expected);
+}
+
+#[rstest]
+#[case(5.seconds(), 5.seconds(), 10.seconds())]
+#[case((-5).seconds(), 5.seconds(), 0.seconds())]
+#[case(1.seconds(), (-1).milliseconds(), 999.milliseconds())]
+fn checked_add_some(#[case] a: Duration, #[case] b: Duration, #[case] expected: Duration) {
+    assert_eq!(a.checked_add(b), Some(expected));
+}
+
+#[rstest]
+#[case(Duration::MAX, 1.nanoseconds())]
+#[case(5.seconds(), Duration::MAX)]
+#[case(Duration::MIN, Duration::MIN)]
+fn checked_add_none(#[case] a: Duration, #[case] b: Duration) {
+    assert_eq!(a.checked_add(b), None);
+}
+
+#[rstest]
+#[case(5.seconds(), 5.seconds(), 0.seconds())]
+#[case(5.seconds(), 10.seconds(), (-5).seconds())]
+fn checked_sub_some(#[case] a: Duration, #[case] b: Duration, #[case] expected: Duration) {
+    assert_eq!(a.checked_sub(b), Some(expected));
+}
+
+#[rstest]
+#[case(Duration::MIN, 1.nanoseconds())]
+#[case(5.seconds(), Duration::MIN)]
+#[case(Duration::MAX, Duration::MIN)]
+fn checked_sub_none(#[case] a: Duration, #[case] b: Duration) {
+    assert_eq!(a.checked_sub(b), None);
+}
+
+#[rstest]
+#[case(5.seconds(), 2, 10.seconds())]
+#[case(5.seconds(), -2, (-10).seconds())]
+#[case(5.seconds(), 0, Duration::ZERO)]
+fn checked_mul_some(#[case] duration: Duration, #[case] rhs: i32, #[case] expected: Duration) {
+    assert_eq!(duration.checked_mul(rhs), Some(expected));
+}
+
+#[rstest]
+#[case(Duration::MIN, -1)]
+#[case(Duration::MAX, 2)]
+#[case(Duration::MIN, 2)]
+fn checked_mul_none(#[case] duration: Duration, #[case] rhs: i32) {
+    assert_eq!(duration.checked_mul(rhs), None);
+}
+
+#[rstest]
+#[case(10.seconds(), 2, 5.seconds())]
+#[case(10.seconds(), -2, (-5).seconds())]
+fn checked_div_some(#[case] duration: Duration, #[case] rhs: i32, #[case] expected: Duration) {
+    assert_eq!(duration.checked_div(rhs), Some(expected));
+}
+
+#[rstest]
+#[case(1.seconds(), 0)]
+#[case(Duration::MIN, -1)]
+fn checked_div_none(#[case] duration: Duration, #[case] rhs: i32) {
+    assert_eq!(duration.checked_div(rhs), None);
+}
+
+#[rstest]
+fn checked_div_regression() {
+    assert_eq!(
+        Duration::new(1, 1).checked_div(7),
+        Some(Duration::new(0, 142_857_143)) // manually verified
+    );
+}
+
+#[rstest]
+#[case(5.seconds(), Some((-5).seconds()))]
+#[case((-5).seconds(), Some(5.seconds()))]
+#[case(Duration::MIN, None)]
+fn checked_neg(#[case] duration: Duration, #[case] expected: Option<Duration>) {
+    assert_eq!(duration.checked_neg(), expected);
+}
+
+#[rstest]
+#[case(5.seconds(), 5.seconds(), 10.seconds())]
+#[case(Duration::MAX, 1.nanoseconds(), Duration::MAX)]
+#[case(Duration::MAX, 1.seconds(), Duration::MAX)]
+#[case(Duration::MIN, (-1).nanoseconds(), Duration::MIN)]
+#[case(Duration::MIN, (-1).seconds(), Duration::MIN)]
+#[case((-5).seconds(), 5.seconds(), Duration::ZERO)]
+#[case(1_600.milliseconds(), 1_600.milliseconds(), 3_200.milliseconds())]
+#[case(1.seconds(), (-1).milliseconds(), 999.milliseconds())]
+fn saturating_add(#[case] a: Duration, #[case] b: Duration, #[case] expected: Duration) {
+    assert_eq!(a.saturating_add(b), expected);
+}
+
+#[rstest]
+#[case(5.seconds(), 5.seconds(), Duration::ZERO)]
+#[case(Duration::MIN, 1.nanoseconds(), Duration::MIN)]
+#[case(Duration::MAX, (-1).nanoseconds(), Duration::MAX)]
+#[case(Duration::MAX, (-1).seconds(), Duration::MAX)]
+#[case(5.seconds(), 10.seconds(), (-5).seconds())]
+#[case((-1_600).milliseconds(), 1_600.milliseconds(), (-3_200).milliseconds())]
+#[case(0.seconds(), Duration::MIN, Duration::MIN)]
+#[case(Duration::MIN, 5.seconds(), Duration::MIN)]
+#[case(1_200.milliseconds(), 600.milliseconds(), 600.milliseconds())]
+#[case((-1_200).milliseconds(), (-600).milliseconds(), (-600).milliseconds())]
+fn saturating_sub(#[case] a: Duration, #[case] b: Duration, #[case] expected: Duration) {
+    assert_eq!(a.saturating_sub(b), expected);
+}
+
+#[rstest]
+#[case(5.seconds(), 2, 10.seconds())]
+#[case(5.seconds(), -2, (-10).seconds())]
+#[case(5.seconds(), 0, Duration::ZERO)]
+#[case(Duration::MAX, 2, Duration::MAX)]
+#[case(Duration::MIN, 2, Duration::MIN)]
+#[case(Duration::MAX, -2, Duration::MIN)]
+#[case(Duration::MIN, -2, Duration::MAX)]
+#[case(
+    Duration::new(1_844_674_407_370_955_161, 600_000_000),
+    5,
+    Duration::MAX
+)]
+#[case(Duration::new(1_844_674_407_370_955_161, 800_000_000), -5, Duration::MIN)]
+fn saturating_mul(#[case] duration: Duration, #[case] rhs: i32, #[case] expected: Duration) {
+    assert_eq!(duration.saturating_mul(rhs), expected);
+}
+
+#[rstest]
+#[timeout(StdDuration::from_millis(100))]
+fn time_fn() {
+    #[allow(deprecated)]
+    let (time, value) = Duration::time_fn(|| {
+        std::thread::sleep(1.std_milliseconds());
+        0
+    });
+
+    assert!(time >= 1.milliseconds());
+    assert_eq!(value, 0);
+}
+
+#[rstest]
+#[case(0.seconds(), "0s")]
+#[case(60.days(), "60d")]
+#[case((-48).hours(), "-2d")]
+#[case(48.hours(), "2d")]
+#[case(1.minutes(), "1m")]
+#[case(10.minutes(), "10m")]
+#[case(1.seconds(), "1s")]
+#[case(10.seconds(), "10s")]
+#[case(1.milliseconds(), "1ms")]
+#[case(10.milliseconds(), "10ms")]
+#[case(100.milliseconds(), "100ms")]
+#[case(1.microseconds(), "1µs")]
+#[case(10.microseconds(), "10µs")]
+#[case(100.microseconds(), "100µs")]
+#[case(1.nanoseconds(), "1ns")]
+#[case(10.nanoseconds(), "10ns")]
+#[case(100.nanoseconds(), "100ns")]
+fn display_basic(#[case] duration: Duration, #[case] expected: &str) {
+    assert_eq!(duration.to_string(), expected);
+}
+
+#[rstest]
+#[case(1.days(), "1d")]
+#[case(26.hours(), "1d2h")]
+#[case(1_563.minutes(), "1d2h3m")]
+#[case(93_784.seconds(), "1d2h3m4s")]
+#[case(93_784_005.milliseconds(), "1d2h3m4s5ms")]
+#[case(93_784_005_006.microseconds(), "1d2h3m4s5ms6µs")]
+#[case(93_784_005_006_007.nanoseconds(), "1d2h3m4s5ms6µs7ns")]
+fn display_compound(#[case] duration: Duration, #[case] expected: &str) {
+    assert_eq!(duration.to_string(), expected);
+}
+
+#[rstest]
+#[case(0.seconds(), 3, "0.000s")]
+#[case(60.days(), 3, "60.000d")]
+#[case((-48).hours(), 3, "-2.000d")]
+#[case(48.hours(), 3, "2.000d")]
+#[case(1.minutes(), 3, "1.000m")]
+#[case(10.minutes(), 3, "10.000m")]
+#[case(1.seconds(), 3, "1.000s")]
+#[case(10.seconds(), 3, "10.000s")]
+#[case(1.milliseconds(), 3, "1.000ms")]
+#[case(10.milliseconds(), 3, "10.000ms")]
+#[case(100.milliseconds(), 3, "100.000ms")]
+#[case(1.microseconds(), 3, "1.000µs")]
+#[case(10.microseconds(), 3, "10.000µs")]
+#[case(100.microseconds(), 3, "100.000µs")]
+#[case(1.nanoseconds(), 3, "1.000ns")]
+#[case(10.nanoseconds(), 3, "10.000ns")]
+#[case(100.nanoseconds(), 3, "100.000ns")]
+#[case(1.days(), 3, "1.000d")]
+#[case(26.hours(), 3, "1.083d")]
+#[case(1_563.minutes(), 4, "1.0854d")]
+#[case(93_784.seconds(), 5, "1.08546d")]
+#[case(93_784_005.milliseconds(), 6, "1.085463d")]
+#[case(93_784_005_006.microseconds(), 9, "1.085463021d")]
+#[case(93_784_005_006_007.nanoseconds(), 12, "1.085463020903d")]
+fn display_precision(#[case] duration: Duration, #[case] precision: usize, #[case] expected: &str) {
+    assert_eq!(format!("{duration:.precision$}"), expected);
+}
+
+#[rstest]
+#[case(0.std_seconds(), 0.seconds())]
+#[case(1.std_seconds(), 1.seconds())]
+fn try_from_std_duration_success(#[case] std_duration: StdDuration, #[case] expected: Duration) {
+    assert_eq!(Duration::try_from(std_duration), Ok(expected));
+}
+
+#[rstest]
+#[case(u64::MAX.std_seconds(), error::ConversionRange)]
+fn try_from_std_duration_error(
+    #[case] std_duration: StdDuration,
+    #[case] expected: error::ConversionRange,
+) {
+    assert_eq!(Duration::try_from(std_duration), Err(expected));
+}
+
+#[rstest]
+#[case(0.seconds(), 0.std_seconds())]
+#[case(1.seconds(), 1.std_seconds())]
+fn try_to_std_duration_success(#[case] duration: Duration, #[case] expected: StdDuration) {
+    assert_eq!(StdDuration::try_from(duration), Ok(expected));
+}
+
+#[rstest]
+#[case((-1).seconds())]
+#[case((-500).milliseconds())]
+fn try_to_std_duration_error(#[case] duration: Duration) {
+    assert_eq!(StdDuration::try_from(duration), Err(error::ConversionRange));
+}
+
+#[rstest]
+#[case(1.seconds(), 1.seconds(), 2.seconds())]
+#[case(500.milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.seconds(), (-1).seconds(), 0.seconds())]
+fn add(#[case] lhs: Duration, #[case] rhs: Duration, #[case] expected: Duration) {
+    assert_eq!(lhs + rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.std_seconds(), 2.seconds())]
+#[case(500.milliseconds(), 500.std_milliseconds(), 1.seconds())]
+#[case((-1).seconds(), 1.std_seconds(), 0.seconds())]
+fn add_std(#[case] lhs: Duration, #[case] rhs: StdDuration, #[case] expected: Duration) {
+    assert_eq!(lhs + rhs, expected);
+}
+
+#[rstest]
+#[case(1.std_seconds(), 1.seconds(), 2.seconds())]
+#[case(500.std_milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.std_seconds(), (-1).seconds(), 0.seconds())]
+fn std_add(#[case] lhs: StdDuration, #[case] rhs: Duration, #[case] expected: Duration) {
+    assert_eq!(lhs + rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.seconds(), 2.seconds())]
+#[case(500.milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.seconds(), (-1).seconds(), 0.seconds())]
+fn add_assign(#[case] mut duration: Duration, #[case] other: Duration, #[case] expected: Duration) {
+    duration += other;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.std_seconds(), 2.seconds())]
+#[case(500.milliseconds(), 500.std_milliseconds(), 1.seconds())]
+#[case((-1).seconds(), 1.std_seconds(), 0.seconds())]
+fn add_assign_std(
+    #[case] mut duration: Duration,
+    #[case] other: StdDuration,
+    #[case] expected: Duration,
+) {
+    duration += other;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.std_seconds(), 1.seconds(), 2.seconds())]
+#[case(500.std_milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.std_seconds(), (-1).seconds(), 0.seconds())]
+fn std_add_assign(
+    #[case] mut duration: StdDuration,
+    #[case] other: Duration,
+    #[case] expected: Duration,
+) {
+    duration += other;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), (-1).seconds())]
+#[case((-1).seconds(), 1.seconds())]
+#[case(0.seconds(), 0.seconds())]
+fn neg(#[case] duration: Duration, #[case] expected: Duration) {
+    assert_eq!(-duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.seconds(), 0.seconds())]
+#[case(1_500.milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.seconds(), (-1).seconds(), 2.seconds())]
+fn sub(#[case] lhs: Duration, #[case] rhs: Duration, #[case] expected: Duration) {
+    assert_eq!(lhs - rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.std_seconds(), 0.seconds())]
+#[case(1_500.milliseconds(), 500.std_milliseconds(), 1.seconds())]
+#[case((-1).seconds(), 1.std_seconds(), -(2.seconds()))]
+fn sub_std(#[case] lhs: Duration, #[case] rhs: StdDuration, #[case] expected: Duration) {
+    assert_eq!(lhs - rhs, expected);
+}
+
+#[rstest]
+#[case(1.std_seconds(), 1.seconds(), 0.seconds())]
+#[case(1_500.std_milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.std_seconds(), (-1).seconds(), 2.seconds())]
+fn std_sub(#[case] lhs: StdDuration, #[case] rhs: Duration, #[case] expected: Duration) {
+    assert_eq!(lhs - rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.seconds(), 0.seconds())]
+#[case(1_500.milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.seconds(), (-1).seconds(), 2.seconds())]
+fn sub_assign(#[case] mut duration: Duration, #[case] other: Duration, #[case] expected: Duration) {
+    duration -= other;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.std_seconds(), 0.seconds())]
+#[case(1_500.milliseconds(), 500.std_milliseconds(), 1.seconds())]
+#[case((-1).seconds(), 1.std_seconds(), -(2.seconds()))]
+fn sub_assign_std(
+    #[case] mut duration: Duration,
+    #[case] other: StdDuration,
+    #[case] expected: Duration,
+) {
+    duration -= other;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.std_seconds(), 1.seconds(), 0.seconds())]
+#[case(1_500.std_milliseconds(), 500.milliseconds(), 1.seconds())]
+#[case(1.std_seconds(), (-1).seconds(), 2.seconds())]
+fn std_sub_assign(
+    #[case] mut duration: StdDuration,
+    #[case] other: Duration,
+    #[case] expected: Duration,
+) {
+    duration -= other;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[should_panic]
+fn std_sub_assign_overflow() {
+    let mut duration = 1.std_seconds();
+    duration -= 2.seconds();
+}
+
+#[rstest]
+#[case(1.seconds(), 2, 2.seconds())]
+#[case(1.seconds(), -2, (-2).seconds())]
+fn mul_int_success(#[case] duration: Duration, #[case] rhs: i32, #[case] expected: Duration) {
+    assert_eq!(duration * rhs, expected);
+}
+
+#[rstest]
+#[case(Duration::MAX, 2)]
+#[case(Duration::MIN, 2)]
+#[should_panic]
+fn mul_int_panic(#[case] duration: Duration, #[case] rhs: i32) {
+    let _ = duration * rhs;
+}
+
+#[rstest]
+#[case(1.seconds(), 2, 2.seconds())]
+#[case(1.seconds(), -2, (-2).seconds())]
+fn mul_int_assign(#[case] mut duration: Duration, #[case] rhs: i32, #[case] expected: Duration) {
+    duration *= rhs;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(2, 1.seconds(), 2.seconds())]
+#[case(-2, 1.seconds(), (-2).seconds())]
+fn int_mul(#[case] lhs: i32, #[case] duration: Duration, #[case] expected: Duration) {
+    assert_eq!(lhs * duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 2, 500.milliseconds())]
+#[case(1.seconds(), -2, (-500).milliseconds())]
+fn div_int(#[case] duration: Duration, #[case] rhs: i32, #[case] expected: Duration) {
+    assert_eq!(duration / rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 2, 500.milliseconds())]
+#[case(1.seconds(), -2, (-500).milliseconds())]
+fn div_int_assign(#[case] mut duration: Duration, #[case] rhs: i32, #[case] expected: Duration) {
+    duration /= rhs;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 0.5.seconds(), 2.)]
+#[case(2.seconds(), 0.25.seconds(), 8.)]
+#[allow(clippy::float_cmp)]
+fn div(#[case] lhs: Duration, #[case] rhs: Duration, #[case] expected: f64) {
+    assert_eq!(lhs / rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 0.5.std_seconds(), 2.)]
+#[case(2.seconds(), 0.25.std_seconds(), 8.)]
+#[allow(clippy::float_cmp)]
+fn div_std(#[case] lhs: Duration, #[case] rhs: StdDuration, #[case] expected: f64) {
+    assert_eq!(lhs / rhs, expected);
+}
+
+#[rstest]
+#[case(1.std_seconds(), 0.5.seconds(), 2.)]
+#[case(2.std_seconds(), 0.25.seconds(), 8.)]
+#[allow(clippy::float_cmp)]
+fn std_div(#[case] lhs: StdDuration, #[case] rhs: Duration, #[case] expected: f64) {
+    assert_eq!(lhs / rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.5, 1_500.milliseconds())]
+#[case(1.seconds(), 2.5, 2_500.milliseconds())]
+#[case(1.seconds(), -1.5, (-1_500).milliseconds())]
+#[case(1.seconds(), 0., 0.seconds())]
+fn mul_f32(#[case] duration: Duration, #[case] rhs: f32, #[case] expected: Duration) {
+    assert_eq!(duration * rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.5, 1_500.milliseconds())]
+#[case(1.seconds(), 2.5, 2_500.milliseconds())]
+#[case(1.seconds(), -1.5, (-1_500).milliseconds())]
+#[case(1.seconds(), 0., 0.seconds())]
+fn mul_f64(#[case] duration: Duration, #[case] rhs: f64, #[case] expected: Duration) {
+    assert_eq!(duration * rhs, expected);
+}
+
+#[rstest]
+#[case(1.5, 1.seconds(), 1_500.milliseconds())]
+#[case(2.5, 1.seconds(), 2_500.milliseconds())]
+#[case(-1.5, 1.seconds(), (-1_500).milliseconds())]
+#[case(0., 1.seconds(), 0.seconds())]
+fn f32_mul(#[case] lhs: f32, #[case] duration: Duration, #[case] expected: Duration) {
+    assert_eq!(lhs * duration, expected);
+}
+
+#[rstest]
+#[case(1.5, 1.seconds(), 1_500.milliseconds())]
+#[case(2.5, 1.seconds(), 2_500.milliseconds())]
+#[case(-1.5, 1.seconds(), (-1_500).milliseconds())]
+#[case(0., 1.seconds(), 0.seconds())]
+fn f64_mul(#[case] lhs: f64, #[case] duration: Duration, #[case] expected: Duration) {
+    assert_eq!(lhs * duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.5, 1_500.milliseconds())]
+#[case(1.seconds(), 2.5, 2_500.milliseconds())]
+#[case(1.seconds(), -1.5, (-1_500).milliseconds())]
+#[case(1.seconds(), 0., 0.seconds())]
+fn mul_f32_assign(#[case] mut duration: Duration, #[case] rhs: f32, #[case] expected: Duration) {
+    duration *= rhs;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.5, 1_500.milliseconds())]
+#[case(1.seconds(), 2.5, 2_500.milliseconds())]
+#[case(1.seconds(), -1.5, (-1_500).milliseconds())]
+#[case(1.seconds(), 0., 0.seconds())]
+fn mul_f64_assign(#[case] mut duration: Duration, #[case] rhs: f64, #[case] expected: Duration) {
+    duration *= rhs;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1., 1.seconds())]
+#[case(1.seconds(), 2., 500.milliseconds())]
+#[case(1.seconds(), 4., 250.milliseconds())]
+#[case(1.seconds(), 0.25, 4.seconds())]
+#[case(1.seconds(), -1., (-1).seconds())]
+fn div_f32(#[case] duration: Duration, #[case] rhs: f32, #[case] expected: Duration) {
+    assert_eq!(duration / rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1., 1.seconds())]
+#[case(1.seconds(), 2., 500.milliseconds())]
+#[case(1.seconds(), 4., 250.milliseconds())]
+#[case(1.seconds(), 0.25, 4.seconds())]
+#[case(1.seconds(), -1., (-1).seconds())]
+fn div_f64(#[case] duration: Duration, #[case] rhs: f64, #[case] expected: Duration) {
+    assert_eq!(duration / rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1., 1.seconds())]
+#[case(1.seconds(), 2., 500.milliseconds())]
+#[case(1.seconds(), 4., 250.milliseconds())]
+#[case(1.seconds(), 0.25, 4.seconds())]
+#[case(1.seconds(), -1., (-1).seconds())]
+fn div_f32_assign(#[case] mut duration: Duration, #[case] rhs: f32, #[case] expected: Duration) {
+    duration /= rhs;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1., 1.seconds())]
+#[case(1.seconds(), 2., 500.milliseconds())]
+#[case(1.seconds(), 4., 250.milliseconds())]
+#[case(1.seconds(), 0.25, 4.seconds())]
+#[case(1.seconds(), -1., (-1).seconds())]
+fn div_f64_assign(#[case] mut duration: Duration, #[case] rhs: f64, #[case] expected: Duration) {
+    duration /= rhs;
+    assert_eq!(duration, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.seconds(), true)]
+#[case(0.seconds(), 0.seconds(), true)]
+#[case(1.seconds(), 2.seconds(), false)]
+#[case(1.seconds(), (-1).seconds(), false)]
+#[case((-1).seconds(), (-1).seconds(), true)]
+#[case(40.seconds(), 1.minutes(), false)]
+fn partial_eq(#[case] lhs: Duration, #[case] rhs: Duration, #[case] expected: bool) {
+    assert_eq_ne!(lhs, rhs, expected);
+}
+
+#[rstest]
+#[case(1.seconds(), 1.std_seconds(), true)]
+#[case(0.seconds(), 0.std_seconds(), true)]
+#[case(1.seconds(), 2.std_seconds(), false)]
+#[case((-1).seconds(), 1.std_seconds(), false)]
+#[case(40.seconds(), 1.std_minutes(), false)]
+fn partial_eq_std(#[case] lhs: Duration, #[case] rhs: StdDuration, #[case] expected: bool) {
+    assert_eq_ne!(lhs, rhs, expected);
+}
+
+#[rstest]
+#[case(1.std_seconds(), 1.seconds(), true)]
+#[case(0.std_seconds(), 0.seconds(), true)]
+#[case(2.std_seconds(), 1.seconds(), false)]
+#[case(1.std_seconds(), (-1).seconds(), false)]
+#[case(1.std_minutes(), 40.seconds(), false)]
+fn std_partial_eq(#[case] lhs: StdDuration, #[case] rhs: Duration, #[case] expected: bool) {
+    assert_eq_ne!(lhs, rhs, expected);
+}
+
+#[rstest]
+#[case(0.seconds(), 0.seconds(), Equal)]
+#[case(1.seconds(), 0.seconds(), Greater)]
+#[case(1.seconds(), (-1).seconds(), Greater)]
+#[case((-1).seconds(), 1.seconds(), Less)]
+#[case(0.seconds(), (-1).seconds(), Greater)]
+#[case(0.seconds(), 1.seconds(), Less)]
+#[case((-1).seconds(), 0.seconds(), Less)]
+#[case(1.minutes(), 1.seconds(), Greater)]
+#[case((-1).minutes(), (-1).seconds(), Less)]
+fn partial_ord(#[case] lhs: Duration, #[case] rhs: Duration, #[case] expected: Ordering) {
+    assert_eq!(lhs.partial_cmp(&rhs), Some(expected));
+}
+
+#[rstest]
+#[case(0.seconds(), 0.std_seconds(), Equal)]
+#[case(1.seconds(), 0.std_seconds(), Greater)]
+#[case((-1).seconds(), 1.std_seconds(), Less)]
+#[case(0.seconds(), 1.std_seconds(), Less)]
+#[case((-1).seconds(), 0.std_seconds(), Less)]
+#[case(1.minutes(), 1.std_seconds(), Greater)]
+#[case(0.seconds(), u64::MAX.std_seconds(), Less)]
+fn partial_ord_std(#[case] lhs: Duration, #[case] rhs: StdDuration, #[case] expected: Ordering) {
+    assert_eq!(lhs.partial_cmp(&rhs), Some(expected));
+}
+
+#[rstest]
+#[case(0.std_seconds(), 0.seconds(), Equal)]
+#[case(1.std_seconds(), 0.seconds(), Greater)]
+#[case(1.std_seconds(), (-1).seconds(), Greater)]
+#[case(0.std_seconds(), (-1).seconds(), Greater)]
+#[case(0.std_seconds(), 1.seconds(), Less)]
+#[case(1.std_minutes(), 1.seconds(), Greater)]
+fn std_partial_ord(#[case] lhs: StdDuration, #[case] rhs: Duration, #[case] expected: Ordering) {
+    assert_eq!(lhs.partial_cmp(&rhs), Some(expected));
+}
+
+#[rstest]
+#[case(0.seconds(), 0.seconds(), Equal)]
+#[case(1.seconds(), 0.seconds(), Greater)]
+#[case(1.seconds(), (-1).seconds(), Greater)]
+#[case((-1).seconds(), 1.seconds(), Less)]
+#[case(0.seconds(), (-1).seconds(), Greater)]
+#[case(0.seconds(), 1.seconds(), Less)]
+#[case((-1).seconds(), 0.seconds(), Less)]
+#[case(1.minutes(), 1.seconds(), Greater)]
+#[case((-1).minutes(), (-1).seconds(), Less)]
+#[case(100.nanoseconds(), 200.nanoseconds(), Less)]
+#[case((-100).nanoseconds(), (-200).nanoseconds(), Greater)]
+fn ord(#[case] lhs: Duration, #[case] rhs: Duration, #[case] expected: Ordering) {
+    assert_eq!(lhs.cmp(&rhs), expected);
+}
+
+#[rstest]
+fn arithmetic_regression() {
+    let added = 1.6.seconds() + 1.6.seconds();
+    assert_eq!(added.whole_seconds(), 3);
+    assert_eq!(added.subsec_milliseconds(), 200);
+
+    let subtracted = 1.6.seconds() - (-1.6).seconds();
+    assert_eq!(subtracted.whole_seconds(), 3);
+    assert_eq!(subtracted.subsec_milliseconds(), 200);
+}
+
+#[rstest]
+fn sum_iter_ref() {
+    let i = [1.6.seconds(), 1.6.seconds()];
+    let sum = i.iter().sum::<Duration>();
+    assert_eq!(sum, 3.2.seconds());
+}
+
+#[rstest]
+fn sum_iter() {
+    let i = [1.6.seconds(), 1.6.seconds()];
+    let sum = i.into_iter().sum::<Duration>();
+    assert_eq!(sum, 3.2.seconds());
+}
diff --git a/tests/error.rs b/tests/error.rs
new file mode 100644
index 000000000..244aba31c
--- /dev/null
+++ b/tests/error.rs
@@ -0,0 +1,194 @@
+use std::error::Error as _;
+use std::io;
+
+use time::error::{
+    ComponentRange, ConversionRange, DifferentVariant, Error, Format, IndeterminateOffset,
+    InvalidFormatDescription, InvalidVariant, Parse, ParseFromDescription, TryFromParsed,
+};
+use time::macros::format_description;
+use time::parsing::Parsed;
+use time::{format_description, Date, Time};
+
+macro_rules! assert_display_eq {
+    ($a:expr, $b:expr $(,)?) => {
+        assert_eq!($a.to_string(), $b.to_string())
+    };
+}
+
+macro_rules! assert_dbg_reflexive {
+    ($a:expr) => {
+        assert_eq!(format!("{:?}", $a), format!("{:?}", $a))
+    };
+}
+
+macro_rules! assert_source {
+    ($err:expr,None $(,)?) => {
+        assert!($err.source().is_none())
+    };
+    ($err:expr, $source:ty $(,)?) => {
+        assert!($err.source().unwrap().is::<$source>())
+    };
+}
+
+fn component_range() -> ComponentRange {
+    Date::from_ordinal_date(0, 367).expect_err("367 is not a valid day")
+}
+
+fn insufficient_type_information() -> Format {
+    Time::MIDNIGHT
+        .format(&format_description::well_known::Rfc3339)
+        .expect_err("missing date and UTC offset")
+}
+
+fn unexpected_trailing_characters() -> Parse {
+    Time::parse("a", format_description!("")).expect_err("should fail to parse")
+}
+
+fn invalid_format_description() -> InvalidFormatDescription {
+    format_description::parse("[").expect_err("format description is invalid")
+}
+
+fn io_error() -> io::Error {
+    io::Error::last_os_error()
+}
+
+fn invalid_literal() -> ParseFromDescription {
+    Parsed::parse_literal(b"a", b"b").expect_err("should fail to parse")
+}
+
+#[test]
+fn debug() {
+    assert_dbg_reflexive!(Parse::from(ParseFromDescription::InvalidComponent("a")));
+    assert_dbg_reflexive!(invalid_format_description());
+    assert_dbg_reflexive!(DifferentVariant);
+    assert_dbg_reflexive!(InvalidVariant);
+}
+
+#[test]
+fn display() {
+    assert_display_eq!(ConversionRange, Error::from(ConversionRange));
+    assert_display_eq!(component_range(), Error::from(component_range()));
+    assert_display_eq!(component_range(), TryFromParsed::from(component_range()));
+    assert_display_eq!(IndeterminateOffset, Error::from(IndeterminateOffset));
+    assert_display_eq!(
+        TryFromParsed::InsufficientInformation,
+        Error::from(TryFromParsed::InsufficientInformation)
+    );
+    assert_display_eq!(
+        insufficient_type_information(),
+        Error::from(insufficient_type_information())
+    );
+    assert_display_eq!(
+        Format::InvalidComponent("a"),
+        Error::from(Format::InvalidComponent("a"))
+    );
+    assert_display_eq!(
+        ParseFromDescription::InvalidComponent("a"),
+        Error::from(Parse::from(ParseFromDescription::InvalidComponent("a")))
+    );
+    assert_display_eq!(invalid_literal(), Parse::from(invalid_literal()));
+    assert_display_eq!(
+        component_range(),
+        Error::from(Parse::from(TryFromParsed::from(component_range())))
+    );
+    assert_display_eq!(
+        ParseFromDescription::InvalidComponent("a"),
+        Parse::from(ParseFromDescription::InvalidComponent("a"))
+    );
+    assert_display_eq!(
+        component_range(),
+        Parse::from(TryFromParsed::from(component_range()))
+    );
+    assert_display_eq!(
+        unexpected_trailing_characters(),
+        Error::from(unexpected_trailing_characters()),
+    );
+    assert_display_eq!(
+        invalid_format_description(),
+        Error::from(invalid_format_description())
+    );
+    assert_display_eq!(io_error(), Format::from(io_error()));
+    assert_display_eq!(DifferentVariant, Error::from(DifferentVariant));
+    assert_display_eq!(InvalidVariant, Error::from(InvalidVariant));
+}
+
+#[test]
+fn source() {
+    assert_source!(Error::from(ConversionRange), ConversionRange);
+    assert_source!(Error::from(component_range()), ComponentRange);
+    assert_source!(TryFromParsed::from(component_range()), ComponentRange);
+    assert_source!(TryFromParsed::InsufficientInformation, None);
+    assert_source!(insufficient_type_information(), None);
+    assert_source!(Format::InvalidComponent("a"), None);
+    assert_source!(Error::from(insufficient_type_information()), Format);
+    assert_source!(Error::from(IndeterminateOffset), IndeterminateOffset);
+    assert_source!(
+        Parse::from(TryFromParsed::InsufficientInformation),
+        TryFromParsed
+    );
+    assert_source!(
+        Error::from(TryFromParsed::InsufficientInformation),
+        TryFromParsed
+    );
+    assert_source!(
+        Parse::from(ParseFromDescription::InvalidComponent("a")),
+        ParseFromDescription
+    );
+    assert_source!(
+        Error::from(ParseFromDescription::InvalidComponent("a")),
+        ParseFromDescription
+    );
+    assert_source!(unexpected_trailing_characters(), ParseFromDescription);
+    assert_source!(
+        Error::from(unexpected_trailing_characters()),
+        ParseFromDescription
+    );
+    assert_source!(
+        Error::from(invalid_format_description()),
+        InvalidFormatDescription
+    );
+    assert_source!(Format::from(io_error()), io::Error);
+    assert_source!(Error::from(DifferentVariant), DifferentVariant);
+    assert_source!(Error::from(InvalidVariant), InvalidVariant);
+}
+
+#[test]
+fn component_name() {
+    assert_eq!(component_range().name(), "ordinal");
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn conversion() {
+    assert!(ComponentRange::try_from(Error::from(component_range())).is_ok());
+    assert!(ConversionRange::try_from(Error::from(ConversionRange)).is_ok());
+    assert!(Format::try_from(Error::from(insufficient_type_information())).is_ok());
+    assert!(IndeterminateOffset::try_from(Error::from(IndeterminateOffset)).is_ok());
+    assert!(InvalidFormatDescription::try_from(Error::from(invalid_format_description())).is_ok());
+    assert!(ParseFromDescription::try_from(Error::from(invalid_literal())).is_ok());
+    assert!(ParseFromDescription::try_from(Parse::from(invalid_literal())).is_ok());
+    assert!(ParseFromDescription::try_from(unexpected_trailing_characters()).is_ok());
+    assert!(Parse::try_from(Error::from(unexpected_trailing_characters())).is_ok());
+    assert!(Parse::try_from(Error::from(invalid_literal())).is_ok());
+    assert!(Parse::try_from(Error::from(TryFromParsed::InsufficientInformation)).is_ok());
+    assert!(DifferentVariant::try_from(Error::from(DifferentVariant)).is_ok());
+    assert!(InvalidVariant::try_from(Error::from(InvalidVariant)).is_ok());
+    assert!(ComponentRange::try_from(TryFromParsed::ComponentRange(component_range())).is_ok());
+    assert!(TryFromParsed::try_from(Error::from(TryFromParsed::InsufficientInformation)).is_ok());
+    assert!(TryFromParsed::try_from(Parse::from(TryFromParsed::InsufficientInformation)).is_ok());
+    assert!(io::Error::try_from(Format::from(io_error())).is_ok());
+
+    assert!(ComponentRange::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(ConversionRange::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(Format::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(IndeterminateOffset::try_from(Error::from(ConversionRange)).is_err());
+    assert!(InvalidFormatDescription::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(ParseFromDescription::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(Parse::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(DifferentVariant::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(InvalidVariant::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(ComponentRange::try_from(TryFromParsed::InsufficientInformation).is_err());
+    assert!(TryFromParsed::try_from(Error::from(IndeterminateOffset)).is_err());
+    assert!(TryFromParsed::try_from(unexpected_trailing_characters()).is_err());
+    assert!(io::Error::try_from(insufficient_type_information()).is_err());
+}
diff --git a/tests/ext.rs b/tests/ext.rs
new file mode 100644
index 000000000..e01ea6890
--- /dev/null
+++ b/tests/ext.rs
@@ -0,0 +1,112 @@
+mod numerical_duration {
+    use time::ext::NumericalDuration;
+    use time::Duration;
+
+    #[test]
+    fn unsigned() {
+        assert_eq!(5.nanoseconds(), Duration::nanoseconds(5));
+        assert_eq!(5.microseconds(), Duration::microseconds(5));
+        assert_eq!(5.milliseconds(), Duration::milliseconds(5));
+        assert_eq!(5.seconds(), Duration::seconds(5));
+        assert_eq!(5.minutes(), Duration::minutes(5));
+        assert_eq!(5.hours(), Duration::hours(5));
+        assert_eq!(5.days(), Duration::days(5));
+        assert_eq!(5.weeks(), Duration::weeks(5));
+    }
+
+    #[test]
+    fn signed() {
+        assert_eq!((-5).nanoseconds(), Duration::nanoseconds(-5));
+        assert_eq!((-5).microseconds(), Duration::microseconds(-5));
+        assert_eq!((-5).milliseconds(), Duration::milliseconds(-5));
+        assert_eq!((-5).seconds(), Duration::seconds(-5));
+        assert_eq!((-5).minutes(), Duration::minutes(-5));
+        assert_eq!((-5).hours(), Duration::hours(-5));
+        assert_eq!((-5).days(), Duration::days(-5));
+        assert_eq!((-5).weeks(), Duration::weeks(-5));
+    }
+
+    #[test]
+    fn float() {
+        // Ensure values truncate rather than round.
+        assert_eq!(1.9.nanoseconds(), Duration::nanoseconds(1));
+
+        assert_eq!(1.0.nanoseconds(), Duration::nanoseconds(1));
+        assert_eq!(1.0.microseconds(), Duration::microseconds(1));
+        assert_eq!(1.0.milliseconds(), Duration::milliseconds(1));
+        assert_eq!(1.0.seconds(), Duration::seconds(1));
+        assert_eq!(1.0.minutes(), Duration::minutes(1));
+        assert_eq!(1.0.hours(), Duration::hours(1));
+        assert_eq!(1.0.days(), Duration::days(1));
+        assert_eq!(1.0.weeks(), Duration::weeks(1));
+
+        assert_eq!(1.5.nanoseconds(), Duration::nanoseconds(1));
+        assert_eq!(1.5.microseconds(), Duration::nanoseconds(1_500));
+        assert_eq!(1.5.milliseconds(), Duration::microseconds(1_500));
+        assert_eq!(1.5.seconds(), Duration::milliseconds(1_500));
+        assert_eq!(1.5.minutes(), Duration::seconds(90));
+        assert_eq!(1.5.hours(), Duration::minutes(90));
+        assert_eq!(1.5.days(), Duration::hours(36));
+        assert_eq!(1.5.weeks(), Duration::hours(252));
+    }
+
+    #[test]
+    fn arithmetic() {
+        assert_eq!(2.seconds() + 500.milliseconds(), 2_500.milliseconds());
+        assert_eq!(2.seconds() - 500.milliseconds(), 1_500.milliseconds());
+    }
+}
+
+mod numerical_std_duration {
+    use std::time::Duration as StdDuration;
+
+    use time::ext::NumericalStdDuration;
+
+    #[test]
+    fn unsigned() {
+        assert_eq!(5.std_nanoseconds(), StdDuration::from_nanos(5));
+        assert_eq!(5.std_microseconds(), StdDuration::from_micros(5));
+        assert_eq!(5.std_milliseconds(), StdDuration::from_millis(5));
+        assert_eq!(5.std_seconds(), StdDuration::from_secs(5));
+        assert_eq!(5.std_minutes(), StdDuration::from_secs(5 * 60));
+        assert_eq!(5.std_hours(), StdDuration::from_secs(5 * 3_600));
+        assert_eq!(5.std_days(), StdDuration::from_secs(5 * 86_400));
+        assert_eq!(5.std_weeks(), StdDuration::from_secs(5 * 604_800));
+    }
+
+    #[test]
+    fn float() {
+        // Ensure values truncate rather than round.
+        assert_eq!(1.9.std_nanoseconds(), StdDuration::from_nanos(1));
+
+        assert_eq!(1.0.std_nanoseconds(), StdDuration::from_nanos(1));
+        assert_eq!(1.0.std_microseconds(), StdDuration::from_micros(1));
+        assert_eq!(1.0.std_milliseconds(), StdDuration::from_millis(1));
+        assert_eq!(1.0.std_seconds(), StdDuration::from_secs(1));
+        assert_eq!(1.0.std_minutes(), StdDuration::from_secs(60));
+        assert_eq!(1.0.std_hours(), StdDuration::from_secs(3_600));
+        assert_eq!(1.0.std_days(), StdDuration::from_secs(86_400));
+        assert_eq!(1.0.std_weeks(), StdDuration::from_secs(604_800));
+
+        assert_eq!(1.5.std_nanoseconds(), StdDuration::from_nanos(1));
+        assert_eq!(1.5.std_microseconds(), StdDuration::from_nanos(1_500));
+        assert_eq!(1.5.std_milliseconds(), StdDuration::from_micros(1_500));
+        assert_eq!(1.5.std_seconds(), StdDuration::from_millis(1_500));
+        assert_eq!(1.5.std_minutes(), StdDuration::from_secs(90));
+        assert_eq!(1.5.std_hours(), StdDuration::from_secs(90 * 60));
+        assert_eq!(1.5.std_days(), StdDuration::from_secs(36 * 3_600));
+        assert_eq!(1.5.std_weeks(), StdDuration::from_secs(252 * 3_600));
+    }
+
+    #[test]
+    fn arithmetic() {
+        assert_eq!(
+            2.std_seconds() + 500.std_milliseconds(),
+            2_500.std_milliseconds()
+        );
+        assert_eq!(
+            2.std_seconds() - 500.std_milliseconds(),
+            1_500.std_milliseconds()
+        );
+    }
+}
diff --git a/tests/format_description.rs b/tests/format_description.rs
new file mode 100644
index 000000000..bcbeed32e
--- /dev/null
+++ b/tests/format_description.rs
@@ -0,0 +1,68 @@
+use time::format_description::{modifier, BorrowedFormatItem, Component, OwnedFormatItem};
+
+#[test]
+fn borrowed_format_item_component_conversions() {
+    let component = Component::Year(modifier::Year::default());
+    let item = BorrowedFormatItem::from(component);
+    assert!(matches!(item, BorrowedFormatItem::Component(inner) if inner == component));
+    assert_eq!(Component::try_from(item), Ok(component));
+    assert!(Component::try_from(BorrowedFormatItem::Literal(b"")).is_err());
+    assert!(<&[BorrowedFormatItem<'_>]>::try_from(BorrowedFormatItem::Literal(b"")).is_err());
+}
+
+#[test]
+fn borrowed_format_item_compound_conversions() {
+    let compound = [BorrowedFormatItem::Literal(b"")].as_slice();
+    let item = BorrowedFormatItem::from(compound);
+    assert!(matches!(item, BorrowedFormatItem::Compound(inner) if inner == compound));
+    assert_eq!(<&[BorrowedFormatItem<'_>]>::try_from(item), Ok(compound));
+}
+
+#[test]
+fn borrowed_format_item_equality() {
+    let component = Component::Year(modifier::Year::default());
+    let compound = [BorrowedFormatItem::Literal(b"")].as_slice();
+    let component_item = BorrowedFormatItem::from(component);
+    let compound_item = BorrowedFormatItem::from(compound);
+
+    assert_eq!(component, component_item);
+    assert_eq!(component_item, component);
+    assert_eq!(compound, compound_item);
+    assert_eq!(compound_item, compound);
+}
+
+#[test]
+fn owned_format_item_component_conversions() {
+    let component = Component::Year(modifier::Year::default());
+    let item = OwnedFormatItem::from(component);
+    assert!(matches!(item, OwnedFormatItem::Component(inner) if inner == component));
+    assert_eq!(Component::try_from(item), Ok(component));
+    assert!(Component::try_from(OwnedFormatItem::Literal(Box::new([]))).is_err());
+    assert!(Vec::<OwnedFormatItem>::try_from(OwnedFormatItem::Literal(Box::new([]))).is_err());
+}
+
+#[test]
+fn owned_format_item_compound_conversions() {
+    let compound = vec![OwnedFormatItem::Literal(Box::new([]))];
+    let item = OwnedFormatItem::from(compound.clone());
+    assert!(matches!(item.clone(), OwnedFormatItem::Compound(inner) if inner.to_vec() == compound));
+    assert_eq!(Vec::<OwnedFormatItem>::try_from(item), Ok(compound));
+}
+
+#[test]
+fn owned_format_item_equality() {
+    let component = Component::Year(modifier::Year::default());
+    let compound = OwnedFormatItem::from([BorrowedFormatItem::Literal(b"")].as_slice());
+    let component_item = OwnedFormatItem::from(component);
+
+    assert_eq!(component, component_item);
+    assert_eq!(component_item, component);
+    assert_eq!(
+        compound,
+        [OwnedFormatItem::Literal(Box::new([]))].as_slice()
+    );
+    assert_eq!(
+        [OwnedFormatItem::Literal(Box::new([]))].as_slice(),
+        compound
+    );
+}
diff --git a/tests/formatting.rs b/tests/formatting.rs
new file mode 100644
index 000000000..6cb403b74
--- /dev/null
+++ b/tests/formatting.rs
@@ -0,0 +1,808 @@
+use std::io;
+use std::num::NonZeroU8;
+
+use time::format_description::well_known::iso8601::{DateKind, OffsetPrecision, TimePrecision};
+use time::format_description::well_known::{iso8601, Iso8601, Rfc2822, Rfc3339};
+use time::format_description::{self, BorrowedFormatItem, OwnedFormatItem};
+use time::macros::{date, datetime, format_description as fd, offset, time};
+use time::{OffsetDateTime, Time};
+
+#[test]
+fn rfc_2822() -> time::Result<()> {
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05 UTC).format(&Rfc2822)?,
+        "Sat, 02 Jan 2021 03:04:05 +0000"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05 +06:07).format(&Rfc2822)?,
+        "Sat, 02 Jan 2021 03:04:05 +0607"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05 -06:07).format(&Rfc2822)?,
+        "Sat, 02 Jan 2021 03:04:05 -0607"
+    );
+
+    assert!(matches!(
+        datetime!(1885-01-01 01:01:01 UTC).format(&Rfc2822),
+        Err(time::error::Format::InvalidComponent("year"))
+    ));
+    assert!(matches!(
+        datetime!(2000-01-01 00:00:00 +00:00:01).format(&Rfc2822),
+        Err(time::error::Format::InvalidComponent("offset_second"))
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn rfc_3339() -> time::Result<()> {
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.1 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.1Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.12 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.12Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.123Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_4 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.1234Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_45 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.12345Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_456 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.123456Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_456_7 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.1234567Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_456_78 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.12345678Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_456_789 UTC).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.123456789Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_456_789 -01:02).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.123456789-01:02"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05.123_456_789 +01:02).format(&Rfc3339)?,
+        "2021-01-02T03:04:05.123456789+01:02"
+    );
+
+    assert!(matches!(
+        datetime!(-0001-01-01 0:00 UTC).format(&Rfc3339),
+        Err(time::error::Format::InvalidComponent("year"))
+    ));
+    assert!(matches!(
+        datetime!(0000-01-01 0:00 +00:00:01).format(&Rfc3339),
+        Err(time::error::Format::InvalidComponent("offset_second"))
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn iso_8601() -> time::Result<()> {
+    macro_rules! assert_format_config {
+        ($formatted:literal $(, $($config:tt)+)?) => {
+            assert_eq!(
+                datetime!(2021-01-02 03:04:05 UTC).format(
+                    &Iso8601::<{ iso8601::Config::DEFAULT$($($config)+)?.encode() }>
+                )?,
+                $formatted
+            );
+        };
+    }
+
+    assert!(
+        std::panic::catch_unwind(|| {
+            let _unused = datetime!(2021-01-02 03:04:05 UTC).format(&Iso8601::PARSING);
+        })
+        .is_err()
+    );
+    assert_eq!(
+        datetime!(-123_456-01-02 03:04:05 UTC).format(
+            &Iso8601::<
+                {
+                    iso8601::Config::DEFAULT
+                        .set_year_is_six_digits(true)
+                        .encode()
+                },
+            >
+        )?,
+        "-123456-01-02T03:04:05.000000000Z"
+    );
+    assert_eq!(
+        datetime!(-123_456-01-02 03:04:05 UTC).format(
+            &Iso8601::<
+                {
+                    iso8601::Config::DEFAULT
+                        .set_date_kind(DateKind::Ordinal)
+                        .set_year_is_six_digits(true)
+                        .encode()
+                },
+            >
+        )?,
+        "-123456-002T03:04:05.000000000Z"
+    );
+    assert_eq!(
+        datetime!(-123_456-01-02 03:04:05 UTC).format(
+            &Iso8601::<
+                {
+                    iso8601::Config::DEFAULT
+                        .set_date_kind(DateKind::Week)
+                        .set_year_is_six_digits(true)
+                        .encode()
+                },
+            >
+        )?,
+        "-123456-W01-4T03:04:05.000000000Z"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05+1:00).format(&Iso8601::DEFAULT)?,
+        "2021-01-02T03:04:05.000000000+01:00"
+    );
+    assert_eq!(
+        datetime!(2021-01-02 03:04:05+1:00).format(
+            &Iso8601::<
+                {
+                    iso8601::Config::DEFAULT
+                        .set_offset_precision(OffsetPrecision::Hour)
+                        .encode()
+                },
+            >
+        )?,
+        "2021-01-02T03:04:05.000000000+01"
+    );
+    assert_format_config!("2021-01-02T03:04:05.000000000Z");
+    assert_format_config!("20210102T030405.000000000Z", .set_use_separators(false));
+    assert_format_config!("+002021-01-02T03:04:05.000000000Z", .set_year_is_six_digits(true));
+    assert_format_config!("2021-01-02T03Z", .set_time_precision(TimePrecision::Hour { decimal_digits: None }));
+    assert_format_config!("2021-01-02T03:04Z", .set_time_precision(TimePrecision::Minute { decimal_digits: None }));
+    assert_format_config!("2021-01-02T03:04:05Z", .set_time_precision(TimePrecision::Second { decimal_digits: None }));
+    assert_format_config!("2021-002T03:04:05.000000000Z", .set_date_kind(DateKind::Ordinal));
+    assert_format_config!("2020-W53-6T03:04:05.000000000Z", .set_date_kind(DateKind::Week));
+
+    assert!(matches!(
+        datetime!(+10_000-01-01 0:00 UTC).format(&Iso8601::DEFAULT),
+        Err(time::error::Format::InvalidComponent("year"))
+    ));
+    assert!(matches!(
+        datetime!(+10_000-W 01-1 0:00 UTC).format(
+            &Iso8601::<
+                {
+                    iso8601::Config::DEFAULT
+                        .set_date_kind(DateKind::Week)
+                        .encode()
+                },
+            >
+        ),
+        Err(time::error::Format::InvalidComponent("year"))
+    ));
+    assert!(matches!(
+        datetime!(+10_000-001 0:00 UTC).format(
+            &Iso8601::<
+                {
+                    iso8601::Config::DEFAULT
+                        .set_date_kind(DateKind::Ordinal)
+                        .encode()
+                },
+            >
+        ),
+        Err(time::error::Format::InvalidComponent("year"))
+    ));
+    assert!(matches!(
+        datetime!(2021-01-02 03:04:05 +0:00:01).format(&Iso8601::DEFAULT),
+        Err(time::error::Format::InvalidComponent("offset_second"))
+    ));
+    assert!(matches!(
+        datetime!(2021-01-02 03:04:05 +0:01).format(
+            &Iso8601::<
+                {
+                    iso8601::Config::DEFAULT
+                        .set_offset_precision(OffsetPrecision::Hour)
+                        .encode()
+                },
+            >
+        ),
+        Err(time::error::Format::InvalidComponent("offset_minute"))
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn iso_8601_issue_678() -> time::Result<()> {
+    macro_rules! assert_format_config {
+        ($formatted:literal $(, $($config:tt)+)?) => {
+            assert_eq!(
+                datetime!(2021-01-02 03:04:05.999_999_999 UTC).format(
+                    &Iso8601::<{ iso8601::Config::DEFAULT$($($config)+)?.encode() }>
+                )?,
+                $formatted
+            );
+        };
+    }
+
+    assert_format_config!("2021-01-02T03:04:05.999999999Z", .set_time_precision(TimePrecision::Second { decimal_digits: NonZeroU8::new(9) }));
+    assert_format_config!("2021-01-02T03:04:05.999999Z", .set_time_precision(TimePrecision::Second { decimal_digits: NonZeroU8::new(6) }));
+    assert_format_config!("2021-01-02T03:04:05.999Z", .set_time_precision(TimePrecision::Second { decimal_digits: NonZeroU8::new(3) }));
+
+    Ok(())
+}
+
+#[test]
+fn format_time() -> time::Result<()> {
+    let format_output = [
+        (fd!("[hour]"), "13"),
+        (fd!("[hour repr:12]"), "01"),
+        (fd!("[hour repr:12 padding:none]"), "1"),
+        (fd!("[hour repr:12 padding:space]"), " 1"),
+        (fd!("[hour repr:24]"), "13"),
+        (fd!("[hour repr:24]"), "13"),
+        (fd!("[hour repr:24 padding:none]"), "13"),
+        (fd!("[hour repr:24 padding:space]"), "13"),
+        (fd!("[minute]"), "02"),
+        (fd!("[minute padding:none]"), "2"),
+        (fd!("[minute padding:space]"), " 2"),
+        (fd!("[minute padding:zero]"), "02"),
+        (fd!("[period]"), "PM"),
+        (fd!("[period case:upper]"), "PM"),
+        (fd!("[period case:lower]"), "pm"),
+        (fd!("[second]"), "03"),
+        (fd!("[second padding:none]"), "3"),
+        (fd!("[second padding:space]"), " 3"),
+        (fd!("[second padding:zero]"), "03"),
+        (fd!("[subsecond]"), "456789012"),
+        (fd!("[subsecond digits:1]"), "4"),
+        (fd!("[subsecond digits:2]"), "45"),
+        (fd!("[subsecond digits:3]"), "456"),
+        (fd!("[subsecond digits:4]"), "4567"),
+        (fd!("[subsecond digits:5]"), "45678"),
+        (fd!("[subsecond digits:6]"), "456789"),
+        (fd!("[subsecond digits:7]"), "4567890"),
+        (fd!("[subsecond digits:8]"), "45678901"),
+        (fd!("[subsecond digits:9]"), "456789012"),
+        (fd!("[subsecond digits:1+]"), "456789012"),
+    ];
+
+    for &(format_description, output) in &format_output {
+        assert_eq!(
+            time!(13:02:03.456_789_012).format(format_description)?,
+            output
+        );
+        assert!(
+            time!(13:02:03.456_789_012)
+                .format_into(&mut io::sink(), format_description)
+                .is_ok()
+        );
+        assert_eq!(
+            time!(13:02:03.456_789_012).format(&OwnedFormatItem::from(format_description))?,
+            output
+        );
+        assert!(
+            time!(13:02:03.456_789_012)
+                .format_into(&mut io::sink(), &OwnedFormatItem::from(format_description))
+                .is_ok()
+        );
+    }
+
+    assert_eq!(
+        time!(1:02:03).format(fd!("[hour repr:12][period]"))?,
+        "01AM"
+    );
+    assert_eq!(
+        Time::MIDNIGHT.format(fd!("[hour repr:12][period case:lower]"))?,
+        "12am"
+    );
+    assert_eq!(Time::MIDNIGHT.format(fd!("[subsecond digits:1+]"))?, "0");
+    assert_eq!(
+        time!(0:00:00.01).format(fd!("[subsecond digits:1+]"))?,
+        "01"
+    );
+    assert_eq!(
+        time!(0:00:00.001).format(fd!("[subsecond digits:1+]"))?,
+        "001"
+    );
+    assert_eq!(
+        time!(0:00:00.0001).format(fd!("[subsecond digits:1+]"))?,
+        "0001"
+    );
+    assert_eq!(
+        time!(0:00:00.00001).format(fd!("[subsecond digits:1+]"))?,
+        "00001"
+    );
+    assert_eq!(
+        time!(0:00:00.000001).format(fd!("[subsecond digits:1+]"))?,
+        "000001"
+    );
+    assert_eq!(
+        time!(0:00:00.0000001).format(fd!("[subsecond digits:1+]"))?,
+        "0000001"
+    );
+    assert_eq!(
+        time!(0:00:00.00000001).format(fd!("[subsecond digits:1+]"))?,
+        "00000001"
+    );
+    assert_eq!(
+        time!(0:00:00.000000001).format(fd!("[subsecond digits:1+]"))?,
+        "000000001"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn display_time() {
+    assert_eq!(time!(0:00).to_string(), "0:00:00.0");
+    assert_eq!(time!(23:59).to_string(), "23:59:00.0");
+    assert_eq!(time!(23:59:59).to_string(), "23:59:59.0");
+    assert_eq!(time!(0:00:01).to_string(), "0:00:01.0");
+    assert_eq!(time!(0:00:00.1).to_string(), "0:00:00.1");
+    assert_eq!(time!(0:00:00.01).to_string(), "0:00:00.01");
+    assert_eq!(time!(0:00:00.001).to_string(), "0:00:00.001");
+    assert_eq!(time!(0:00:00.000_1).to_string(), "0:00:00.0001");
+    assert_eq!(time!(0:00:00.000_01).to_string(), "0:00:00.00001");
+    assert_eq!(time!(0:00:00.000_001).to_string(), "0:00:00.000001");
+    assert_eq!(time!(0:00:00.000_000_1).to_string(), "0:00:00.0000001");
+    assert_eq!(time!(0:00:00.000_000_01).to_string(), "0:00:00.00000001");
+    assert_eq!(time!(0:00:00.000_000_001).to_string(), "0:00:00.000000001");
+
+    assert_eq!(format!("{:>12}", time!(0:00)), "   0:00:00.0");
+    assert_eq!(format!("{:x^14}", time!(0:00)), "xx0:00:00.0xxx");
+}
+
+#[test]
+fn format_date() -> time::Result<()> {
+    let format_output = [
+        (fd!("[day]"), "31"),
+        (fd!("[month]"), "12"),
+        (fd!("[month repr:short]"), "Dec"),
+        (fd!("[month repr:long]"), "December"),
+        (fd!("[ordinal]"), "365"),
+        (fd!("[weekday]"), "Tuesday"),
+        (fd!("[weekday repr:short]"), "Tue"),
+        (fd!("[weekday repr:sunday]"), "3"),
+        (fd!("[weekday repr:sunday one_indexed:false]"), "2"),
+        (fd!("[weekday repr:monday]"), "2"),
+        (fd!("[weekday repr:monday one_indexed:false]"), "1"),
+        (fd!("[week_number]"), "01"),
+        (fd!("[week_number padding:none]"), "1"),
+        (fd!("[week_number padding:space]"), " 1"),
+        (fd!("[week_number repr:sunday]"), "52"),
+        (fd!("[week_number repr:monday]"), "52"),
+        (fd!("[year]"), "2019"),
+        (fd!("[year base:iso_week]"), "2020"),
+        (fd!("[year sign:mandatory]"), "+2019"),
+        (fd!("[year base:iso_week sign:mandatory]"), "+2020"),
+        (fd!("[year repr:last_two]"), "19"),
+        (fd!("[year base:iso_week repr:last_two]"), "20"),
+    ];
+
+    for &(format_description, output) in &format_output {
+        assert_eq!(date!(2019 - 12 - 31).format(format_description)?, output);
+        assert!(
+            date!(2019 - 12 - 31)
+                .format_into(&mut io::sink(), format_description)
+                .is_ok()
+        );
+        assert_eq!(
+            date!(2019 - 12 - 31).format(&OwnedFormatItem::from(format_description))?,
+            output
+        );
+        assert!(
+            date!(2019 - 12 - 31)
+                .format_into(&mut io::sink(), &OwnedFormatItem::from(format_description))
+                .is_ok()
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn display_date() {
+    assert_eq!(date!(2019 - 01 - 01).to_string(), "2019-01-01");
+    assert_eq!(date!(2019 - 12 - 31).to_string(), "2019-12-31");
+    assert_eq!(date!(-4713 - 11 - 24).to_string(), "-4713-11-24");
+    assert_eq!(date!(-0001 - 01 - 01).to_string(), "-0001-01-01");
+
+    assert_eq!(date!(+10_000-01-01).to_string(), "+10000-01-01");
+    assert_eq!(date!(+100_000-01-01).to_string(), "+100000-01-01");
+    assert_eq!(date!(-10_000 - 01 - 01).to_string(), "-10000-01-01");
+    assert_eq!(date!(-100_000 - 01 - 01).to_string(), "-100000-01-01");
+}
+
+#[test]
+fn format_offset() -> time::Result<()> {
+    let value_format_output = [
+        (
+            offset!(+01:02:03),
+            fd!("[offset_hour sign:automatic]"),
+            "01",
+        ),
+        (
+            offset!(+01:02:03),
+            fd!("[offset_hour sign:mandatory]"),
+            "+01",
+        ),
+        (
+            offset!(-01:02:03),
+            fd!("[offset_hour sign:automatic]"),
+            "-01",
+        ),
+        (
+            offset!(-01:02:03),
+            fd!("[offset_hour sign:mandatory]"),
+            "-01",
+        ),
+        (offset!(+01:02:03), fd!("[offset_minute]"), "02"),
+        (offset!(+01:02:03), fd!("[offset_second]"), "03"),
+    ];
+
+    for &(value, format_description, output) in &value_format_output {
+        assert_eq!(value.format(format_description)?, output);
+        assert!(
+            value
+                .format_into(&mut io::sink(), format_description)
+                .is_ok()
+        );
+        assert_eq!(
+            value.format(&OwnedFormatItem::from(format_description))?,
+            output
+        );
+        assert!(
+            value
+                .format_into(&mut io::sink(), &OwnedFormatItem::from(format_description))
+                .is_ok()
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn display_offset() {
+    assert_eq!(offset!(UTC).to_string(), "+00:00:00");
+    assert_eq!(offset!(+0:00:01).to_string(), "+00:00:01");
+    assert_eq!(offset!(-0:00:01).to_string(), "-00:00:01");
+    assert_eq!(offset!(+1).to_string(), "+01:00:00");
+    assert_eq!(offset!(-1).to_string(), "-01:00:00");
+    assert_eq!(offset!(+23:59).to_string(), "+23:59:00");
+    assert_eq!(offset!(-23:59).to_string(), "-23:59:00");
+    assert_eq!(offset!(+23:59:59).to_string(), "+23:59:59");
+    assert_eq!(offset!(-23:59:59).to_string(), "-23:59:59");
+
+    assert_eq!(format!("{:>10}", offset!(UTC)), " +00:00:00");
+    assert_eq!(format!("{:x^14}", offset!(UTC)), "xx+00:00:00xxx");
+}
+
+#[test]
+fn format_pdt() -> time::Result<()> {
+    let format_description = fd!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]");
+
+    assert_eq!(
+        datetime!(1970-01-01 0:00).format(format_description)?,
+        "1970-01-01 00:00:00.0"
+    );
+    assert!(
+        datetime!(1970-01-01 0:00)
+            .format_into(&mut io::sink(), format_description)
+            .is_ok()
+    );
+    assert_eq!(
+        datetime!(1970-01-01 0:00).format(&OwnedFormatItem::from(format_description))?,
+        "1970-01-01 00:00:00.0"
+    );
+    assert!(
+        datetime!(1970-01-01 0:00)
+            .format_into(&mut io::sink(), &OwnedFormatItem::from(format_description))
+            .is_ok()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn display_pdt() {
+    assert_eq!(
+        datetime!(1970-01-01 0:00).to_string(),
+        String::from("1970-01-01 0:00:00.0")
+    );
+    assert_eq!(
+        datetime!(1970-01-01 0:00:01).to_string(),
+        String::from("1970-01-01 0:00:01.0")
+    );
+}
+
+#[test]
+fn format_odt() -> time::Result<()> {
+    let format_description = format_description::parse(
+        "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond digits:1+] [offset_hour \
+         sign:mandatory]:[offset_minute]:[offset_second]",
+    )?;
+
+    assert_eq!(
+        datetime!(1970-01-01 0:00 UTC).format(&format_description)?,
+        "1970-01-01 00:00:00.0 +00:00:00"
+    );
+    assert!(
+        datetime!(1970-01-01 0:00 UTC)
+            .format_into(&mut io::sink(), &format_description)
+            .is_ok()
+    );
+    assert_eq!(
+        datetime!(1970-01-01 0:00 UTC).format(&OwnedFormatItem::from(&format_description))?,
+        "1970-01-01 00:00:00.0 +00:00:00"
+    );
+    assert!(
+        datetime!(1970-01-01 0:00 UTC)
+            .format_into(&mut io::sink(), &OwnedFormatItem::from(format_description))
+            .is_ok()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn display_odt() {
+    assert_eq!(
+        datetime!(1970-01-01 0:00 UTC).to_string(),
+        "1970-01-01 0:00:00.0 +00:00:00"
+    );
+}
+
+#[test]
+fn insufficient_type_information() {
+    let assert_insufficient_type_information = |res| {
+        assert!(matches!(
+            res,
+            Err(time::error::Format::InsufficientTypeInformation { .. })
+        ));
+    };
+    assert_insufficient_type_information(Time::MIDNIGHT.format(fd!("[year]")));
+    assert_insufficient_type_information(Time::MIDNIGHT.format(&Rfc3339));
+    assert_insufficient_type_information(date!(2021 - 001).format(&Rfc3339));
+    assert_insufficient_type_information(datetime!(2021 - 001 0:00).format(&Rfc3339));
+    assert_insufficient_type_information(Time::MIDNIGHT.format(&Rfc2822));
+    assert_insufficient_type_information(date!(2021 - 001).format(&Rfc2822));
+    assert_insufficient_type_information(datetime!(2021 - 001 0:00).format(&Rfc2822));
+    assert_insufficient_type_information(Time::MIDNIGHT.format(&BorrowedFormatItem::First(&[
+        BorrowedFormatItem::Compound(fd!("[year]")),
+    ])));
+    assert_insufficient_type_information(Time::MIDNIGHT.format(&Iso8601::DEFAULT));
+    assert_insufficient_type_information(date!(2021 - 001).format(&Iso8601::DEFAULT));
+    assert_insufficient_type_information(datetime!(2021-001 0:00).format(&Iso8601::DEFAULT));
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn failed_write() -> time::Result<()> {
+    macro_rules! assert_err {
+        ($val:expr, $format:expr) => {{
+            let val = $val;
+            let format = $format;
+            let success_len = val.format(&format)?.len();
+            for len in 0..success_len {
+                let mut buf = &mut vec![0; len][..];
+                let res = val.format_into(&mut buf, &format);
+                assert!(matches!(
+                    res,
+                    Err(time::error::Format::StdIo(e)) if e.kind() == io::ErrorKind::WriteZero)
+                );
+            }
+        }};
+    }
+
+    assert_err!(Time::MIDNIGHT, fd!("foo"));
+    assert_err!(Time::MIDNIGHT, OwnedFormatItem::from(fd!("foo")));
+    assert_err!(Time::MIDNIGHT, BorrowedFormatItem::Compound(fd!("foo")));
+    assert_err!(
+        Time::MIDNIGHT,
+        BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(fd!("foo")))
+    );
+    assert_err!(
+        Time::MIDNIGHT,
+        OwnedFormatItem::from(BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(
+            fd!("foo")
+        )))
+    );
+    assert_err!(OffsetDateTime::UNIX_EPOCH, Rfc3339);
+    assert_err!(datetime!(2021-001 0:00:00.1 UTC), Rfc3339);
+    assert_err!(datetime!(2021-001 0:00 +0:01), Rfc3339);
+    assert_err!(OffsetDateTime::UNIX_EPOCH, Rfc2822);
+    assert_err!(OffsetDateTime::UNIX_EPOCH, Iso8601::DEFAULT);
+    assert_err!(datetime!(2021-001 0:00 +0:01), Iso8601::DEFAULT);
+    assert_err!(
+        OffsetDateTime::UNIX_EPOCH,
+        Iso8601::<
+            {
+                iso8601::Config::DEFAULT
+                    .set_year_is_six_digits(true)
+                    .encode()
+            },
+        >
+    );
+    assert_err!(
+        OffsetDateTime::UNIX_EPOCH,
+        Iso8601::<
+            {
+                iso8601::Config::DEFAULT
+                    .set_date_kind(DateKind::Ordinal)
+                    .encode()
+            },
+        >
+    );
+    assert_err!(
+        OffsetDateTime::UNIX_EPOCH,
+        Iso8601::<
+            {
+                iso8601::Config::DEFAULT
+                    .set_year_is_six_digits(true)
+                    .set_date_kind(DateKind::Ordinal)
+                    .encode()
+            },
+        >
+    );
+    assert_err!(
+        OffsetDateTime::UNIX_EPOCH,
+        Iso8601::<
+            {
+                iso8601::Config::DEFAULT
+                    .set_year_is_six_digits(true)
+                    .set_date_kind(DateKind::Week)
+                    .encode()
+            },
+        >
+    );
+    assert_err!(
+        OffsetDateTime::UNIX_EPOCH,
+        Iso8601::<
+            {
+                iso8601::Config::DEFAULT
+                    .set_date_kind(DateKind::Week)
+                    .encode()
+            },
+        >
+    );
+    assert_err!(
+        OffsetDateTime::UNIX_EPOCH,
+        Iso8601::<
+            {
+                iso8601::Config::DEFAULT
+                    .set_time_precision(TimePrecision::Minute {
+                        decimal_digits: None,
+                    })
+                    .encode()
+            },
+        >
+    );
+    assert_err!(
+        OffsetDateTime::UNIX_EPOCH,
+        Iso8601::<
+            {
+                iso8601::Config::DEFAULT
+                    .set_time_precision(TimePrecision::Hour {
+                        decimal_digits: None,
+                    })
+                    .encode()
+            },
+        >
+    );
+
+    assert_err!(Time::MIDNIGHT, fd!("[hour padding:space]"));
+    assert_err!(offset!(+1), fd!("[offset_hour sign:mandatory]"));
+    assert_err!(offset!(-1), fd!("[offset_hour]"));
+    assert_err!(date!(-1 - 001), fd!("[year]"));
+    assert_err!(date!(2021 - 001), fd!("[year sign:mandatory]"));
+    assert_err!(date!(+999_999 - 001), fd!("[year]"));
+    assert_err!(date!(+99_999 - 001), fd!("[year]"));
+
+    let component_names = [
+        "day",
+        "month",
+        "ordinal",
+        "weekday",
+        "week_number",
+        "year",
+        "hour",
+        "minute",
+        "period",
+        "second",
+        "subsecond",
+        "offset_hour",
+        "offset_minute",
+        "offset_second",
+    ];
+    for component in &component_names {
+        let component = format!("[{component}]");
+        assert_err!(
+            OffsetDateTime::UNIX_EPOCH,
+            format_description::parse(&component)?
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn first() -> time::Result<()> {
+    assert_eq!(Time::MIDNIGHT.format(&BorrowedFormatItem::First(&[]))?, "");
+    assert_eq!(
+        Time::MIDNIGHT.format(&BorrowedFormatItem::First(&[BorrowedFormatItem::Compound(
+            fd!("[hour]")
+        )]))?,
+        "00"
+    );
+    assert_eq!(
+        Time::MIDNIGHT.format(&OwnedFormatItem::First(Box::new([])))?,
+        ""
+    );
+    assert_eq!(
+        Time::MIDNIGHT.format(&OwnedFormatItem::from(BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Compound(fd!("[hour]"))
+        ])))?,
+        "00"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn ignore() -> time::Result<()> {
+    assert_eq!(Time::MIDNIGHT.format(fd!("[ignore count:2]"))?, "");
+
+    Ok(())
+}
+
+#[test]
+fn end() -> time::Result<()> {
+    assert_eq!(Time::MIDNIGHT.format(fd!("[end]"))?, "");
+
+    Ok(())
+}
+
+#[test]
+fn unix_timestamp() -> time::Result<()> {
+    let dt = datetime!(2009-02-13 23:31:30.123456789 UTC);
+
+    assert_eq!(dt.format(&fd!("[unix_timestamp]"))?, "1234567890");
+    assert_eq!(
+        dt.format(&fd!("[unix_timestamp sign:mandatory]"))?,
+        "+1234567890"
+    );
+    assert_eq!(
+        dt.format(&fd!("[unix_timestamp precision:millisecond]"))?,
+        "1234567890123"
+    );
+    assert_eq!(
+        dt.format(&fd!("[unix_timestamp precision:microsecond]"))?,
+        "1234567890123456"
+    );
+    assert_eq!(
+        dt.format(&fd!("[unix_timestamp precision:nanosecond]"))?,
+        "1234567890123456789"
+    );
+    assert_eq!(
+        datetime!(1969-12-31 23:59:59 UTC).format(&fd!("[unix_timestamp]"))?,
+        "-1"
+    );
+
+    Ok(())
+}
diff --git a/tests/instant.rs b/tests/instant.rs
new file mode 100644
index 000000000..ec1405191
--- /dev/null
+++ b/tests/instant.rs
@@ -0,0 +1,238 @@
+#![allow(deprecated)]
+
+use std::cmp::Ordering;
+use std::thread;
+use std::time::Instant as StdInstant;
+
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::{Duration, Instant};
+
+#[test]
+fn elapsed() {
+    let instant = Instant::now();
+    thread::sleep(1.std_milliseconds());
+    assert!(instant.elapsed() >= 1.milliseconds());
+}
+
+#[test]
+fn checked_add() {
+    let now = Instant::now();
+    assert_eq!(now.checked_add(0.seconds()), Some(now));
+    assert_eq!(now.checked_add(5.seconds()), Some(now + 5.seconds()));
+    assert_eq!(now.checked_add((-5).seconds()), Some(now + (-5).seconds()));
+}
+
+#[test]
+fn checked_sub() {
+    let now = Instant::now();
+    assert_eq!(now.checked_sub(0.seconds()), Some(now));
+    assert_eq!(now.checked_sub(5.seconds()), Some(now - 5.seconds()));
+    assert_eq!(now.checked_sub((-5).seconds()), Some(now - (-5).seconds()));
+}
+
+#[test]
+fn into_inner() {
+    let now = Instant::now();
+    assert_eq!(now.into_inner(), now.0);
+}
+
+#[test]
+fn std_from() {
+    let now_time = Instant::now();
+    let now_std = StdInstant::from(now_time);
+    assert_eq!(now_time, now_std);
+}
+
+#[test]
+fn from_std() {
+    let now_std = StdInstant::now();
+    let now_time = Instant::from(now_std);
+    assert_eq!(now_time, now_std);
+}
+
+#[allow(clippy::eq_op)]
+#[test]
+fn sub() {
+    let start = Instant::now();
+    thread::sleep(1.std_milliseconds());
+    assert!(Instant::now() - start >= 1.milliseconds());
+    assert_eq!(start - start, Duration::ZERO);
+}
+
+#[test]
+fn sub_std() {
+    let start = StdInstant::now();
+    thread::sleep(1.std_milliseconds());
+    assert!(Instant::now() - start >= 1.milliseconds());
+}
+
+#[test]
+fn std_sub() {
+    let start = Instant::now();
+    thread::sleep(1.std_milliseconds());
+    assert!(StdInstant::now() - start >= 1.milliseconds());
+}
+
+#[test]
+fn add_duration() {
+    let start = Instant::now();
+    assert!(start + 0.seconds() <= Instant::now());
+    thread::sleep(1.std_milliseconds());
+    assert!(start + 1.milliseconds() <= Instant::now());
+}
+
+#[test]
+fn std_add_duration() {
+    let start = StdInstant::now();
+    thread::sleep(1.std_milliseconds());
+    assert!(start + 1.milliseconds() <= StdInstant::now());
+}
+
+#[test]
+fn add_std_duration() {
+    let start = Instant::now();
+    thread::sleep(1.std_milliseconds());
+    assert!(start + 1.std_milliseconds() <= Instant::now());
+}
+
+#[test]
+fn add_assign_duration() {
+    let mut start = Instant::now();
+    thread::sleep(1.std_milliseconds());
+    start += 1.milliseconds();
+    assert!(start <= Instant::now());
+}
+
+#[test]
+fn std_add_assign_duration() {
+    let mut start = StdInstant::now();
+    thread::sleep(1.std_milliseconds());
+    start += 1.milliseconds();
+    assert!(start <= StdInstant::now());
+}
+
+#[test]
+fn add_assign_std_duration() {
+    let mut start = Instant::now();
+    thread::sleep(1.std_milliseconds());
+    start += 1.std_milliseconds();
+    assert!(start <= Instant::now());
+}
+
+#[test]
+fn sub_duration() {
+    let instant = Instant::now();
+    assert!(instant - 100.milliseconds() <= Instant::now());
+    assert_eq!(instant - Duration::ZERO, instant);
+}
+
+#[test]
+fn std_sub_duration() {
+    let instant = StdInstant::now();
+    assert!(instant - 100.milliseconds() <= StdInstant::now());
+}
+
+#[test]
+fn sub_std_duration() {
+    let instant = Instant::now();
+    assert!(instant - 100.std_milliseconds() <= Instant::now());
+}
+
+#[test]
+fn sub_assign_duration() {
+    let mut instant = Instant::now();
+    instant -= 100.milliseconds();
+    assert!(instant <= Instant::now());
+}
+
+#[test]
+fn std_sub_assign_duration() {
+    let mut instant = StdInstant::now();
+    instant -= 100.milliseconds();
+    assert!(instant <= StdInstant::now());
+}
+
+#[test]
+fn sub_assign_std_duration() {
+    let mut instant = Instant::now();
+    instant -= 100.std_milliseconds();
+    assert!(instant <= Instant::now());
+}
+
+#[test]
+fn eq_std() {
+    let now_time = Instant::now();
+    let now_std = StdInstant::from(now_time);
+    assert_eq!(now_time, now_std);
+}
+
+#[test]
+fn std_eq() {
+    let now_time = Instant::now();
+    let now_std = StdInstant::from(now_time);
+    assert_eq!(now_std, now_time);
+}
+
+#[test]
+fn ord() {
+    let now_time = Instant::now();
+    let now_std = now_time + 1.seconds();
+    assert_eq!(now_time.cmp(&now_std), Ordering::Less);
+
+    let now_time = Instant::now();
+    let now_std = now_time - 1.seconds();
+    assert_eq!(now_time.cmp(&now_std), Ordering::Greater);
+}
+
+#[test]
+fn partial_ord_std() {
+    let now_time = Instant::now();
+    let now_std = StdInstant::from(now_time) + 1.seconds();
+    assert!(now_time < now_std);
+
+    let now_time = Instant::now();
+    let now_std = StdInstant::from(now_time) - 1.seconds();
+    assert!(now_time > now_std);
+}
+
+#[test]
+fn std_partial_ord() {
+    let now_time = Instant::now();
+    let now_std = StdInstant::from(now_time) + 1.seconds();
+    assert!(now_std > now_time);
+
+    let now_time = Instant::now();
+    let now_std = StdInstant::from(now_time) - 1.seconds();
+    assert!(now_std < now_time);
+}
+
+#[test]
+fn sub_regression() {
+    let now = Instant::now();
+    let future = now + Duration::seconds(5);
+    let past = now - Duration::seconds(5);
+
+    assert_eq!(future - now, Duration::seconds(5));
+    assert_eq!(now - past, Duration::seconds(5));
+    assert_eq!(future - past, Duration::seconds(10));
+
+    assert_eq!(now - future, Duration::seconds(-5));
+    assert_eq!(past - now, Duration::seconds(-5));
+    assert_eq!(past - future, Duration::seconds(-10));
+}
+
+#[test]
+fn as_ref() {
+    let now = Instant::now();
+    assert_eq!(now.as_ref(), now.as_ref());
+}
+
+#[test]
+fn borrow() {
+    use std::borrow::Borrow;
+    let now = Instant::now();
+    assert_eq!(
+        <Instant as Borrow<StdInstant>>::borrow(&now),
+        <Instant as Borrow<StdInstant>>::borrow(&now)
+    );
+}
diff --git a/tests/macros.rs b/tests/macros.rs
new file mode 100644
index 000000000..855fad85c
--- /dev/null
+++ b/tests/macros.rs
@@ -0,0 +1,367 @@
+use core::num::NonZeroU16;
+
+use rstest::rstest;
+use time::format_description::modifier::*;
+use time::format_description::{BorrowedFormatItem, Component};
+use time::macros::{date, format_description, time};
+use time::{Date, Time};
+
+#[rstest]
+fn nontrivial_string() {
+    assert!(format_description!(r"").is_empty());
+    assert!(format_description!(r###""###).is_empty());
+    assert!(format_description!(b"").is_empty());
+    assert!(format_description!(br"").is_empty());
+    assert!(format_description!(br###""###).is_empty());
+    #[rustfmt::skip]
+    assert_eq!(
+        format_description!("foo\
+        bar\n\r\t\\\"\'\0\x20\x4E\x4e\u{20}\u{4E}\u{4_e}"),
+        &[BorrowedFormatItem::Literal(b"foobar\n\r\t\\\"'\0 NN NN")]
+    );
+    #[rustfmt::skip]
+    assert_eq!(
+        format_description!(b"foo\
+        bar\n\r\t\\\"\'\0\x20\x4E\x4e"),
+        &[BorrowedFormatItem::Literal(b"foobar\n\r\t\\\"'\0 NN")]
+    );
+}
+
+#[rstest]
+fn format_description_version() {
+    assert_eq!(
+        format_description!(version = 1, "[["),
+        &[BorrowedFormatItem::Literal(b"[")]
+    );
+    assert_eq!(
+        format_description!(version = 1, r"\\"),
+        &[BorrowedFormatItem::Literal(br"\\")]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"\\"),
+        &[BorrowedFormatItem::Literal(br"\")]
+    );
+}
+
+#[rstest]
+fn nested_v1() {
+    assert_eq!(
+        format_description!(version = 1, "[optional [[[]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Literal(
+            b"["
+        ))]
+    );
+    assert_eq!(
+        format_description!(version = 1, "[optional [ [[ ]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(
+            &[
+                BorrowedFormatItem::Literal(b" "),
+                BorrowedFormatItem::Literal(b"["),
+                BorrowedFormatItem::Literal(b" "),
+            ]
+        ))]
+    );
+    assert_eq!(
+        format_description!(version = 1, "[first [a][[[]]"),
+        &[BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Literal(b"a"),
+            BorrowedFormatItem::Literal(b"[")
+        ])]
+    );
+}
+
+#[rstest]
+fn optional() {
+    assert_eq!(
+        format_description!(version = 2, "[optional [:[year]]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(
+            &[
+                BorrowedFormatItem::Literal(b":"),
+                BorrowedFormatItem::Component(Component::Year(Default::default()))
+            ]
+        ))]
+    );
+    assert_eq!(
+        format_description!(version = 2, "[optional [[year]]]"),
+        &[BorrowedFormatItem::Optional(
+            &BorrowedFormatItem::Component(Component::Year(Default::default()))
+        )]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"[optional [\[]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Literal(
+            b"["
+        ))]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"[optional [ \[ ]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(
+            &[
+                BorrowedFormatItem::Literal(b" "),
+                BorrowedFormatItem::Literal(b"["),
+                BorrowedFormatItem::Literal(b" "),
+            ]
+        ))]
+    );
+}
+
+#[rstest]
+fn first() {
+    assert_eq!(
+        format_description!(version = 2, "[first [a]]"),
+        &[BorrowedFormatItem::First(&[BorrowedFormatItem::Literal(
+            b"a"
+        )])]
+    );
+    assert_eq!(
+        format_description!(version = 2, "[first [a] [b]]"),
+        &[BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Literal(b"a"),
+            BorrowedFormatItem::Literal(b"b"),
+        ])]
+    );
+    assert_eq!(
+        format_description!(version = 2, "[first [a][b]]"),
+        &[BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Literal(b"a"),
+            BorrowedFormatItem::Literal(b"b"),
+        ])]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"[first [a][\[]]"),
+        &[BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Literal(b"a"),
+            BorrowedFormatItem::Literal(b"["),
+        ])]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"[first [a][\[\[]]"),
+        &[BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Literal(b"a"),
+            BorrowedFormatItem::Compound(&[
+                BorrowedFormatItem::Literal(b"["),
+                BorrowedFormatItem::Literal(b"["),
+            ])
+        ])]
+    );
+    assert_eq!(
+        format_description!(
+            version = 2,
+            "[first [[period case:upper]] [[period case:lower]] ]"
+        ),
+        &[BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Component(Component::Period(modifier!(Period {
+                is_uppercase: true,
+                case_sensitive: true,
+            }))),
+            BorrowedFormatItem::Component(Component::Period(modifier!(Period {
+                is_uppercase: false,
+                case_sensitive: true,
+            }))),
+        ])]
+    );
+}
+
+#[rstest]
+fn backslash_escape() {
+    assert_eq!(
+        format_description!(version = 2, r"[optional [\]]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Literal(
+            b"]"
+        ))]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"[optional [\[]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Literal(
+            b"["
+        ))]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"[optional [\\]]"),
+        &[BorrowedFormatItem::Optional(&BorrowedFormatItem::Literal(
+            br"\"
+        ))]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"\\"),
+        &[BorrowedFormatItem::Literal(br"\")]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"\["),
+        &[BorrowedFormatItem::Literal(br"[")]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"\]"),
+        &[BorrowedFormatItem::Literal(br"]")]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"foo\\"),
+        &[
+            BorrowedFormatItem::Literal(b"foo"),
+            BorrowedFormatItem::Literal(br"\"),
+        ]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"\\"),
+        &[BorrowedFormatItem::Literal(br"\")]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"\["),
+        &[BorrowedFormatItem::Literal(br"[")]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"\]"),
+        &[BorrowedFormatItem::Literal(br"]")]
+    );
+    assert_eq!(
+        format_description!(version = 2, r"foo\\"),
+        &[
+            BorrowedFormatItem::Literal(b"foo"),
+            BorrowedFormatItem::Literal(br"\"),
+        ]
+    );
+}
+
+#[rstest]
+fn format_description_coverage() {
+    assert_eq!(
+        format_description!("[day padding:space][day padding:zero][day padding:none]"),
+        &[
+            BorrowedFormatItem::Component(Component::Day(modifier!(Day {
+                padding: Padding::Space,
+            }))),
+            BorrowedFormatItem::Component(Component::Day(modifier!(Day {
+                padding: Padding::Zero,
+            }))),
+            BorrowedFormatItem::Component(Component::Day(modifier!(Day {
+                padding: Padding::None,
+            })))
+        ]
+    );
+    assert_eq!(
+        format_description!(
+            "[offset_minute padding:space][offset_minute padding:zero][offset_minute padding:none]"
+        ),
+        &[
+            BorrowedFormatItem::Component(Component::OffsetMinute(modifier!(OffsetMinute {
+                padding: Padding::Space,
+            }))),
+            BorrowedFormatItem::Component(Component::OffsetMinute(modifier!(OffsetMinute {
+                padding: Padding::Zero,
+            }))),
+            BorrowedFormatItem::Component(Component::OffsetMinute(modifier!(OffsetMinute {
+                padding: Padding::None,
+            })))
+        ]
+    );
+    assert_eq!(
+        format_description!(
+            "[offset_second padding:space][offset_second padding:zero][offset_second padding:none]"
+        ),
+        &[
+            BorrowedFormatItem::Component(Component::OffsetSecond(modifier!(OffsetSecond {
+                padding: Padding::Space,
+            }))),
+            BorrowedFormatItem::Component(Component::OffsetSecond(modifier!(OffsetSecond {
+                padding: Padding::Zero,
+            }))),
+            BorrowedFormatItem::Component(Component::OffsetSecond(modifier!(OffsetSecond {
+                padding: Padding::None,
+            }))),
+        ]
+    );
+    assert_eq!(
+        format_description!("[ordinal padding:space][ordinal padding:zero][ordinal padding:none]"),
+        &[
+            BorrowedFormatItem::Component(Component::Ordinal(modifier!(Ordinal {
+                padding: Padding::Space,
+            }))),
+            BorrowedFormatItem::Component(Component::Ordinal(modifier!(Ordinal {
+                padding: Padding::Zero,
+            }))),
+            BorrowedFormatItem::Component(Component::Ordinal(modifier!(Ordinal {
+                padding: Padding::None,
+            }))),
+        ]
+    );
+    assert_eq!(
+        format_description!("[month repr:numerical]"),
+        &[BorrowedFormatItem::Component(Component::Month(modifier!(
+            Month {
+                repr: MonthRepr::Numerical,
+                padding: Padding::Zero,
+            }
+        )))]
+    );
+    assert_eq!(
+        format_description!("[week_number repr:iso ]"),
+        &[BorrowedFormatItem::Component(Component::WeekNumber(
+            modifier!(WeekNumber {
+                padding: Padding::Zero,
+                repr: WeekNumberRepr::Iso,
+            })
+        ))]
+    );
+    assert_eq!(
+        format_description!("[weekday repr:long one_indexed:true]"),
+        &[BorrowedFormatItem::Component(Component::Weekday(
+            modifier!(Weekday {
+                repr: WeekdayRepr::Long,
+                one_indexed: true,
+            })
+        ))]
+    );
+    assert_eq!(
+        format_description!("[year repr:full base:calendar]"),
+        &[BorrowedFormatItem::Component(Component::Year(modifier!(
+            Year {
+                repr: YearRepr::Full,
+                iso_week_based: false,
+                padding: Padding::Zero,
+                sign_is_mandatory: false,
+            }
+        )))]
+    );
+    assert_eq!(
+        format_description!("[[ "),
+        &[
+            BorrowedFormatItem::Literal(b"["),
+            BorrowedFormatItem::Literal(b" ")
+        ]
+    );
+    assert_eq!(
+        format_description!("[ignore count:2]"),
+        &[BorrowedFormatItem::Component(Component::Ignore(
+            Ignore::count(NonZeroU16::new(2).expect("2 is not zero"))
+        ))]
+    );
+    assert_eq!(
+        format_description!("[unix_timestamp precision:nanosecond sign:mandatory]"),
+        &[BorrowedFormatItem::Component(Component::UnixTimestamp(
+            modifier!(UnixTimestamp {
+                precision: UnixTimestampPrecision::Nanosecond,
+                sign_is_mandatory: true,
+            })
+        ))]
+    );
+    assert_eq!(
+        format_description!("[end]"),
+        &[BorrowedFormatItem::Component(Component::End(modifier!(
+            End
+        )))]
+    );
+}
+
+#[rstest]
+fn date_coverage() {
+    assert_eq!(Ok(date!(2000 - 001)), Date::from_ordinal_date(2000, 1));
+    assert_eq!(Ok(date!(2019-W 01-1)), Date::from_ordinal_date(2018, 365));
+    assert_eq!(Ok(date!(2021-W 52-6)), Date::from_ordinal_date(2022, 1));
+    assert_eq!(Ok(date!(2021-W 34-5)), Date::from_ordinal_date(2021, 239));
+}
+
+#[rstest]
+fn time_coverage() {
+    assert_eq!(time!(12 AM), Time::MIDNIGHT);
+    assert_eq!(Ok(time!(12 PM)), Time::from_hms(12, 0, 0));
+}
diff --git a/tests/main.rs b/tests/main.rs
new file mode 100644
index 000000000..bada9e1cb
--- /dev/null
+++ b/tests/main.rs
@@ -0,0 +1,156 @@
+#![allow(
+    clippy::missing_const_for_fn, // irrelevant for tests
+    clippy::std_instead_of_core, // irrelevant for tests
+    clippy::std_instead_of_alloc, // irrelevant for tests
+    clippy::alloc_instead_of_core, // irrelevant for tests
+)]
+
+#[cfg(not(all(
+    feature = "default",
+    feature = "alloc",
+    feature = "formatting",
+    feature = "large-dates",
+    feature = "local-offset",
+    feature = "macros",
+    feature = "parsing",
+    feature = "quickcheck",
+    feature = "serde-human-readable",
+    feature = "serde-well-known",
+    feature = "std",
+    feature = "rand",
+    feature = "serde",
+)))]
+#[test]
+fn run_with_all_features() -> Result<(), Box<dyn std::error::Error>> {
+    #[derive(Debug)]
+    struct Error(std::process::ExitStatus);
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl std::error::Error for Error {}
+
+    let status = std::process::Command::new("cargo")
+        .args(["test", "--all-features"])
+        .status()?;
+
+    return if status.success() {
+        Ok(())
+    } else {
+        Err(Box::new(Error(status)))
+    };
+
+    // Intentionally unreachable. This is to show the user a warning when they don't provide
+    // `--all-features`.
+    "Tests must be run with `--all-features`. Because the flag was not provided, `cargo test \
+     --all-features` is run.";
+}
+
+macro_rules! require_all_features {
+    ($($x:item)*) => {$(
+        #[cfg(all(
+            feature = "default",
+            feature = "alloc",
+            feature = "formatting",
+            feature = "large-dates",
+            feature = "local-offset",
+            feature = "macros",
+            feature = "parsing",
+            feature = "quickcheck",
+            feature = "serde-human-readable",
+            feature = "serde-well-known",
+            feature = "std",
+            feature = "rand",
+            feature = "serde",
+        ))]
+        $x
+    )*};
+}
+
+require_all_features! {
+    use std::sync::Mutex;
+
+    /// A lock to ensure that certain tests don't run in parallel, which could lead to a test
+    /// unexpectedly failing.
+    static SOUNDNESS_LOCK: Mutex<()> = Mutex::new(());
+
+    // Required by the crate for technical reasons.
+    #[allow(clippy::single_component_path_imports)]
+    use rstest_reuse;
+
+    /// Construct a non-exhaustive modifier.
+    macro_rules! modifier {
+        ($name:ident $({
+            $($field:ident $(: $value:expr)?),* $(,)?
+        })?) => {{
+            // Needed for when there are no fields.
+            #[allow(unused_mut)]
+            let mut value = ::time::format_description::modifier::$name::default();
+            $($(value.$field = modifier!(@value $field $($value)?);)*)?
+            value
+        }};
+
+        (@value $field:ident) => ($field);
+        (@value $field:ident $value:expr) => ($value);
+    }
+
+    /// Assert that the given expression panics.
+    macro_rules! assert_panic {
+        ($($x:tt)*) => {
+            assert!(std::panic::catch_unwind(|| {
+                $($x)*
+            })
+            .is_err())
+        }
+    }
+
+    /// `assert_eq!` or `assert_ne!` depending on the value of `$is_eq`.
+    ///
+    /// This provides better diagnostics than `assert_eq!($left == $right, $is_eq)`.
+    macro_rules! assert_eq_ne {
+        ($left:expr, $right:expr, $is_eq:expr $(, $($rest:tt)*)?) => {{
+            if $is_eq {
+                assert_eq!($left, $right $(, $($rest)*)?);
+            } else {
+                assert_ne!($left, $right $(, $($rest)*)?);
+            }
+        }}
+    }
+
+    mod date;
+    mod derives;
+    mod duration;
+    mod error;
+    mod ext;
+    mod format_description;
+    mod formatting;
+    mod instant;
+    mod macros;
+    mod meta;
+    mod month;
+    mod offset_date_time;
+    mod parse_format_description;
+    mod parsed;
+    mod parsing;
+    mod primitive_date_time;
+    #[path = "quickcheck.rs"]
+    mod quickcheck_mod;
+    mod rand;
+    mod serde;
+    mod serde_helpers;
+    mod time;
+    mod utc_offset;
+    mod util;
+    mod weekday;
+
+    #[cfg(__ui_tests)]
+    #[test]
+    fn compile_fail() {
+        let tests = trybuild::TestCases::new();
+        // Path is relative from `time/Cargo.toml`.
+        tests.compile_fail("../tests/compile-fail/*.rs");
+    }
+}
diff --git a/tests/meta.rs b/tests/meta.rs
new file mode 100644
index 000000000..ded83b616
--- /dev/null
+++ b/tests/meta.rs
@@ -0,0 +1,1090 @@
+// Prefer runtime checks if possible, as otherwise tests can't be run at all if something is
+// changed.
+
+use std::borrow::Borrow;
+use std::error::Error as StdError;
+use std::fmt::{Debug, Display};
+use std::hash::Hash;
+use std::iter::Sum;
+use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+use std::panic::{RefUnwindSafe, UnwindSafe};
+use std::time::{Duration as StdDuration, Instant as StdInstant, SystemTime};
+
+use quickcheck::Arbitrary;
+use rand::distributions::{Distribution, Standard};
+use serde::{Deserialize, Serialize};
+use time::format_description::well_known::iso8601;
+use time::format_description::{modifier, well_known, BorrowedFormatItem, Component};
+use time::formatting::Formattable;
+use time::parsing::{Parsable, Parsed};
+#[allow(deprecated)]
+use time::Instant;
+use time::{
+    error, ext, Date, Duration, Error, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset,
+    Weekday,
+};
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn alignment() {
+    macro_rules! assert_alignment {
+        ($t:ty, $alignment:expr) => {
+            let alignment = $alignment;
+            assert_eq!(
+                ::core::mem::align_of::<$t>(),
+                alignment,
+                "alignment of `{}` was {}",
+                stringify!($t),
+                alignment,
+            );
+        };
+    }
+
+    assert_alignment!(Date, 4);
+    assert_alignment!(Duration, 8);
+    assert_alignment!(OffsetDateTime, 4);
+    assert_alignment!(PrimitiveDateTime, 4);
+    assert_alignment!(Time, 4);
+    assert_alignment!(UtcOffset, 1);
+    assert_alignment!(error::ComponentRange, 8);
+    assert_alignment!(error::ConversionRange, 1);
+    assert_alignment!(error::DifferentVariant, 1);
+    assert_alignment!(error::IndeterminateOffset, 1);
+    assert_alignment!(modifier::Day, 1);
+    assert_alignment!(modifier::Hour, 1);
+    assert_alignment!(modifier::Minute, 1);
+    assert_alignment!(modifier::Month, 1);
+    assert_alignment!(modifier::OffsetHour, 1);
+    assert_alignment!(modifier::OffsetMinute, 1);
+    assert_alignment!(modifier::OffsetSecond, 1);
+    assert_alignment!(modifier::Ordinal, 1);
+    assert_alignment!(modifier::Period, 1);
+    assert_alignment!(modifier::Second, 1);
+    assert_alignment!(modifier::Subsecond, 1);
+    assert_alignment!(modifier::WeekNumber, 1);
+    assert_alignment!(modifier::Weekday, 1);
+    assert_alignment!(modifier::Year, 1);
+    assert_alignment!(well_known::Rfc2822, 1);
+    assert_alignment!(well_known::Rfc3339, 1);
+    assert_alignment!(
+        well_known::Iso8601<{ iso8601::Config::DEFAULT.encode() }>,
+        1
+    );
+    assert_alignment!(iso8601::Config, 1);
+    assert_alignment!(iso8601::DateKind, 1);
+    assert_alignment!(iso8601::FormattedComponents, 1);
+    assert_alignment!(iso8601::OffsetPrecision, 1);
+    assert_alignment!(iso8601::TimePrecision, 1);
+    assert_alignment!(Parsed, ::core::mem::align_of::<u128>());
+    assert_alignment!(Month, 1);
+    assert_alignment!(Weekday, 1);
+    assert_alignment!(Error, 8);
+    assert_alignment!(error::Format, 8);
+    assert_alignment!(error::InvalidFormatDescription, 8);
+    assert_alignment!(error::Parse, 8);
+    assert_alignment!(error::ParseFromDescription, 8);
+    assert_alignment!(error::TryFromParsed, 8);
+    assert_alignment!(Component, 2);
+    assert_alignment!(BorrowedFormatItem<'_>, 8);
+    assert_alignment!(modifier::MonthRepr, 1);
+    assert_alignment!(modifier::Padding, 1);
+    assert_alignment!(modifier::SubsecondDigits, 1);
+    assert_alignment!(modifier::WeekNumberRepr, 1);
+    assert_alignment!(modifier::WeekdayRepr, 1);
+    assert_alignment!(modifier::YearRepr, 1);
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn size() {
+    macro_rules! assert_size {
+        ($t:ty, $size:literal, $opt_size:literal) => {
+            assert!(
+                ::core::mem::size_of::<$t>() <= $size,
+                concat!("size of `{}` used to be ", $size, ", but is now {}"),
+                stringify!($t),
+                ::core::mem::size_of::<$t>(),
+            );
+            assert!(
+                ::core::mem::size_of::<Option<$t>>() <= $opt_size,
+                concat!(
+                    "size of `Option<{}>` used to be ",
+                    $opt_size,
+                    ", but is now {}"
+                ),
+                stringify!($t),
+                ::core::mem::size_of::<Option<$t>>(),
+            );
+        };
+    }
+
+    assert_size!(Date, 4, 4);
+    assert_size!(Duration, 16, 16);
+    assert_size!(OffsetDateTime, 16, 16);
+    assert_size!(PrimitiveDateTime, 12, 12);
+    assert_size!(Time, 8, 8);
+    assert_size!(UtcOffset, 3, 4);
+    assert_size!(error::ComponentRange, 48, 48);
+    assert_size!(error::ConversionRange, 0, 1);
+    assert_size!(error::DifferentVariant, 0, 1);
+    assert_size!(error::IndeterminateOffset, 0, 1);
+    assert_size!(modifier::Day, 1, 1);
+    assert_size!(modifier::Hour, 2, 2);
+    assert_size!(modifier::Minute, 1, 1);
+    assert_size!(modifier::Month, 3, 3);
+    assert_size!(modifier::OffsetHour, 2, 2);
+    assert_size!(modifier::OffsetMinute, 1, 1);
+    assert_size!(modifier::OffsetSecond, 1, 1);
+    assert_size!(modifier::Ordinal, 1, 1);
+    assert_size!(modifier::Period, 2, 2);
+    assert_size!(modifier::Second, 1, 1);
+    assert_size!(modifier::Subsecond, 1, 1);
+    assert_size!(modifier::WeekNumber, 2, 2);
+    assert_size!(modifier::Weekday, 3, 3);
+    assert_size!(modifier::Year, 4, 4);
+    assert_size!(well_known::Rfc2822, 0, 1);
+    assert_size!(well_known::Rfc3339, 0, 1);
+    assert_size!(
+        well_known::Iso8601<{ iso8601::Config::DEFAULT.encode() }>,
+        0,
+        1
+    );
+    assert_size!(iso8601::Config, 7, 7);
+    assert_size!(iso8601::DateKind, 1, 1);
+    assert_size!(iso8601::FormattedComponents, 1, 1);
+    assert_size!(iso8601::OffsetPrecision, 1, 1);
+    assert_size!(iso8601::TimePrecision, 2, 2);
+    assert_size!(Parsed, 56, 56);
+    assert_size!(Month, 1, 1);
+    assert_size!(Weekday, 1, 1);
+    assert_size!(Error, 56, 56);
+    assert_size!(error::Format, 24, 24);
+    assert_size!(error::InvalidFormatDescription, 48, 48);
+    assert_size!(error::Parse, 48, 48);
+    assert_size!(error::ParseFromDescription, 24, 24);
+    assert_size!(error::TryFromParsed, 48, 48);
+    assert_size!(Component, 6, 6); // TODO Size is 4 starting with rustc 1.71.
+    assert_size!(BorrowedFormatItem<'_>, 24, 24);
+    assert_size!(modifier::MonthRepr, 1, 1);
+    assert_size!(modifier::Padding, 1, 1);
+    assert_size!(modifier::SubsecondDigits, 1, 1);
+    assert_size!(modifier::WeekNumberRepr, 1, 1);
+    assert_size!(modifier::WeekdayRepr, 1, 1);
+    assert_size!(modifier::YearRepr, 1, 1);
+}
+
+macro_rules! assert_obj_safe {
+    ($($xs:path),+ $(,)?) => {
+        $(const _: Option<&dyn $xs> = None;)+
+    };
+}
+
+assert_obj_safe!(ext::NumericalDuration);
+assert_obj_safe!(ext::NumericalStdDuration);
+// `Parsable` is not object safe.
+// `Formattable` is not object safe.
+
+macro_rules! assert_impl {
+    ($(#[$meta:meta])* $($(@$lifetimes:lifetime),+ ;)? $type:ty: $($trait:path),+ $(,)?) => {
+        $(#[$meta])*
+        const _: fn() = || {
+            fn assert_impl_all<$($($lifetimes,)+)? T: ?Sized $(+ $trait)+>() {}
+            assert_impl_all::<$type>();
+        };
+    };
+}
+
+assert_impl! { @'a; Date:
+    Add<Duration, Output = Date>,
+    Add<StdDuration, Output = Date>,
+    AddAssign<Duration>,
+    AddAssign<StdDuration>,
+    Arbitrary,
+    Clone,
+    Debug,
+    Deserialize<'a>,
+    Display,
+    Hash,
+    Ord,
+    PartialEq<Date>,
+    PartialOrd<Date>,
+    Serialize,
+    Sub<Date, Output = Duration>,
+    Sub<Duration, Output = Date>,
+    Sub<StdDuration, Output = Date>,
+    SubAssign<Duration>,
+    SubAssign<StdDuration>,
+    TryFrom<Parsed, Error = error::TryFromParsed>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; Duration:
+    Add<Duration, Output = Duration>,
+    Add<StdDuration, Output = Duration>,
+    AddAssign<Duration>,
+    AddAssign<StdDuration>,
+    Arbitrary,
+    Clone,
+    Debug,
+    Default,
+    Deserialize<'a>,
+    Div<Duration, Output = f64>,
+    Div<StdDuration, Output = f64>,
+    Div<f32, Output = Duration>,
+    Div<f64, Output = Duration>,
+    Div<i16, Output = Duration>,
+    Div<i32, Output = Duration>,
+    Div<i8, Output = Duration>,
+    Div<u16, Output = Duration>,
+    Div<u32, Output = Duration>,
+    Div<u8, Output = Duration>,
+    DivAssign<f32>,
+    DivAssign<f64>,
+    DivAssign<i16>,
+    DivAssign<i32>,
+    DivAssign<i8>,
+    DivAssign<u16>,
+    DivAssign<u32>,
+    DivAssign<u8>,
+    Hash,
+    Mul<f32, Output = Duration>,
+    Mul<f64, Output = Duration>,
+    Mul<i16, Output = Duration>,
+    Mul<i32, Output = Duration>,
+    Mul<i8, Output = Duration>,
+    Mul<u16, Output = Duration>,
+    Mul<u32, Output = Duration>,
+    Mul<u8, Output = Duration>,
+    MulAssign<f32>,
+    MulAssign<f64>,
+    MulAssign<i16>,
+    MulAssign<i32>,
+    MulAssign<i8>,
+    MulAssign<u16>,
+    MulAssign<u32>,
+    MulAssign<u8>,
+    Neg<Output = Duration>,
+    Ord,
+    PartialEq<Duration>,
+    PartialEq<StdDuration>,
+    PartialOrd<Duration>,
+    PartialOrd<StdDuration>,
+    Serialize,
+    Sub<Duration, Output = Duration>,
+    Sub<StdDuration, Output = Duration>,
+    SubAssign<Duration>,
+    SubAssign<StdDuration>,
+    Sum<&'a Duration>,
+    Sum<Duration>,
+    TryFrom<StdDuration, Error = error::ConversionRange>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { #[allow(deprecated)] Instant:
+    Add<Duration, Output = Instant>,
+    Add<StdDuration, Output = Instant>,
+    AddAssign<Duration>,
+    AddAssign<StdDuration>,
+    AsRef<StdInstant>,
+    Borrow<StdInstant>,
+    Clone,
+    Debug,
+    From<StdInstant>,
+    Hash,
+    Ord,
+    PartialEq<Instant>,
+    PartialEq<StdInstant>,
+    PartialOrd<Instant>,
+    PartialOrd<StdInstant>,
+    Sub<Duration, Output = Instant>,
+    Sub<StdDuration, Output = Instant>,
+    Sub<Instant, Output = Duration>,
+    Sub<StdInstant, Output = Duration>,
+    SubAssign<Duration>,
+    SubAssign<StdDuration>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; OffsetDateTime:
+    Add<Duration, Output = OffsetDateTime>,
+    Add<StdDuration, Output = OffsetDateTime>,
+    AddAssign<Duration>,
+    AddAssign<StdDuration>,
+    Arbitrary,
+    Clone,
+    Debug,
+    Deserialize<'a>,
+    Display,
+    From<SystemTime>,
+    Hash,
+    Ord,
+    PartialEq<OffsetDateTime>,
+    PartialEq<SystemTime>,
+    PartialOrd<OffsetDateTime>,
+    PartialOrd<SystemTime>,
+    Serialize,
+    Sub<OffsetDateTime, Output = Duration>,
+    Sub<SystemTime, Output = Duration>,
+    Sub<Duration, Output = OffsetDateTime>,
+    Sub<StdDuration, Output = OffsetDateTime>,
+    SubAssign<Duration>,
+    SubAssign<StdDuration>,
+    TryFrom<Parsed, Error = error::TryFromParsed>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; PrimitiveDateTime:
+    Add<Duration, Output = PrimitiveDateTime>,
+    Add<StdDuration, Output = PrimitiveDateTime>,
+    AddAssign<Duration>,
+    AddAssign<StdDuration>,
+    Arbitrary,
+    Clone,
+    Debug,
+    Deserialize<'a>,
+    Display,
+    Hash,
+    Ord,
+    PartialEq<PrimitiveDateTime>,
+    PartialOrd<PrimitiveDateTime>,
+    Serialize,
+    Sub<Duration, Output = PrimitiveDateTime>,
+    Sub<StdDuration, Output = PrimitiveDateTime>,
+    Sub<PrimitiveDateTime>,
+    SubAssign<Duration>,
+    SubAssign<StdDuration>,
+    TryFrom<Parsed, Error = error::TryFromParsed>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; Time:
+    Add<Duration, Output = Time>,
+    Add<StdDuration, Output = Time>,
+    AddAssign<Duration>,
+    AddAssign<StdDuration>,
+    Arbitrary,
+    Clone,
+    Debug,
+    Deserialize<'a>,
+    Display,
+    Hash,
+    Ord,
+    PartialEq<Time>,
+    PartialOrd<Time>,
+    Serialize,
+    Sub<Duration, Output = Time>,
+    Sub<StdDuration, Output = Time>,
+    Sub<Time, Output = Duration>,
+    SubAssign<Duration>,
+    SubAssign<StdDuration>,
+    TryFrom<Parsed, Error = error::TryFromParsed>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; UtcOffset:
+    Arbitrary,
+    Clone,
+    Debug,
+    Deserialize<'a>,
+    Display,
+    Hash,
+    Neg,
+    Ord,
+    PartialEq<UtcOffset>,
+    PartialOrd<UtcOffset>,
+    Serialize,
+    TryFrom<Parsed, Error = error::TryFromParsed>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { error::ComponentRange:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    serde::de::Expected,
+    Hash,
+    PartialEq<error::ComponentRange>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    TryFrom<error::TryFromParsed, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { error::ConversionRange:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    PartialEq<error::ConversionRange>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { error::DifferentVariant:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    PartialEq<error::DifferentVariant>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { error::IndeterminateOffset:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    PartialEq<error::IndeterminateOffset>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Day:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Day>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Hour:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Hour>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Minute:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Minute>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Month:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Month>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::OffsetHour:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::OffsetHour>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::OffsetMinute:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::OffsetMinute>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::OffsetSecond:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::OffsetSecond>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Ordinal:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Ordinal>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Period:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Period>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Second:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Second>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Subsecond:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Subsecond>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::WeekNumber:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::WeekNumber>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Weekday:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Weekday>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Year:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Year>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { well_known::Rfc2822:
+    Clone,
+    Debug,
+    PartialEq<well_known::Rfc2822>,
+    Copy,
+    Eq,
+    Formattable,
+    Parsable,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { well_known::Rfc3339:
+    Clone,
+    Debug,
+    PartialEq<well_known::Rfc3339>,
+    Copy,
+    Eq,
+    Formattable,
+    Parsable,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { well_known::Iso8601::<{ iso8601::Config::DEFAULT.encode() }>:
+    Clone,
+    Debug,
+    PartialEq<well_known::Iso8601<{ iso8601::Config::DEFAULT.encode() }>>,
+    Copy,
+    Eq,
+    Formattable,
+    Parsable,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { iso8601::Config:
+    Debug,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { iso8601::DateKind:
+    Clone,
+    Debug,
+    PartialEq<iso8601::DateKind>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { iso8601::FormattedComponents:
+    Clone,
+    Debug,
+    PartialEq<iso8601::FormattedComponents>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { iso8601::OffsetPrecision:
+    Clone,
+    Debug,
+    PartialEq<iso8601::OffsetPrecision>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { iso8601::TimePrecision:
+    Clone,
+    Debug,
+    PartialEq<iso8601::TimePrecision>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { Parsed:
+    Clone,
+    Debug,
+    Copy,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; Month:
+    Arbitrary,
+    Clone,
+    Debug,
+    Deserialize<'a>,
+    Display,
+    Hash,
+    PartialEq<Month>,
+    TryFrom<u8, Error = error::ComponentRange>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; Weekday:
+    Arbitrary,
+    Clone,
+    Debug,
+    Deserialize<'a>,
+    Display,
+    Hash,
+    PartialEq<Weekday>,
+    Serialize,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { Error:
+    Debug,
+    Display,
+    StdError,
+    From<error::ComponentRange>,
+    From<error::ConversionRange>,
+    From<error::DifferentVariant>,
+    From<error::Format>,
+    From<error::IndeterminateOffset>,
+    From<error::InvalidFormatDescription>,
+    From<error::Parse>,
+    From<error::ParseFromDescription>,
+    From<error::TryFromParsed>,
+    Send,
+    Sync,
+    Unpin,
+}
+assert_impl! { error::Format:
+    Debug,
+    Display,
+    StdError,
+    From<std::io::Error>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    Send,
+    Sync,
+    Unpin,
+}
+assert_impl! { error::InvalidFormatDescription:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    PartialEq<error::InvalidFormatDescription>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { error::Parse:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    From<error::ParseFromDescription>,
+    From<error::TryFromParsed>,
+    PartialEq<error::Parse>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { error::ParseFromDescription:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    PartialEq<error::ParseFromDescription>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    TryFrom<error::Parse, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { error::TryFromParsed:
+    Clone,
+    Debug,
+    Display,
+    StdError,
+    From<error::ComponentRange>,
+    PartialEq<error::TryFromParsed>,
+    TryFrom<Error, Error = error::DifferentVariant>,
+    TryFrom<error::Parse, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; Component:
+    Clone,
+    Debug,
+    PartialEq<Component>,
+    PartialEq<BorrowedFormatItem<'a>>,
+    TryFrom<BorrowedFormatItem<'a>, Error = error::DifferentVariant>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; BorrowedFormatItem<'_>:
+    Clone,
+    Debug,
+    From<&'a [BorrowedFormatItem<'a>]>,
+    From<Component>,
+    PartialEq<&'a [BorrowedFormatItem<'a>]>,
+    PartialEq<Component>,
+    PartialEq<BorrowedFormatItem<'a>>,
+    Eq,
+    Formattable,
+    Parsable,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { @'a; &[BorrowedFormatItem<'_>]:
+    PartialEq<BorrowedFormatItem<'a>>,
+    TryFrom<BorrowedFormatItem<'a>, Error = error::DifferentVariant>,
+}
+assert_impl! { modifier::MonthRepr:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::MonthRepr>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::Padding:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::Padding>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::SubsecondDigits:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::SubsecondDigits>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::WeekNumberRepr:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::WeekNumberRepr>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::WeekdayRepr:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::WeekdayRepr>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { modifier::YearRepr:
+    Clone,
+    Debug,
+    Default,
+    PartialEq<modifier::YearRepr>,
+    Copy,
+    Eq,
+    RefUnwindSafe,
+    Send,
+    Sync,
+    Unpin,
+    UnwindSafe,
+}
+assert_impl! { Standard:
+    Distribution<Date>,
+    Distribution<Duration>,
+    Distribution<OffsetDateTime>,
+    Distribution<PrimitiveDateTime>,
+    Distribution<Time>,
+    Distribution<UtcOffset>,
+    Distribution<Month>,
+    Distribution<Weekday>,
+}
+assert_impl! { StdDuration:
+    Add<Duration, Output = Duration>,
+    AddAssign<Duration>,
+    Div<Duration, Output = f64>,
+    PartialEq<Duration>,
+    PartialOrd<Duration>,
+    Sub<Duration, Output = Duration>,
+    SubAssign<Duration>,
+    TryFrom<Duration>,
+}
+assert_impl! { #[allow(deprecated)] StdInstant:
+    Add<Duration, Output = StdInstant>,
+    AddAssign<Duration>,
+    Sub<Duration, Output = StdInstant>,
+    SubAssign<Duration>,
+    PartialEq<Instant>,
+    PartialOrd<Instant>,
+    From<Instant>,
+    Sub<Instant>,
+}
+assert_impl! { SystemTime:
+    Add<Duration, Output = SystemTime>,
+    AddAssign<Duration>,
+    Sub<Duration, Output = SystemTime>,
+    SubAssign<Duration>,
+    From<OffsetDateTime>,
+    PartialEq<OffsetDateTime>,
+    PartialOrd<OffsetDateTime>,
+    Sub<OffsetDateTime>,
+}
+assert_impl! { i8:
+    Mul<Duration>,
+}
+assert_impl! { i16:
+    Mul<Duration>,
+}
+assert_impl! { i32:
+    Mul<Duration>,
+}
+assert_impl! { u8:
+    Mul<Duration>,
+    From<Month>,
+}
+assert_impl! { u16:
+    Mul<Duration>,
+}
+assert_impl! { u32:
+    Mul<Duration>,
+}
+assert_impl! { f32:
+    Mul<Duration>,
+}
+assert_impl! { f64:
+    Mul<Duration>,
+}
diff --git a/tests/month.rs b/tests/month.rs
new file mode 100644
index 000000000..867241627
--- /dev/null
+++ b/tests/month.rs
@@ -0,0 +1,178 @@
+use rstest::rstest;
+use time::Month::{self, *};
+
+#[rstest]
+#[case(January, December)]
+#[case(February, January)]
+#[case(March, February)]
+#[case(April, March)]
+#[case(May, April)]
+#[case(June, May)]
+#[case(July, June)]
+#[case(August, July)]
+#[case(September, August)]
+#[case(October, September)]
+#[case(November, October)]
+#[case(December, November)]
+fn previous(#[case] month: Month, #[case] expected: Month) {
+    assert_eq!(month.previous(), expected);
+}
+
+#[rstest]
+#[case(January, February)]
+#[case(February, March)]
+#[case(March, April)]
+#[case(April, May)]
+#[case(May, June)]
+#[case(June, July)]
+#[case(July, August)]
+#[case(August, September)]
+#[case(September, October)]
+#[case(October, November)]
+#[case(November, December)]
+#[case(December, January)]
+fn next(#[case] month: Month, #[case] expected: Month) {
+    assert_eq!(month.next(), expected);
+}
+
+#[rstest]
+#[case(January, 0, January)]
+#[case(January, 1, February)]
+#[case(January, 2, March)]
+#[case(January, 3, April)]
+#[case(January, 4, May)]
+#[case(January, 5, June)]
+#[case(January, 6, July)]
+#[case(January, 7, August)]
+#[case(January, 8, September)]
+#[case(January, 9, October)]
+#[case(January, 10, November)]
+#[case(January, 11, December)]
+#[case(December, 0, December)]
+#[case(December, 1, January)]
+#[case(December, 2, February)]
+#[case(December, 3, March)]
+#[case(December, 4, April)]
+#[case(December, 5, May)]
+#[case(December, 6, June)]
+#[case(December, 7, July)]
+#[case(December, 8, August)]
+#[case(December, 9, September)]
+#[case(December, 10, October)]
+#[case(December, 11, November)]
+#[case(January, 12, January)]
+#[case(January, u8::MAX, April)]
+#[case(December, 12, December)]
+#[case(December, u8::MAX, March)]
+fn nth_next(#[case] month: Month, #[case] n: u8, #[case] expected: Month) {
+    assert_eq!(month.nth_next(n), expected);
+}
+
+#[rstest]
+#[case(January, 0, January)]
+#[case(January, 1, December)]
+#[case(January, 2, November)]
+#[case(January, 3, October)]
+#[case(January, 4, September)]
+#[case(January, 5, August)]
+#[case(January, 6, July)]
+#[case(January, 7, June)]
+#[case(January, 8, May)]
+#[case(January, 9, April)]
+#[case(January, 10, March)]
+#[case(January, 11, February)]
+#[case(December, 0, December)]
+#[case(December, 1, November)]
+#[case(December, 2, October)]
+#[case(December, 3, September)]
+#[case(December, 4, August)]
+#[case(December, 5, July)]
+#[case(December, 6, June)]
+#[case(December, 7, May)]
+#[case(December, 8, April)]
+#[case(December, 9, March)]
+#[case(December, 10, February)]
+#[case(December, 11, January)]
+#[case(January, 12, January)]
+#[case(January, u8::MAX, October)]
+#[case(December, 12, December)]
+#[case(December, u8::MAX, September)]
+fn nth_prev(#[case] month: Month, #[case] n: u8, #[case] expected: Month) {
+    assert_eq!(month.nth_prev(n), expected);
+}
+
+#[rstest]
+#[case(January, "January")]
+#[case(February, "February")]
+#[case(March, "March")]
+#[case(April, "April")]
+#[case(May, "May")]
+#[case(June, "June")]
+#[case(July, "July")]
+#[case(August, "August")]
+#[case(September, "September")]
+#[case(October, "October")]
+#[case(November, "November")]
+#[case(December, "December")]
+fn display(#[case] month: Month, #[case] expected: &str) {
+    assert_eq!(month.to_string(), expected);
+}
+
+#[rstest]
+#[case("January", Ok(January))]
+#[case("February", Ok(February))]
+#[case("March", Ok(March))]
+#[case("April", Ok(April))]
+#[case("May", Ok(May))]
+#[case("June", Ok(June))]
+#[case("July", Ok(July))]
+#[case("August", Ok(August))]
+#[case("September", Ok(September))]
+#[case("October", Ok(October))]
+#[case("November", Ok(November))]
+#[case("December", Ok(December))]
+#[case("foo", Err(time::error::InvalidVariant))]
+fn from_str(#[case] s: &str, #[case] expected: Result<Month, time::error::InvalidVariant>) {
+    assert_eq!(s.parse::<Month>(), expected);
+}
+
+#[rstest]
+#[case(January, 1)]
+#[case(February, 2)]
+#[case(March, 3)]
+#[case(April, 4)]
+#[case(May, 5)]
+#[case(June, 6)]
+#[case(July, 7)]
+#[case(August, 8)]
+#[case(September, 9)]
+#[case(October, 10)]
+#[case(November, 11)]
+#[case(December, 12)]
+fn to_u8(#[case] month: Month, #[case] expected: u8) {
+    assert_eq!(u8::from(month), expected);
+}
+
+#[rstest]
+#[case(1, January)]
+#[case(2, February)]
+#[case(3, March)]
+#[case(4, April)]
+#[case(5, May)]
+#[case(6, June)]
+#[case(7, July)]
+#[case(8, August)]
+#[case(9, September)]
+#[case(10, October)]
+#[case(11, November)]
+#[case(12, December)]
+fn try_from_u8_success(#[case] input: u8, #[case] expected: Month) {
+    assert_eq!(Month::try_from(input), Ok(expected));
+}
+
+#[rstest]
+#[case(0)]
+#[case(13)]
+fn try_from_u8_error(#[case] input: u8) {
+    assert!(matches!(Month::try_from(input), Err(err) if err.name() == "month"));
+}
diff --git a/tests/offset_date_time.rs b/tests/offset_date_time.rs
new file mode 100644
index 000000000..29b2eb4fd
--- /dev/null
+++ b/tests/offset_date_time.rs
@@ -0,0 +1,1309 @@
+use std::cmp::Ordering;
+use std::time::{Duration as StdDuration, SystemTime};
+
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::{date, datetime, offset, time};
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Weekday};
+
+#[test]
+fn new_utc() {
+    let dt = OffsetDateTime::new_utc(date!(2023 - 12 - 18), time!(10:13:44.250 AM));
+    assert_eq!(dt.year(), 2023);
+    assert_eq!(dt.millisecond(), 250);
+    assert_eq!(dt.offset(), offset!(UTC));
+}
+
+#[test]
+fn new_in_offset() {
+    let dt =
+        OffsetDateTime::new_in_offset(date!(2023 - 12 - 18), time!(10:13:44.250 AM), offset!(-4));
+    assert_eq!(dt.year(), 2023);
+    assert_eq!(dt.millisecond(), 250);
+    assert_eq!(dt.offset().whole_hours(), -4);
+}
+
+#[test]
+fn now_utc() {
+    assert!(OffsetDateTime::now_utc().year() >= 2019);
+    assert_eq!(OffsetDateTime::now_utc().offset(), offset!(UTC));
+}
+
+#[cfg_attr(miri, ignore)]
+#[test]
+fn now_local() {
+    use time::util::local_offset::*;
+
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
+
+    // Safety: Technically not sound. However, this is a test, and it's highly improbable that we
+    // will run into issues with setting an environment variable a few times.
+    unsafe { set_soundness(Soundness::Unsound) };
+    assert!(OffsetDateTime::now_local().is_ok());
+    // Safety: We're setting it back to sound.
+    unsafe { set_soundness(Soundness::Sound) };
+}
+
+#[test]
+fn to_offset() {
+    assert_eq!(
+        datetime!(2000-01-01 0:00 UTC).to_offset(offset!(-1)).year(),
+        1999,
+    );
+
+    let sydney = datetime!(2000-01-01 0:00 +11);
+    let new_york = sydney.to_offset(offset!(-5));
+    let los_angeles = sydney.to_offset(offset!(-8));
+    assert_eq!(sydney.hour(), 0);
+    assert_eq!(sydney.day(), 1);
+    assert_eq!(new_york.hour(), 8);
+    assert_eq!(new_york.day(), 31);
+    assert_eq!(los_angeles.hour(), 5);
+    assert_eq!(los_angeles.day(), 31);
+
+    assert_eq!(
+        datetime!(0000-001 0:00 +0:00:02).to_offset(offset!(-0:00:59)),
+        datetime!(-0001-365 23:58:59 -0:00:59)
+    );
+
+    assert_eq!(
+        datetime!(0000-001 0:00 UTC).to_offset(offset!(UTC)),
+        datetime!(0000-001 0:00 UTC),
+    );
+}
+
+#[test]
+fn to_offset_panic() {
+    assert_panic!(PrimitiveDateTime::MAX.assume_utc().to_offset(offset!(+1)));
+    assert_panic!(PrimitiveDateTime::MIN.assume_utc().to_offset(offset!(-1)));
+}
+
+#[test]
+fn to_offset_invalid_regression() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00 +13).to_offset(offset!(-13)),
+        datetime!(2018-12-30 22:00:00 -13),
+    );
+}
+
+#[test]
+fn checked_to_offset() {
+    assert_eq!(
+        datetime!(2000-01-01 0:00 UTC)
+            .checked_to_offset(offset!(-1))
+            .map(|odt| odt.year()),
+        Some(1999),
+    );
+    assert_eq!(
+        PrimitiveDateTime::MAX
+            .assume_utc()
+            .checked_to_offset(offset!(+1)),
+        None
+    );
+    assert_eq!(
+        PrimitiveDateTime::MIN
+            .assume_utc()
+            .checked_to_offset(offset!(-1)),
+        None
+    );
+}
+
+#[test]
+fn from_unix_timestamp() {
+    assert_eq!(
+        OffsetDateTime::from_unix_timestamp(0),
+        Ok(OffsetDateTime::UNIX_EPOCH),
+    );
+    assert_eq!(
+        OffsetDateTime::from_unix_timestamp(1_546_300_800),
+        Ok(datetime!(2019-01-01 0:00 UTC)),
+    );
+}
+
+#[test]
+fn from_unix_timestamp_nanos() {
+    assert_eq!(
+        OffsetDateTime::from_unix_timestamp_nanos(0),
+        Ok(OffsetDateTime::UNIX_EPOCH),
+    );
+    assert_eq!(
+        OffsetDateTime::from_unix_timestamp_nanos(1_546_300_800_000_000_000),
+        Ok(datetime!(2019-01-01 0:00 UTC)),
+    );
+    assert!(OffsetDateTime::from_unix_timestamp_nanos(i128::MAX).is_err());
+}
+
+#[test]
+fn offset() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).offset(), offset!(UTC));
+    assert_eq!(datetime!(2019-01-01 0:00 +1).offset(), offset!(+1));
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC)
+            .to_offset(offset!(+1))
+            .offset(),
+        offset!(+1),
+    );
+}
+
+#[test]
+fn unix_timestamp() {
+    assert_eq!(OffsetDateTime::UNIX_EPOCH.unix_timestamp(), 0);
+    assert_eq!(
+        OffsetDateTime::UNIX_EPOCH
+            .to_offset(offset!(+1))
+            .unix_timestamp(),
+        0,
+    );
+    assert_eq!(datetime!(1970-01-01 0:00 -1).unix_timestamp(), 3_600);
+}
+
+#[test]
+fn unix_timestamp_nanos() {
+    assert_eq!(datetime!(1970-01-01 0:00 UTC).unix_timestamp_nanos(), 0);
+    assert_eq!(
+        datetime!(1970-01-01 1:00 UTC)
+            .to_offset(offset!(-1))
+            .unix_timestamp_nanos(),
+        3_600_000_000_000,
+    );
+}
+
+#[test]
+fn date() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).date(), date!(2019 - 01 - 01));
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC).to_offset(offset!(-1)).date(),
+        date!(2018 - 12 - 31),
+    );
+}
+
+#[test]
+fn time() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).time(), time!(0:00));
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC).to_offset(offset!(-1)).time(),
+        time!(23:00),
+    );
+}
+
+#[test]
+fn year() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).year(), 2019);
+    assert_eq!(
+        datetime!(2019-12-31 23:00 UTC)
+            .to_offset(offset!(+1))
+            .year(),
+        2020,
+    );
+    assert_eq!(datetime!(2020-01-01 0:00 UTC).year(), 2020);
+}
+
+#[test]
+fn month() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).month(), Month::January);
+    assert_eq!(
+        datetime!(2019-12-31 23:00 UTC)
+            .to_offset(offset!(+1))
+            .month(),
+        Month::January,
+    );
+}
+
+#[test]
+fn day() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).day(), 1);
+    assert_eq!(
+        datetime!(2019-12-31 23:00 UTC).to_offset(offset!(+1)).day(),
+        1,
+    );
+}
+
+#[test]
+fn ordinal() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).ordinal(), 1);
+    assert_eq!(
+        datetime!(2019-12-31 23:00 UTC)
+            .to_offset(offset!(+1))
+            .ordinal(),
+        1,
+    );
+}
+
+#[test]
+fn iso_week() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).iso_week(), 1);
+    assert_eq!(datetime!(2020-01-01 0:00 UTC).iso_week(), 1);
+    assert_eq!(datetime!(2020-12-31 0:00 UTC).iso_week(), 53);
+    assert_eq!(datetime!(2021-01-01 0:00 UTC).iso_week(), 53);
+}
+
+#[test]
+fn sunday_based_week() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).sunday_based_week(), 0);
+    assert_eq!(datetime!(2020-01-01 0:00 UTC).sunday_based_week(), 0);
+    assert_eq!(datetime!(2020-12-31 0:00 UTC).sunday_based_week(), 52);
+    assert_eq!(datetime!(2021-01-01 0:00 UTC).sunday_based_week(), 0);
+}
+
+#[test]
+fn monday_based_week() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).monday_based_week(), 0);
+    assert_eq!(datetime!(2020-01-01 0:00 UTC).monday_based_week(), 0);
+    assert_eq!(datetime!(2020-12-31 0:00 UTC).monday_based_week(), 52);
+    assert_eq!(datetime!(2021-01-01 0:00 UTC).monday_based_week(), 0);
+}
+
+#[test]
+fn to_calendar_date() {
+    assert_eq!(
+        datetime!(2019-01-02 0:00 UTC).to_calendar_date(),
+        (2019, Month::January, 2)
+    );
+}
+
+#[test]
+fn to_ordinal_date() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).to_ordinal_date(), (2019, 1));
+}
+
+#[test]
+fn to_iso_week_date() {
+    use Weekday::*;
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC).to_iso_week_date(),
+        (2019, 1, Tuesday)
+    );
+    assert_eq!(
+        datetime!(2019-10-04 0:00 UTC).to_iso_week_date(),
+        (2019, 40, Friday)
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00 UTC).to_iso_week_date(),
+        (2020, 1, Wednesday)
+    );
+    assert_eq!(
+        datetime!(2020-12-31 0:00 UTC).to_iso_week_date(),
+        (2020, 53, Thursday)
+    );
+    assert_eq!(
+        datetime!(2021-01-01 0:00 UTC).to_iso_week_date(),
+        (2020, 53, Friday)
+    );
+}
+
+#[test]
+fn weekday() {
+    use Weekday::*;
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).weekday(), Tuesday);
+    assert_eq!(datetime!(2019-02-01 0:00 UTC).weekday(), Friday);
+    assert_eq!(datetime!(2019-03-01 0:00 UTC).weekday(), Friday);
+}
+
+#[test]
+fn to_julian_day() {
+    assert_eq!(
+        datetime!(-999_999-01-01 0:00 UTC).to_julian_day(),
+        -363_521_074
+    );
+    assert_eq!(datetime!(-4713-11-24 0:00 UTC).to_julian_day(), 0);
+    assert_eq!(datetime!(2000-01-01 0:00 UTC).to_julian_day(), 2_451_545);
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).to_julian_day(), 2_458_485);
+    assert_eq!(datetime!(2019-12-31 0:00 UTC).to_julian_day(), 2_458_849);
+}
+
+#[test]
+fn to_hms() {
+    assert_eq!(datetime!(2020-01-01 1:02:03 UTC).to_hms(), (1, 2, 3));
+}
+
+#[test]
+fn to_hms_milli() {
+    assert_eq!(
+        datetime!(2020-01-01 1:02:03.004 UTC).to_hms_milli(),
+        (1, 2, 3, 4)
+    );
+}
+
+#[test]
+fn to_hms_micro() {
+    assert_eq!(
+        datetime!(2020-01-01 1:02:03.004_005 UTC).to_hms_micro(),
+        (1, 2, 3, 4_005)
+    );
+}
+
+#[test]
+fn to_hms_nano() {
+    assert_eq!(
+        datetime!(2020-01-01 1:02:03.004_005_006 UTC).to_hms_nano(),
+        (1, 2, 3, 4_005_006)
+    );
+}
+
+#[test]
+fn hour() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).hour(), 0);
+    assert_eq!(
+        datetime!(2019-01-01 23:59:59 UTC)
+            .to_offset(offset!(-2))
+            .hour(),
+        21,
+    );
+}
+
+#[test]
+fn minute() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).minute(), 0);
+    assert_eq!(
+        datetime!(2019-01-01 23:59:59 UTC)
+            .to_offset(offset!(+0:30))
+            .minute(),
+        29,
+    );
+}
+
+#[test]
+fn second() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).second(), 0);
+    assert_eq!(
+        datetime!(2019-01-01 23:59:59 UTC)
+            .to_offset(offset!(+0:00:30))
+            .second(),
+        29,
+    );
+}
+
+#[test]
+fn millisecond() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).millisecond(), 0);
+    assert_eq!(datetime!(2019-01-01 23:59:59.999 UTC).millisecond(), 999);
+}
+
+#[test]
+fn microsecond() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).microsecond(), 0);
+    assert_eq!(
+        datetime!(2019-01-01 23:59:59.999_999 UTC).microsecond(),
+        999_999,
+    );
+}
+
+#[test]
+fn nanosecond() {
+    assert_eq!(datetime!(2019-01-01 0:00 UTC).nanosecond(), 0);
+    assert_eq!(
+        datetime!(2019-01-01 23:59:59.999_999_999 UTC).nanosecond(),
+        999_999_999,
+    );
+}
+
+#[test]
+fn replace_time() {
+    assert_eq!(
+        datetime!(2020-01-01 5:00 UTC).replace_time(time!(12:00)),
+        datetime!(2020-01-01 12:00 UTC)
+    );
+    assert_eq!(
+        datetime!(2020-01-01 12:00 -5).replace_time(time!(7:00)),
+        datetime!(2020-01-01 7:00 -5)
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00 +1).replace_time(time!(12:00)),
+        datetime!(2020-01-01 12:00 +1)
+    );
+}
+
+#[test]
+fn replace_date() {
+    assert_eq!(
+        datetime!(2020-01-01 12:00 UTC).replace_date(date!(2020 - 01 - 30)),
+        datetime!(2020-01-30 12:00 UTC)
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00 +1).replace_date(date!(2020 - 01 - 30)),
+        datetime!(2020-01-30 0:00 +1)
+    );
+}
+
+#[test]
+fn replace_date_time() {
+    assert_eq!(
+        datetime!(2020-01-01 12:00 UTC).replace_date_time(datetime!(2020-01-30 16:00)),
+        datetime!(2020-01-30 16:00 UTC)
+    );
+    assert_eq!(
+        datetime!(2020-01-01 12:00 +1).replace_date_time(datetime!(2020-01-30 0:00)),
+        datetime!(2020-01-30 0:00 +1)
+    );
+}
+
+#[test]
+fn replace_offset() {
+    assert_eq!(
+        datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)),
+        datetime!(2020-01-01 0:00 -5)
+    );
+}
+
+#[test]
+fn replace_year() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00 +01).replace_year(2019),
+        Ok(datetime!(2019 - 02 - 18 12:00 +01))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 12:00 +01)
+            .replace_year(-1_000_000_000)
+            .is_err()
+    ); // -1_000_000_000 isn't a valid year
+    assert!(
+        datetime!(2022 - 02 - 18 12:00 +01)
+            .replace_year(1_000_000_000)
+            .is_err()
+    ); // 1_000_000_000 isn't a valid year
+}
+
+#[test]
+fn replace_month() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00 +01).replace_month(Month::January),
+        Ok(datetime!(2022 - 01 - 18 12:00 +01))
+    );
+    assert!(
+        datetime!(2022 - 01 - 30 12:00 +01)
+            .replace_month(Month::February)
+            .is_err()
+    ); // 30 isn't a valid day in February
+}
+
+#[test]
+fn replace_day() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00 +01).replace_day(1),
+        Ok(datetime!(2022 - 02 - 01 12:00 +01))
+    );
+    assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_day(0).is_err()); // 00 isn't a valid day
+    assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_day(30).is_err()); // 30 isn't a valid day in February
+}
+
+#[test]
+fn replace_ordinal() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00 +01).replace_ordinal(1),
+        Ok(datetime!(2022 - 001 12:00 +01))
+    );
+    assert_eq!(
+        datetime!(2024 - 02 - 29 12:00 +01).replace_ordinal(366),
+        Ok(datetime!(2024 - 366 12:00 +01))
+    );
+    assert!(datetime!(2022 - 049 12:00 +01).replace_ordinal(0).is_err()); // 0 isn't a valid day
+    assert!(
+        datetime!(2022 - 049 12:00 +01)
+            .replace_ordinal(366)
+            .is_err()
+    ); // 2022 isn't a leap year
+    assert!(
+        datetime!(2022 - 049 12:00 +01)
+            .replace_ordinal(367)
+            .is_err()
+    ); // 367 isn't a valid day
+}
+
+#[test]
+fn replace_hour() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_hour(7),
+        Ok(datetime!(2022 - 02 - 18 07:02:03.004_005_006 +01))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01)
+            .replace_hour(24)
+            .is_err()
+    ); // 24 isn't a valid hour
+}
+
+#[test]
+fn replace_minute() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_minute(7),
+        Ok(datetime!(2022 - 02 - 18 01:07:03.004_005_006 +01))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01)
+            .replace_minute(60)
+            .is_err()
+    ); // 60 isn't a valid minute
+}
+
+#[test]
+fn replace_second() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_second(7),
+        Ok(datetime!(2022 - 02 - 18 01:02:07.004_005_006 +01))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01)
+            .replace_second(60)
+            .is_err()
+    ); // 60 isn't a valid second
+}
+
+#[test]
+fn replace_millisecond() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_millisecond(7),
+        Ok(datetime!(2022 - 02 - 18 01:02:03.007 +01))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01)
+            .replace_millisecond(1_000)
+            .is_err()
+    ); // 1_000 isn't a valid millisecond
+}
+
+#[test]
+fn replace_microsecond() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_microsecond(7_008),
+        Ok(datetime!(2022 - 02 - 18 01:02:03.007_008 +01))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01)
+            .replace_microsecond(1_000_000)
+            .is_err()
+    ); // 1_000_000 isn't a valid microsecond
+}
+
+#[test]
+fn replace_nanosecond() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_nanosecond(7_008_009),
+        Ok(datetime!(2022 - 02 - 18 01:02:03.007_008_009 +01))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01)
+            .replace_nanosecond(1_000_000_000)
+            .is_err()
+    ); // 1_000_000_000 isn't a valid nanosecond
+}
+
+#[test]
+fn partial_eq() {
+    assert_eq!(
+        datetime!(2000-01-01 0:00 UTC).to_offset(offset!(-1)),
+        datetime!(2000-01-01 0:00 UTC),
+    );
+}
+
+#[test]
+fn partial_ord() {
+    let t1 = datetime!(2019-01-01 0:00 UTC);
+    let t2 = datetime!(2019-01-01 0:00 UTC).to_offset(offset!(-1));
+    assert_eq!(t1.partial_cmp(&t2), Some(Ordering::Equal));
+}
+
+#[test]
+fn ord() {
+    let t1 = datetime!(2019-01-01 0:00 UTC);
+    let t2 = datetime!(2019-01-01 0:00 UTC).to_offset(offset!(-1));
+    assert_eq!(t1, t2);
+
+    let t1 = datetime!(2019-01-01 0:00 UTC);
+    let t2 = datetime!(2019-01-01 0:00:00.000_000_001 UTC);
+    assert!(t2 > t1);
+}
+
+#[test]
+fn hash() {
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
+
+    assert_eq!(
+        {
+            let mut hasher = DefaultHasher::new();
+            datetime!(2019-01-01 0:00 UTC).hash(&mut hasher);
+            hasher.finish()
+        },
+        {
+            let mut hasher = DefaultHasher::new();
+            datetime!(2019-01-01 0:00 UTC)
+                .to_offset(offset!(-1))
+                .hash(&mut hasher);
+            hasher.finish()
+        }
+    );
+
+    // Ensure that a `PrimitiveDateTime` and `OffsetDateTime` don't collide,
+    // even if the UTC time is the same.
+    assert_ne!(
+        {
+            let mut hasher = DefaultHasher::new();
+            datetime!(2019-01-01 0:00).hash(&mut hasher);
+            hasher.finish()
+        },
+        {
+            let mut hasher = DefaultHasher::new();
+            datetime!(2019-01-01 0:00 UTC).hash(&mut hasher);
+            hasher.finish()
+        }
+    );
+}
+
+#[test]
+fn arithmetic_regression() {
+    let val = Date::MIN
+        .next_day()
+        .expect("date is not maximum")
+        .midnight()
+        .assume_offset(offset!(+12:00:01));
+
+    assert_eq!(val + Duration::ZERO, val);
+    assert_eq!(val - Duration::ZERO, val);
+    assert_eq!(val + StdDuration::from_secs(0), val);
+    assert_eq!(val - StdDuration::from_secs(0), val);
+}
+
+#[test]
+fn add_duration() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC) + 5.days(),
+        datetime!(2019-01-06 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 0:00 UTC) + 1.days(),
+        datetime!(2020-01-01 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 23:59:59 UTC) + 2.seconds(),
+        datetime!(2020-01-01 0:00:01 UTC),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00:01 UTC) + (-2).seconds(),
+        datetime!(2019-12-31 23:59:59 UTC),
+    );
+    assert_eq!(
+        datetime!(1999-12-31 23:00 UTC) + 1.hours(),
+        datetime!(2000-01-01 0:00 UTC),
+    );
+}
+
+#[test]
+fn add_std_duration() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC) + 5.std_days(),
+        datetime!(2019-01-06 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 0:00 UTC) + 1.std_days(),
+        datetime!(2020-01-01 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 23:59:59 UTC) + 2.std_seconds(),
+        datetime!(2020-01-01 0:00:01 UTC),
+    );
+}
+
+#[test]
+fn add_assign_duration() {
+    let mut new_years_day_2019 = datetime!(2019-01-01 0:00 UTC);
+    new_years_day_2019 += 5.days();
+    assert_eq!(new_years_day_2019, datetime!(2019-01-06 0:00 UTC));
+
+    let mut new_years_eve_2020_days = datetime!(2019-12-31 0:00 UTC);
+    new_years_eve_2020_days += 1.days();
+    assert_eq!(new_years_eve_2020_days, datetime!(2020-01-01 0:00 UTC));
+
+    let mut new_years_eve_2020_seconds = datetime!(2019-12-31 23:59:59 UTC);
+    new_years_eve_2020_seconds += 2.seconds();
+    assert_eq!(
+        new_years_eve_2020_seconds,
+        datetime!(2020-01-01 0:00:01 UTC)
+    );
+
+    let mut new_years_day_2020_seconds = datetime!(2020-01-01 0:00:01 UTC);
+    new_years_day_2020_seconds += (-2).seconds();
+    assert_eq!(
+        new_years_day_2020_seconds,
+        datetime!(2019-12-31 23:59:59 UTC)
+    );
+}
+
+#[test]
+fn add_assign_std_duration() {
+    let mut new_years_day_2019 = datetime!(2019-01-01 0:00 UTC);
+    new_years_day_2019 += 5.std_days();
+    assert_eq!(new_years_day_2019, datetime!(2019-01-06 0:00 UTC));
+
+    let mut new_years_eve_2020_days = datetime!(2019-12-31 0:00 UTC);
+    new_years_eve_2020_days += 1.std_days();
+    assert_eq!(new_years_eve_2020_days, datetime!(2020-01-01 0:00 UTC));
+
+    let mut new_years_eve_2020_seconds = datetime!(2019-12-31 23:59:59 UTC);
+    new_years_eve_2020_seconds += 2.std_seconds();
+    assert_eq!(
+        new_years_eve_2020_seconds,
+        datetime!(2020-01-01 0:00:01 UTC)
+    );
+}
+
+#[test]
+fn sub_duration() {
+    assert_eq!(
+        datetime!(2019-01-06 0:00 UTC) - 5.days(),
+        datetime!(2019-01-01 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00 UTC) - 1.days(),
+        datetime!(2019-12-31 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00:01 UTC) - 2.seconds(),
+        datetime!(2019-12-31 23:59:59 UTC),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 23:59:59 UTC) - (-2).seconds(),
+        datetime!(2020-01-01 0:00:01 UTC),
+    );
+    assert_eq!(
+        datetime!(1999-12-31 23:00 UTC) - (-1).hours(),
+        datetime!(2000-01-01 0:00 UTC),
+    );
+}
+
+#[test]
+fn sub_std_duration() {
+    assert_eq!(
+        datetime!(2019-01-06 0:00 UTC) - 5.std_days(),
+        datetime!(2019-01-01 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00 UTC) - 1.std_days(),
+        datetime!(2019-12-31 0:00 UTC),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00:01 UTC) - 2.std_seconds(),
+        datetime!(2019-12-31 23:59:59 UTC),
+    );
+}
+
+#[test]
+fn sub_assign_duration() {
+    let mut new_years_day_2019 = datetime!(2019-01-06 0:00 UTC);
+    new_years_day_2019 -= 5.days();
+    assert_eq!(new_years_day_2019, datetime!(2019-01-01 0:00 UTC));
+
+    let mut new_years_day_2020_days = datetime!(2020-01-01 0:00 UTC);
+    new_years_day_2020_days -= 1.days();
+    assert_eq!(new_years_day_2020_days, datetime!(2019-12-31 0:00 UTC));
+
+    let mut new_years_day_2020_seconds = datetime!(2020-01-01 0:00:01 UTC);
+    new_years_day_2020_seconds -= 2.seconds();
+    assert_eq!(
+        new_years_day_2020_seconds,
+        datetime!(2019-12-31 23:59:59 UTC)
+    );
+
+    let mut new_years_eve_2020_seconds = datetime!(2019-12-31 23:59:59 UTC);
+    new_years_eve_2020_seconds -= (-2).seconds();
+    assert_eq!(
+        new_years_eve_2020_seconds,
+        datetime!(2020-01-01 0:00:01 UTC)
+    );
+}
+
+#[test]
+fn sub_assign_std_duration() {
+    let mut ny19 = datetime!(2019-01-06 0:00 UTC);
+    ny19 -= 5.std_days();
+    assert_eq!(ny19, datetime!(2019-01-01 0:00 UTC));
+
+    let mut ny20 = datetime!(2020-01-01 0:00 UTC);
+    ny20 -= 1.std_days();
+    assert_eq!(ny20, datetime!(2019-12-31 0:00 UTC));
+
+    let mut ny20t = datetime!(2020-01-01 0:00:01 UTC);
+    ny20t -= 2.std_seconds();
+    assert_eq!(ny20t, datetime!(2019-12-31 23:59:59 UTC));
+}
+
+#[test]
+fn std_add_duration() {
+    assert_eq!(
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC)) + 0.seconds(),
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC)) + 5.days(),
+        SystemTime::from(datetime!(2019-01-06 0:00 UTC)),
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2019-12-31 0:00 UTC)) + 1.days(),
+        SystemTime::from(datetime!(2020-01-01 0:00 UTC)),
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2019-12-31 23:59:59 UTC)) + 2.seconds(),
+        SystemTime::from(datetime!(2020-01-01 0:00:01 UTC)),
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2020-01-01 0:00:01 UTC)) + (-2).seconds(),
+        SystemTime::from(datetime!(2019-12-31 23:59:59 UTC)),
+    );
+}
+
+#[test]
+fn std_add_assign_duration() {
+    let mut new_years_day_2019 = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+    new_years_day_2019 += 5.days();
+    assert_eq!(new_years_day_2019, datetime!(2019-01-06 0:00 UTC));
+
+    let mut new_years_eve_2020_days = SystemTime::from(datetime!(2019-12-31 0:00 UTC));
+    new_years_eve_2020_days += 1.days();
+    assert_eq!(new_years_eve_2020_days, datetime!(2020-01-01 0:00 UTC));
+
+    let mut new_years_eve_2020_seconds = SystemTime::from(datetime!(2019-12-31 23:59:59 UTC));
+    new_years_eve_2020_seconds += 2.seconds();
+    assert_eq!(
+        new_years_eve_2020_seconds,
+        datetime!(2020-01-01 0:00:01 UTC)
+    );
+
+    let mut new_years_day_2020_seconds = SystemTime::from(datetime!(2020-01-01 0:00:01 UTC));
+    new_years_day_2020_seconds += (-2).seconds();
+    assert_eq!(
+        new_years_day_2020_seconds,
+        datetime!(2019-12-31 23:59:59 UTC)
+    );
+}
+
+#[test]
+fn std_sub_duration() {
+    assert_eq!(
+        SystemTime::from(datetime!(2019-01-06 0:00 UTC)) - 5.days(),
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2020-01-01 0:00 UTC)) - 1.days(),
+        SystemTime::from(datetime!(2019-12-31 0:00 UTC)),
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2020-01-01 0:00:01 UTC)) - 2.seconds(),
+        SystemTime::from(datetime!(2019-12-31 23:59:59 UTC)),
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2019-12-31 23:59:59 UTC)) - (-2).seconds(),
+        SystemTime::from(datetime!(2020-01-01 0:00:01 UTC)),
+    );
+}
+
+#[test]
+fn std_sub_assign_duration() {
+    let mut new_years_day_2019 = SystemTime::from(datetime!(2019-01-06 0:00 UTC));
+    new_years_day_2019 -= 5.days();
+    assert_eq!(new_years_day_2019, datetime!(2019-01-01 0:00 UTC));
+
+    let mut new_years_day_2020 = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+    new_years_day_2020 -= 1.days();
+    assert_eq!(new_years_day_2020, datetime!(2019-12-31 0:00 UTC));
+
+    let mut new_years_day_2020_seconds = SystemTime::from(datetime!(2020-01-01 0:00:01 UTC));
+    new_years_day_2020_seconds -= 2.seconds();
+    assert_eq!(
+        new_years_day_2020_seconds,
+        datetime!(2019-12-31 23:59:59 UTC)
+    );
+
+    let mut new_years_eve_2020_seconds = SystemTime::from(datetime!(2019-12-31 23:59:59 UTC));
+    new_years_eve_2020_seconds -= (-2).seconds();
+    assert_eq!(
+        new_years_eve_2020_seconds,
+        datetime!(2020-01-01 0:00:01 UTC)
+    );
+}
+
+#[test]
+fn sub_self() {
+    assert_eq!(
+        datetime!(2019-01-02 0:00 UTC) - datetime!(2019-01-01 0:00 UTC),
+        1.days(),
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC) - datetime!(2019-01-02 0:00 UTC),
+        (-1).days(),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00 UTC) - datetime!(2019-12-31 0:00 UTC),
+        1.days(),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 0:00 UTC) - datetime!(2020-01-01 0:00 UTC),
+        (-1).days(),
+    );
+    assert_eq!(
+        datetime!(+999_999-12-31 23:59:59.999_999_999 -23:59:59)
+            - datetime!(-999_999-01-01 0:00 +23:59:59),
+        Duration::new(63_113_872_550_397, 999_999_999),
+    );
+}
+
+#[test]
+fn std_sub() {
+    assert_eq!(
+        SystemTime::from(datetime!(2019-01-02 0:00 UTC)) - datetime!(2019-01-01 0:00 UTC),
+        1.days()
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC)) - datetime!(2019-01-02 0:00 UTC),
+        (-1).days()
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2020-01-01 0:00 UTC)) - datetime!(2019-12-31 0:00 UTC),
+        1.days()
+    );
+    assert_eq!(
+        SystemTime::from(datetime!(2019-12-31 0:00 UTC)) - datetime!(2020-01-01 0:00 UTC),
+        (-1).days()
+    );
+}
+
+#[test]
+fn sub_std() {
+    assert_eq!(
+        datetime!(2019-01-02 0:00 UTC) - SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+        1.days()
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC) - SystemTime::from(datetime!(2019-01-02 0:00 UTC)),
+        (-1).days()
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00 UTC) - SystemTime::from(datetime!(2019-12-31 0:00 UTC)),
+        1.days()
+    );
+    assert_eq!(
+        datetime!(2019-12-31 0:00 UTC) - SystemTime::from(datetime!(2020-01-01 0:00 UTC)),
+        (-1).days()
+    );
+}
+
+#[test]
+fn eq_std() {
+    let now_datetime = OffsetDateTime::now_utc();
+    let now_systemtime = SystemTime::from(now_datetime);
+    assert_eq!(now_datetime, now_systemtime);
+}
+
+#[test]
+fn std_eq() {
+    let now_datetime = OffsetDateTime::now_utc();
+    let now_systemtime = SystemTime::from(now_datetime);
+    assert_eq!(now_systemtime, now_datetime);
+}
+
+#[test]
+fn ord_std() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00 UTC),
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC))
+    );
+    assert!(datetime!(2019-01-01 0:00 UTC) < SystemTime::from(datetime!(2020-01-01 0:00 UTC)));
+    assert!(datetime!(2019-01-01 0:00 UTC) < SystemTime::from(datetime!(2019-02-01 0:00 UTC)));
+    assert!(datetime!(2019-01-01 0:00 UTC) < SystemTime::from(datetime!(2019-01-02 0:00 UTC)));
+    assert!(datetime!(2019-01-01 0:00 UTC) < SystemTime::from(datetime!(2019-01-01 1:00:00 UTC)));
+    assert!(datetime!(2019-01-01 0:00 UTC) < SystemTime::from(datetime!(2019-01-01 0:01:00 UTC)));
+    assert!(datetime!(2019-01-01 0:00 UTC) < SystemTime::from(datetime!(2019-01-01 0:00:01 UTC)));
+    assert!(
+        datetime!(2019-01-01 0:00 UTC) < SystemTime::from(datetime!(2019-01-01 0:00:00.001 UTC))
+    );
+    assert!(datetime!(2020-01-01 0:00 UTC) > SystemTime::from(datetime!(2019-01-01 0:00 UTC)));
+    assert!(datetime!(2019-02-01 0:00 UTC) > SystemTime::from(datetime!(2019-01-01 0:00 UTC)));
+    assert!(datetime!(2019-01-02 0:00 UTC) > SystemTime::from(datetime!(2019-01-01 0:00 UTC)));
+    assert!(datetime!(2019-01-01 1:00:00 UTC) > SystemTime::from(datetime!(2019-01-01 0:00 UTC)));
+    assert!(datetime!(2019-01-01 0:01:00 UTC) > SystemTime::from(datetime!(2019-01-01 0:00 UTC)));
+    assert!(datetime!(2019-01-01 0:00:01 UTC) > SystemTime::from(datetime!(2019-01-01 0:00 UTC)));
+    assert!(
+        datetime!(2019-01-01 0:00:00.000_000_001 UTC)
+            > SystemTime::from(datetime!(2019-01-01 0:00 UTC))
+    );
+}
+
+#[test]
+fn std_ord() {
+    assert_eq!(
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+        datetime!(2019-01-01 0:00 UTC)
+    );
+    assert!(SystemTime::from(datetime!(2019-01-01 0:00 UTC)) < datetime!(2020-01-01 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 0:00 UTC)) < datetime!(2019-02-01 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 0:00 UTC)) < datetime!(2019-01-02 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 0:00 UTC)) < datetime!(2019-01-01 1:00:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 0:00 UTC)) < datetime!(2019-01-01 0:01:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 0:00 UTC)) < datetime!(2019-01-01 0:00:01 UTC));
+    assert!(
+        SystemTime::from(datetime!(2019-01-01 0:00 UTC))
+            < datetime!(2019-01-01 0:00:00.000_000_001 UTC)
+    );
+    assert!(SystemTime::from(datetime!(2020-01-01 0:00 UTC)) > datetime!(2019-01-01 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-02-01 0:00 UTC)) > datetime!(2019-01-01 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-02 0:00 UTC)) > datetime!(2019-01-01 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 1:00:00 UTC)) > datetime!(2019-01-01 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 0:01:00 UTC)) > datetime!(2019-01-01 0:00 UTC));
+    assert!(SystemTime::from(datetime!(2019-01-01 0:00:01 UTC)) > datetime!(2019-01-01 0:00 UTC));
+    assert!(
+        SystemTime::from(datetime!(2019-01-01 0:00:00.001 UTC)) > datetime!(2019-01-01 0:00 UTC)
+    );
+}
+
+#[test]
+fn from_std() {
+    assert_eq!(
+        OffsetDateTime::from(SystemTime::UNIX_EPOCH),
+        OffsetDateTime::UNIX_EPOCH
+    );
+    assert_eq!(
+        OffsetDateTime::from(SystemTime::UNIX_EPOCH - 1.std_days()),
+        OffsetDateTime::UNIX_EPOCH - 1.days()
+    );
+    assert_eq!(
+        OffsetDateTime::from(SystemTime::UNIX_EPOCH + 1.std_days()),
+        OffsetDateTime::UNIX_EPOCH + 1.days()
+    );
+}
+
+#[test]
+fn to_std() {
+    assert_eq!(
+        SystemTime::from(OffsetDateTime::UNIX_EPOCH),
+        SystemTime::UNIX_EPOCH
+    );
+    assert_eq!(
+        SystemTime::from(OffsetDateTime::UNIX_EPOCH + 1.days()),
+        SystemTime::UNIX_EPOCH + 1.std_days()
+    );
+    assert_eq!(
+        SystemTime::from(OffsetDateTime::UNIX_EPOCH - 1.days()),
+        SystemTime::UNIX_EPOCH - 1.std_days()
+    );
+}
+
+#[test]
+fn checked_add_duration() {
+    // Successful addition
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add(5.nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.450_000_005 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add(4.seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:57.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add(2.days()),
+        Some(datetime!(2021 - 10 - 27 14:01:53.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add(1.weeks()),
+        Some(datetime!(2021 - 11 - 01 14:01:53.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add((-5).nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.449_999_995 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add((-4).seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:49.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add((-2).days()),
+        Some(datetime!(2021 - 10 - 23 14:01:53.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_add((-1).weeks()),
+        Some(datetime!(2021 - 10 - 18 14:01:53.45 UTC))
+    );
+
+    // Addition with underflow
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00 UTC).checked_add((-1).nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00 UTC).checked_add(Duration::MIN),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_990 - 01 - 01 0:00 UTC).checked_add((-530).weeks()),
+        None
+    );
+
+    // Addition with overflow
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 UTC).checked_add(1.nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 UTC).checked_add(Duration::MAX),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_990 - 12 - 31 23:59:59.999_999_999 UTC).checked_add(530.weeks()),
+        None
+    );
+
+    // Adding 0 duration at MIN/MAX values with non-zero offset
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 -10:00).checked_add(Duration::ZERO),
+        Some(datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 -10:00))
+    );
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00 +10:00).checked_add(Duration::ZERO),
+        Some(datetime!(-999_999 - 01 - 01 0:00 +10:00))
+    );
+}
+
+#[test]
+fn checked_sub_duration() {
+    // Successful subtraction
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub((-5).nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.450_000_005 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub((-4).seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:57.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub((-2).days()),
+        Some(datetime!(2021 - 10 - 27 14:01:53.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub((-1).weeks()),
+        Some(datetime!(2021 - 11 - 01 14:01:53.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub(5.nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.449_999_995 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub(4.seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:49.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub(2.days()),
+        Some(datetime!(2021 - 10 - 23 14:01:53.45 UTC))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45 UTC).checked_sub(1.weeks()),
+        Some(datetime!(2021 - 10 - 18 14:01:53.45 UTC))
+    );
+
+    // Subtraction with underflow
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00 UTC).checked_sub(1.nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00 UTC).checked_sub(Duration::MAX),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_990 - 01 - 01 0:00 UTC).checked_sub(530.weeks()),
+        None
+    );
+
+    // Subtraction with overflow
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 UTC).checked_sub((-1).nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 UTC).checked_sub(Duration::MIN),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_990 - 12 - 31 23:59:59.999_999_999 UTC).checked_sub((-530).weeks()),
+        None
+    );
+
+    // Subtracting 0 duration at MIN/MAX values with non-zero offset
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 -10).checked_sub(Duration::ZERO),
+        Some(datetime!(+999_999 - 12 - 31 23:59:59.999_999_999 -10))
+    );
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00 +10).checked_sub(Duration::ZERO),
+        Some(datetime!(-999_999 - 01 - 01 0:00 +10))
+    );
+}
+
+#[test]
+fn saturating_add_duration() {
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47 +10).saturating_add(2.days()),
+        datetime!(2021 - 11 - 14 17:47 +10)
+    );
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47 +10).saturating_add((-2).days()),
+        datetime!(2021 - 11 - 10 17:47 +10)
+    );
+
+    // Adding with underflow
+    assert_eq!(
+        datetime!(-999999 - 01 - 01 0:00 +10).saturating_add((-10).days()),
+        datetime!(-999999 - 01 - 01 0:00 +10)
+    );
+
+    // Adding with overflow
+    assert_eq!(
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10).saturating_add(10.days()),
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10)
+    );
+
+    // Adding zero duration at boundaries
+    assert_eq!(
+        datetime!(-999999 - 01 - 01 0:00 +10).saturating_add(Duration::ZERO),
+        datetime!(-999999 - 01 - 01 0:00 +10)
+    );
+    assert_eq!(
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10).saturating_add(Duration::ZERO),
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10)
+    );
+}
+
+#[test]
+fn saturating_sub_duration() {
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47 +10).saturating_sub(2.days()),
+        datetime!(2021 - 11 - 10 17:47 +10)
+    );
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47 +10).saturating_sub((-2).days()),
+        datetime!(2021 - 11 - 14 17:47 +10)
+    );
+
+    // Subtracting with underflow
+    assert_eq!(
+        datetime!(-999999 - 01 - 01 0:00 +10).saturating_sub(10.days()),
+        datetime!(-999999 - 01 - 01 0:00 +10)
+    );
+
+    // Subtracting with overflow
+    assert_eq!(
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10).saturating_sub((-10).days()),
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10)
+    );
+
+    // Subtracting zero duration at boundaries
+    assert_eq!(
+        datetime!(-999999 - 01 - 01 0:00 +10).saturating_sub(Duration::ZERO),
+        datetime!(-999999 - 01 - 01 0:00 +10)
+    );
+    assert_eq!(
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10).saturating_sub(Duration::ZERO),
+        datetime!(+999999 - 12 - 31 23:59:59.999_999_999 +10)
+    );
+}
+
+#[test]
+#[should_panic = "overflow adding duration to date"]
+fn issue_621() {
+    let _ = OffsetDateTime::UNIX_EPOCH + StdDuration::from_secs(18_157_382_926_370_278_155);
+}
diff --git a/tests/parse_format_description.rs b/tests/parse_format_description.rs
new file mode 100644
index 000000000..f29233c93
--- /dev/null
+++ b/tests/parse_format_description.rs
@@ -0,0 +1,799 @@
+use core::num::NonZeroU16;
+
+use rstest::rstest;
+use rstest_reuse::{apply, template};
+use time::error::InvalidFormatDescription;
+use time::format_description::modifier::*;
+use time::format_description::{self, BorrowedFormatItem, Component, OwnedFormatItem};
+
+/// Identical to `modifier!`, but obtains the value from `M<T>` automagically.
+macro_rules! modifier_m {
+    ($name:ident $({
+        $($field:ident $(: $value:expr)?),* $(,)?
+    })?) => {{
+        // Needed for when there are no fields.
+        #[allow(unused_mut)]
+        let mut value = ::time::format_description::modifier::$name::default();
+        $($(value.$field = modifier!(@value $field $($value)?).0;)*)?
+        value
+    }};
+}
+
+/// A modifier with its value and string representation.
+///
+/// This alias is used to avoid repeating the tuple in countless locations.
+type M<T> = (T, &'static str);
+
+#[rustfmt::skip] // does not format well
+#[template]
+#[rstest]
+fn modifiers(
+    #[values(
+        (Padding::Space, "padding:space"),
+        (Padding::Zero, "padding:zero"),
+        (Padding::None, "padding:none"),
+    )]
+    padding: _,
+    #[values(
+        (false, "repr:24"),
+        (true, "repr:12"),
+    )]
+    hour_is_12_hour_clock: _,
+    #[values(
+        (true, "case:upper"),
+        (false, "case:lower"),
+    )]
+    period_is_uppercase: _,
+    #[values(
+        (MonthRepr::Numerical, "repr:numerical"),
+        (MonthRepr::Long, "repr:long"),
+        (MonthRepr::Short, "repr:short"),
+    )]
+    month_repr: _,
+    #[values(
+        (SubsecondDigits::One, "digits:1"),
+        (SubsecondDigits::Two, "digits:2"),
+        (SubsecondDigits::Three, "digits:3"),
+        (SubsecondDigits::Four, "digits:4"),
+        (SubsecondDigits::Five, "digits:5"),
+        (SubsecondDigits::Six, "digits:6"),
+        (SubsecondDigits::Seven, "digits:7"),
+        (SubsecondDigits::Eight, "digits:8"),
+        (SubsecondDigits::Nine, "digits:9"),
+        (SubsecondDigits::OneOrMore, "digits:1+"),
+    )]
+    subsecond_digits: _,
+    #[values(
+        (WeekdayRepr::Short, "repr:short"),
+        (WeekdayRepr::Long, "repr:long"),
+        (WeekdayRepr::Sunday, "repr:sunday"),
+        (WeekdayRepr::Monday, "repr:monday"),
+    )]
+    weekday_repr: _,
+    #[values(
+        (WeekNumberRepr::Iso, "repr:iso"),
+        (WeekNumberRepr::Sunday, "repr:sunday"),
+        (WeekNumberRepr::Monday, "repr:monday"),
+    )]
+    week_number_repr: _,
+    #[values(
+        (YearRepr::Full, "repr:full"),
+        (YearRepr::LastTwo, "repr:last_two"),
+    )]
+    year_repr: _,
+    #[values(
+        (false, "base:calendar"),
+        (true, "base:iso_week"),
+    )]
+    year_is_iso_week_based: _,
+    #[values(
+        (false, "sign:automatic"),
+        (true, "sign:mandatory"),
+    )]
+    sign_is_mandatory: _,
+    #[values(
+        (true, "one_indexed:true"),
+        (false, "one_indexed:false"),
+    )]
+    weekday_is_one_indexed: _,
+    #[values(
+        (true, "case_sensitive:true"),
+        (false, "case_sensitive:false"),
+    )]
+    case_sensitive: _,
+    #[values(
+        (NonZeroU16::new(1).unwrap(), "count:1"),
+        (NonZeroU16::new(2).unwrap(), "count:2"),
+        (NonZeroU16::new(3).unwrap(), "count:3"),
+        (NonZeroU16::new(10).unwrap(), "count:10"),
+        (NonZeroU16::new(100).unwrap(), "count:100"),
+        (NonZeroU16::new(1_000).unwrap(), "count:1000"),
+    )]
+    ignore_count: _,
+    #[values(
+        (UnixTimestampPrecision::Second, "precision:second"),
+        (UnixTimestampPrecision::Millisecond, "precision:millisecond"),
+        (UnixTimestampPrecision::Microsecond, "precision:microsecond"),
+        (UnixTimestampPrecision::Nanosecond, "precision:nanosecond"),
+    )]
+    unix_timestamp_precision: _,
+) {}
+
+#[rstest]
+fn empty() {
+    assert_eq!(format_description::parse_borrowed::<2>(""), Ok(vec![]));
+    assert_eq!(
+        format_description::parse_owned::<2>(""),
+        Ok(OwnedFormatItem::Compound(Box::new([])))
+    );
+}
+
+#[rstest]
+#[case("foo bar", [b"foo bar".as_slice()])]
+#[case("  leading spaces", [b"  leading spaces".as_slice()])]
+#[case("trailing spaces  ", [b"trailing spaces  ".as_slice()])]
+#[case("     ", [b"     ".as_slice()])]
+#[case("[[", [b"[".as_slice()])]
+#[case("foo[[bar", [b"foo".as_slice(), b"[".as_slice(), b"bar".as_slice()])]
+fn only_literal<const N: usize>(#[case] format_description: &str, #[case] expected: [&[u8]; N]) {
+    assert_eq!(
+        format_description::parse(format_description),
+        Ok(expected
+            .into_iter()
+            .map(BorrowedFormatItem::Literal)
+            .collect())
+    );
+}
+
+#[rstest]
+#[case("[day]", Component::Day(modifier!(Day)))]
+#[case("[end]", Component::End(modifier!(End)))]
+#[case("[hour]", Component::Hour(modifier!(Hour)))]
+#[case("[minute]", Component::Minute(modifier!(Minute)))]
+#[case("[month]", Component::Month(modifier!(Month)))]
+#[case("[offset_hour]", Component::OffsetHour(modifier!(OffsetHour)))]
+#[case("[offset_minute]", Component::OffsetMinute(modifier!(OffsetMinute)))]
+#[case("[offset_second]", Component::OffsetSecond(modifier!(OffsetSecond)))]
+#[case("[ordinal]", Component::Ordinal(modifier!(Ordinal)))]
+#[case("[period]", Component::Period(modifier!(Period)))]
+#[case("[second]", Component::Second(modifier!(Second)))]
+#[case("[subsecond]", Component::Subsecond(modifier!(Subsecond)))]
+#[case("[unix_timestamp]", Component::UnixTimestamp(modifier!(UnixTimestamp)))]
+#[case("[weekday]", Component::Weekday(modifier!(Weekday)))]
+#[case("[week_number]", Component::WeekNumber(modifier!(WeekNumber)))]
+#[case("[year]", Component::Year(modifier!(Year)))]
+fn simple_component(#[case] format_description: &str, #[case] component: Component) {
+    assert_eq!(
+        format_description::parse(format_description),
+        Ok(vec![BorrowedFormatItem::Component(component)])
+    );
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[rstest]
+fn errors() {
+    use InvalidFormatDescription::*;
+
+    macro_rules! assert_errs {
+        ($($format_description:literal, $error:pat $(if $condition:expr)?,)*) => {$(
+            assert!(matches!(
+                format_description::parse($format_description),
+                Err($error) $(if $condition)?
+            ));
+            assert!(matches!(
+                format_description::parse_owned::<2>($format_description),
+                Err($error) $(if $condition)?
+            ));
+        )*};
+    }
+
+    assert_errs! {
+        "[ invalid ]", InvalidComponentName { name, index: 2, .. } if name == "invalid",
+        "[", MissingComponentName { index: 0, .. },
+        "[ ", MissingComponentName { index: 1, .. },
+        "[]", MissingComponentName { index: 0, .. },
+        "[day sign:mandatory]", InvalidModifier { value, index: 5, .. } if value == "sign",
+        "[day sign:]", InvalidModifier { value, index: 9,.. } if value.is_empty(),
+        "[day :mandatory]", InvalidModifier { value, index: 5,.. } if value.is_empty(),
+        "[day sign:mandatory", UnclosedOpeningBracket { index: 0, .. },
+        "[day padding:invalid]", InvalidModifier { value, index: 13, .. } if value == "invalid",
+        "[ignore]", MissingRequiredModifier { name: "count", index: 1, .. },
+        "[ignore count:70000]", InvalidModifier { value, index: 14, .. } if value == "70000",
+    }
+}
+
+// region: individual components
+macro_rules! placeholder {
+    ($($x:tt)*) => {
+        " {}"
+    };
+}
+
+macro_rules! parse_with_modifiers {
+    ($modifier_name:literal, $($modifier:ident),+) => {
+        format_description::parse(
+            &format!(
+                concat!(
+                    "[",
+                    $modifier_name,
+                    $(placeholder!($modifier),)+
+                    "]",
+                ),
+                $($modifier.1),+
+            )
+        )
+    };
+}
+
+#[apply(modifiers)]
+fn day_component(padding: M<Padding>) {
+    assert_eq!(
+        parse_with_modifiers!("day", padding),
+        Ok(vec![BorrowedFormatItem::Component(Component::Day(
+            modifier_m!(Day { padding })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn minute_component(padding: M<Padding>) {
+    assert_eq!(
+        parse_with_modifiers!("minute", padding),
+        Ok(vec![BorrowedFormatItem::Component(Component::Minute(
+            modifier_m!(Minute { padding })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn offset_minute_component(padding: M<Padding>) {
+    assert_eq!(
+        parse_with_modifiers!("offset_minute", padding),
+        Ok(vec![BorrowedFormatItem::Component(
+            Component::OffsetMinute(modifier_m!(OffsetMinute { padding }))
+        )])
+    );
+}
+
+#[apply(modifiers)]
+fn offset_second_component(padding: M<Padding>) {
+    assert_eq!(
+        parse_with_modifiers!("offset_second", padding),
+        Ok(vec![BorrowedFormatItem::Component(
+            Component::OffsetSecond(modifier_m!(OffsetSecond { padding }))
+        )])
+    );
+}
+
+#[apply(modifiers)]
+fn ordinal_component(padding: M<Padding>) {
+    assert_eq!(
+        parse_with_modifiers!("ordinal", padding),
+        Ok(vec![BorrowedFormatItem::Component(Component::Ordinal(
+            modifier_m!(Ordinal { padding })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn second_component(padding: M<Padding>) {
+    assert_eq!(
+        parse_with_modifiers!("second", padding),
+        Ok(vec![BorrowedFormatItem::Component(Component::Second(
+            modifier_m!(Second { padding })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn hour_component(padding: M<Padding>, hour_is_12_hour_clock: M<bool>) {
+    assert_eq!(
+        parse_with_modifiers!("hour", padding, hour_is_12_hour_clock),
+        Ok(vec![BorrowedFormatItem::Component(Component::Hour(
+            modifier_m!(Hour {
+                padding,
+                is_12_hour_clock: hour_is_12_hour_clock
+            })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn month_component(padding: M<Padding>, case_sensitive: M<bool>, month_repr: M<MonthRepr>) {
+    assert_eq!(
+        parse_with_modifiers!("month", padding, case_sensitive, month_repr),
+        Ok(vec![BorrowedFormatItem::Component(Component::Month(
+            modifier_m!(Month {
+                padding,
+                repr: month_repr,
+                case_sensitive
+            })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn period_component(case_sensitive: M<bool>, period_is_uppercase: M<bool>) {
+    assert_eq!(
+        parse_with_modifiers!("period", period_is_uppercase, case_sensitive),
+        Ok(vec![BorrowedFormatItem::Component(Component::Period(
+            modifier_m!(Period {
+                is_uppercase: period_is_uppercase,
+                case_sensitive
+            })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn weekday_component(
+    case_sensitive: M<bool>,
+    weekday_is_one_indexed: M<bool>,
+    weekday_repr: M<WeekdayRepr>,
+) {
+    assert_eq!(
+        parse_with_modifiers!(
+            "weekday",
+            case_sensitive,
+            weekday_is_one_indexed,
+            weekday_repr
+        ),
+        Ok(vec![BorrowedFormatItem::Component(Component::Weekday(
+            modifier_m!(Weekday {
+                repr: weekday_repr,
+                one_indexed: weekday_is_one_indexed,
+                case_sensitive
+            })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn week_number_component(padding: M<Padding>, week_number_repr: M<WeekNumberRepr>) {
+    assert_eq!(
+        parse_with_modifiers!("week_number", padding, week_number_repr),
+        Ok(vec![BorrowedFormatItem::Component(Component::WeekNumber(
+            modifier_m!(WeekNumber {
+                padding,
+                repr: week_number_repr
+            })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn offset_hour_component(padding: M<Padding>, sign_is_mandatory: M<bool>) {
+    assert_eq!(
+        parse_with_modifiers!("offset_hour", padding, sign_is_mandatory),
+        Ok(vec![BorrowedFormatItem::Component(Component::OffsetHour(
+            modifier_m!(OffsetHour {
+                padding,
+                sign_is_mandatory
+            })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn year_component(
+    padding: M<Padding>,
+    year_repr: M<YearRepr>,
+    year_is_iso_week_based: M<bool>,
+    sign_is_mandatory: M<bool>,
+) {
+    assert_eq!(
+        parse_with_modifiers!(
+            "year",
+            padding,
+            year_repr,
+            year_is_iso_week_based,
+            sign_is_mandatory
+        ),
+        Ok(vec![BorrowedFormatItem::Component(Component::Year(
+            modifier_m!(Year {
+                padding,
+                repr: year_repr,
+                iso_week_based: year_is_iso_week_based,
+                sign_is_mandatory
+            })
+        ))])
+    );
+}
+
+#[apply(modifiers)]
+fn unix_timestamp_component(
+    sign_is_mandatory: M<bool>,
+    unix_timestamp_precision: M<UnixTimestampPrecision>,
+) {
+    assert_eq!(
+        parse_with_modifiers!(
+            "unix_timestamp",
+            sign_is_mandatory,
+            unix_timestamp_precision
+        ),
+        Ok(vec![BorrowedFormatItem::Component(
+            Component::UnixTimestamp(modifier_m!(UnixTimestamp {
+                sign_is_mandatory,
+                precision: unix_timestamp_precision,
+            }))
+        )])
+    );
+}
+
+#[apply(modifiers)]
+fn subsecond_component(subsecond_digits: M<SubsecondDigits>) {
+    assert_eq!(
+        parse_with_modifiers!("subsecond", subsecond_digits),
+        Ok(vec![BorrowedFormatItem::Component(Component::Subsecond(
+            modifier_m!(Subsecond {
+                digits: subsecond_digits
+            })
+        ))]),
+    );
+}
+
+#[apply(modifiers)]
+fn ignore_component(ignore_count: M<NonZeroU16>) {
+    assert_eq!(
+        parse_with_modifiers!("ignore", ignore_count),
+        Ok(vec![BorrowedFormatItem::Component(Component::Ignore(
+            Ignore::count(ignore_count.0)
+        ))])
+    );
+}
+// endregion individual components
+
+#[rstest]
+fn optional() {
+    assert_eq!(
+        format_description::parse_owned::<2>("[optional [:[year]]]"),
+        Ok(OwnedFormatItem::Optional(Box::new(
+            OwnedFormatItem::Compound(Box::new([
+                OwnedFormatItem::Literal(Box::new(*b":")),
+                OwnedFormatItem::Component(Component::Year(Default::default()))
+            ]))
+        )))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>("[optional [[year]]]"),
+        Ok(OwnedFormatItem::Optional(Box::new(
+            OwnedFormatItem::Component(Component::Year(Default::default()))
+        )))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"[optional [\[]]"),
+        Ok(OwnedFormatItem::Optional(Box::new(
+            OwnedFormatItem::Literal(Box::new(*b"["))
+        )))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"[optional [ \[ ]]"),
+        Ok(OwnedFormatItem::Optional(Box::new(
+            OwnedFormatItem::Compound(Box::new([
+                OwnedFormatItem::Literal(Box::new(*b" ")),
+                OwnedFormatItem::Literal(Box::new(*b"[")),
+                OwnedFormatItem::Literal(Box::new(*b" ")),
+            ]))
+        )))
+    );
+}
+
+#[rstest]
+fn first() {
+    assert_eq!(
+        format_description::parse_owned::<2>("[first [a]]"),
+        Ok(OwnedFormatItem::First(Box::new([
+            OwnedFormatItem::Literal(Box::new(*b"a"))
+        ])))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>("[first [a] [b]]"),
+        Ok(OwnedFormatItem::First(Box::new([
+            OwnedFormatItem::Literal(Box::new(*b"a")),
+            OwnedFormatItem::Literal(Box::new(*b"b")),
+        ])))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>("[first [a][b]]"),
+        Ok(OwnedFormatItem::First(Box::new([
+            OwnedFormatItem::Literal(Box::new(*b"a")),
+            OwnedFormatItem::Literal(Box::new(*b"b")),
+        ])))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"[first [a][\[]]"),
+        Ok(OwnedFormatItem::First(Box::new([
+            OwnedFormatItem::Literal(Box::new(*b"a")),
+            OwnedFormatItem::Literal(Box::new(*b"[")),
+        ])))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"[first [a][\[\[]]"),
+        Ok(OwnedFormatItem::First(Box::new([
+            OwnedFormatItem::Literal(Box::new(*b"a")),
+            OwnedFormatItem::Compound(Box::new([
+                OwnedFormatItem::Literal(Box::new(*b"[")),
+                OwnedFormatItem::Literal(Box::new(*b"[")),
+            ]))
+        ])))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(
+            "[first [[period case:upper]] [[period case:lower]] ]"
+        ),
+        Ok(OwnedFormatItem::First(Box::new([
+            OwnedFormatItem::Component(Component::Period(modifier!(Period {
+                is_uppercase: true,
+                case_sensitive: true,
+            }))),
+            OwnedFormatItem::Component(Component::Period(modifier!(Period {
+                is_uppercase: false,
+                case_sensitive: true,
+            }))),
+        ])))
+    );
+}
+
+#[rstest]
+fn backslash_escape() {
+    assert_eq!(
+        format_description::parse_owned::<2>(r"[optional [\]]]"),
+        Ok(OwnedFormatItem::Optional(Box::new(
+            OwnedFormatItem::Literal(Box::new(*b"]"))
+        )))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"[optional [\[]]"),
+        Ok(OwnedFormatItem::Optional(Box::new(
+            OwnedFormatItem::Literal(Box::new(*b"["))
+        )))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"[optional [\\]]"),
+        Ok(OwnedFormatItem::Optional(Box::new(
+            OwnedFormatItem::Literal(Box::new(*br"\"))
+        )))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"\\"),
+        Ok(OwnedFormatItem::Literal(Box::new(*br"\")))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"\["),
+        Ok(OwnedFormatItem::Literal(Box::new(*br"[")))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"\]"),
+        Ok(OwnedFormatItem::Literal(Box::new(*br"]")))
+    );
+    assert_eq!(
+        format_description::parse_owned::<2>(r"foo\\"),
+        Ok(OwnedFormatItem::Compound(Box::new([
+            OwnedFormatItem::Literal(Box::new(*b"foo")),
+            OwnedFormatItem::Literal(Box::new(*br"\")),
+        ])))
+    );
+    assert_eq!(
+        format_description::parse_borrowed::<2>(r"\\"),
+        Ok(vec![BorrowedFormatItem::Literal(br"\")])
+    );
+    assert_eq!(
+        format_description::parse_borrowed::<2>(r"\["),
+        Ok(vec![BorrowedFormatItem::Literal(br"[")])
+    );
+    assert_eq!(
+        format_description::parse_borrowed::<2>(r"\]"),
+        Ok(vec![BorrowedFormatItem::Literal(br"]")])
+    );
+    assert_eq!(
+        format_description::parse_borrowed::<2>(r"foo\\"),
+        Ok(vec![
+            BorrowedFormatItem::Literal(b"foo"),
+            BorrowedFormatItem::Literal(br"\"),
+        ])
+    );
+}
+
+#[rstest]
+#[case(r"\a", 1)]
+#[case(r"\", 0)]
+fn backslash_escape_error(#[case] format_description: &str, #[case] expected_index: usize) {
+    assert!(matches!(
+        format_description::parse_owned::<2>(format_description),
+        Err(InvalidFormatDescription::Expected {
+            what: "valid escape sequence",
+            index,
+            ..
+        }) if index == expected_index
+    ));
+    assert!(matches!(
+        format_description::parse_borrowed::<2>(format_description),
+        Err(InvalidFormatDescription::Expected {
+            what: "valid escape sequence",
+            index,
+            ..
+        }) if index == expected_index
+    ));
+}
+
+#[rstest]
+fn nested_v1_error() {
+    assert!(matches!(
+        format_description::parse_owned::<2>("[optional [[[]]"),
+        Err(InvalidFormatDescription::MissingComponentName { index: 11, .. })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[optional [ [[ ]]"),
+        Err(InvalidFormatDescription::MissingComponentName { index: 12, .. })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[first [a][[[]]"),
+        Err(InvalidFormatDescription::UnclosedOpeningBracket { index: 0, .. })
+    ));
+}
+
+#[rstest]
+fn nested_error() {
+    use InvalidFormatDescription::*;
+
+    assert!(matches!(
+        format_description::parse("[optional []]"),
+        Err(NotSupported {
+            what: "optional item",
+            context: "runtime-parsed format descriptions",
+            index: 0,
+            ..
+        })
+    ));
+    assert!(matches!(
+        format_description::parse("[first []]"),
+        Err(NotSupported {
+            what: "'first' item",
+            context: "runtime-parsed format descriptions",
+            index: 0,
+            ..
+        })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[year [month]]"),
+        Err(InvalidModifier { value, index: 6, .. }) if value == "["
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[optional[]]"),
+        Err(Expected {
+            what: "whitespace after `optional`",
+            index: 8,
+            ..
+        })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[first[]]"),
+        Err(Expected {
+            what: "whitespace after `first`",
+            index: 5,
+            ..
+        })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[optional []"),
+        Err(UnclosedOpeningBracket { index: 0, .. })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[first []"),
+        Err(UnclosedOpeningBracket { index: 0, .. })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[optional ["),
+        Err(UnclosedOpeningBracket { index: 10, .. })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[optional [[year"),
+        Err(UnclosedOpeningBracket { index: 11, .. })
+    ));
+    assert!(matches!(
+        format_description::parse_owned::<2>("[optional "),
+        Err(Expected {
+            what: "opening bracket",
+            index: 9,
+            ..
+        })
+    ));
+}
+
+#[rstest]
+#[case("[", "missing component name at byte index 0")]
+#[case("[foo", "unclosed opening bracket at byte index 0")]
+#[case("[foo]", "invalid component name `foo` at byte index 1")]
+#[case("[day bar]", "invalid modifier `bar` at byte index 5")]
+#[case("[]", "missing component name at byte index 0")]
+#[case(
+    "[optional []]",
+    "optional item is not supported in runtime-parsed format descriptions at byte index 0"
+)]
+#[case(
+    "[ignore]",
+    "missing required modifier `count` for component at byte index 1"
+)]
+fn error_display(#[case] format_description: &str, #[case] error: &str) {
+    // la10736/rstest#217
+    #[allow(clippy::unwrap_used)] // It's the point of the test.
+    let test = || {
+        assert_eq!(
+            format_description::parse(format_description)
+                .unwrap_err()
+                .to_string(),
+            error
+        );
+    };
+
+    test();
+}
+
+#[rstest]
+#[case("[optional ", "expected opening bracket at byte index 9")]
+fn error_display_owned(#[case] format_description: &str, #[case] error: &str) {
+    // la10736/rstest#217
+    #[allow(clippy::unwrap_used)] // It's the point of the test.
+    let test = || {
+        assert_eq!(
+            format_description::parse_owned::<2>(format_description)
+                .unwrap_err()
+                .to_string(),
+            error
+        )
+    };
+
+    test();
+}
+
+#[rstest]
+fn rfc_3339() {
+    assert_eq!(
+        format_description::parse(
+            "[year]-[month repr:numerical]-[day]T[hour]:[minute]:[second].[subsecond][offset_hour \
+             sign:mandatory]:[offset_minute]"
+        ),
+        Ok(vec![
+            BorrowedFormatItem::Component(Component::Year(modifier!(Year {
+                padding: Padding::Zero,
+                repr: YearRepr::Full,
+                iso_week_based: false,
+                sign_is_mandatory: false
+            }))),
+            BorrowedFormatItem::Literal(b"-"),
+            BorrowedFormatItem::Component(Component::Month(modifier!(Month {
+                padding: Padding::Zero,
+                repr: MonthRepr::Numerical
+            }))),
+            BorrowedFormatItem::Literal(b"-"),
+            BorrowedFormatItem::Component(Component::Day(modifier!(Day {
+                padding: Padding::Zero
+            }))),
+            BorrowedFormatItem::Literal(b"T"),
+            BorrowedFormatItem::Component(Component::Hour(modifier!(Hour {
+                padding: Padding::Zero,
+                is_12_hour_clock: false
+            }))),
+            BorrowedFormatItem::Literal(b":"),
+            BorrowedFormatItem::Component(Component::Minute(modifier!(Minute {
+                padding: Padding::Zero
+            }))),
+            BorrowedFormatItem::Literal(b":"),
+            BorrowedFormatItem::Component(Component::Second(modifier!(Second {
+                padding: Padding::Zero
+            }))),
+            BorrowedFormatItem::Literal(b"."),
+            BorrowedFormatItem::Component(Component::Subsecond(modifier!(Subsecond {
+                digits: SubsecondDigits::OneOrMore
+            }))),
+            BorrowedFormatItem::Component(Component::OffsetHour(modifier!(OffsetHour {
+                padding: Padding::Zero,
+                sign_is_mandatory: true
+            }))),
+            BorrowedFormatItem::Literal(b":"),
+            BorrowedFormatItem::Component(Component::OffsetMinute(modifier!(OffsetMinute {
+                padding: Padding::Zero
+            })))
+        ])
+    );
+}
diff --git a/tests/parsed.rs b/tests/parsed.rs
new file mode 100644
index 000000000..bb63e36b1
--- /dev/null
+++ b/tests/parsed.rs
@@ -0,0 +1,186 @@
+use std::num::{NonZeroU16, NonZeroU8};
+
+use time::format_description::modifier::WeekNumberRepr;
+use time::format_description::{BorrowedFormatItem, Component};
+use time::parsing::Parsed;
+use time::{error, Month, Time, Weekday};
+
+#[test]
+fn getters_setters() {
+    macro_rules! getters_setters {
+        ($( $(#[$attr:meta])* $setter:ident $getter:ident $value:expr;)*) => {$(
+            $(#[$attr])*
+            {
+                let mut parsed = Parsed::new();
+                parsed.$setter($value);
+                assert_eq!(parsed.$getter(), Some($value));
+            }
+        )*};
+    }
+
+    getters_setters! {
+        set_year year 5;
+        set_year_last_two year_last_two 5;
+        set_iso_year iso_year 5;
+        set_iso_year_last_two iso_year_last_two 5;
+        set_month month Month::May;
+        set_sunday_week_number sunday_week_number 5;
+        set_monday_week_number monday_week_number 5;
+        set_iso_week_number iso_week_number NonZeroU8::new(5).expect("valid value");
+        set_weekday weekday Weekday::Monday;
+        set_ordinal ordinal NonZeroU16::new(5).expect("valid value");
+        set_day day NonZeroU8::new(5).expect("valid value");
+        set_hour_24 hour_24 5;
+        set_hour_12 hour_12 NonZeroU8::new(5).expect("valid value");
+        set_hour_12_is_pm hour_12_is_pm true;
+        set_minute minute 5;
+        set_second second 5;
+        set_subsecond subsecond 5;
+        set_offset_hour offset_hour 5;
+        #[allow(deprecated)] set_offset_minute offset_minute 5;
+        set_offset_minute_signed offset_minute_signed -5;
+        #[allow(deprecated)] set_offset_second offset_second 5;
+        set_offset_second_signed offset_second_signed -5;
+    }
+
+    #[allow(deprecated)]
+    {
+        let mut parsed = Parsed::new();
+        parsed.set_offset_minute(200);
+        assert_eq!(parsed.offset_minute(), None);
+        parsed.set_offset_second(200);
+        assert_eq!(parsed.offset_second(), None);
+    }
+}
+
+#[test]
+fn builder_methods() {
+    #[allow(deprecated)]
+    let parsed = Parsed::new()
+        .with_year(5)
+        .and_then(|parsed| parsed.with_year_last_two(5))
+        .and_then(|parsed| parsed.with_iso_year(5))
+        .and_then(|parsed| parsed.with_iso_year_last_two(5))
+        .and_then(|parsed| parsed.with_month(Month::May))
+        .and_then(|parsed| parsed.with_sunday_week_number(5))
+        .and_then(|parsed| parsed.with_monday_week_number(5))
+        .and_then(|parsed| parsed.with_iso_week_number(NonZeroU8::new(5).expect("valid value")))
+        .and_then(|parsed| parsed.with_weekday(Weekday::Monday))
+        .and_then(|parsed| parsed.with_ordinal(NonZeroU16::new(5).expect("valid value")))
+        .and_then(|parsed| parsed.with_day(NonZeroU8::new(5).expect("valid value")))
+        .and_then(|parsed| parsed.with_hour_24(5))
+        .and_then(|parsed| parsed.with_hour_12(NonZeroU8::new(5).expect("valid value")))
+        .and_then(|parsed| parsed.with_hour_12_is_pm(true))
+        .and_then(|parsed| parsed.with_minute(5))
+        .and_then(|parsed| parsed.with_second(5))
+        .and_then(|parsed| parsed.with_subsecond(5))
+        .and_then(|parsed| parsed.with_offset_hour(5))
+        .and_then(|parsed| parsed.with_offset_minute(5))
+        .and_then(|parsed| parsed.with_offset_second(5))
+        .expect("all values are valid");
+
+    assert_eq!(parsed.year(), Some(5));
+    assert_eq!(parsed.year_last_two(), Some(5));
+    assert_eq!(parsed.iso_year(), Some(5));
+    assert_eq!(parsed.iso_year_last_two(), Some(5));
+    assert_eq!(parsed.month(), Some(Month::May));
+    assert_eq!(parsed.sunday_week_number(), Some(5));
+    assert_eq!(parsed.monday_week_number(), Some(5));
+    assert_eq!(
+        parsed.iso_week_number(),
+        Some(NonZeroU8::new(5).expect("valid value"))
+    );
+    assert_eq!(parsed.weekday(), Some(Weekday::Monday));
+    assert_eq!(
+        parsed.ordinal(),
+        Some(NonZeroU16::new(5).expect("valid value"))
+    );
+    assert_eq!(parsed.day(), Some(NonZeroU8::new(5).expect("valid value")));
+    assert_eq!(parsed.hour_24(), Some(5));
+    assert_eq!(
+        parsed.hour_12(),
+        Some(NonZeroU8::new(5).expect("valid value"))
+    );
+    assert_eq!(parsed.hour_12_is_pm(), Some(true));
+    assert_eq!(parsed.minute(), Some(5));
+    assert_eq!(parsed.second(), Some(5));
+    assert_eq!(parsed.subsecond(), Some(5));
+    assert_eq!(parsed.offset_hour(), Some(5));
+    #[allow(deprecated)]
+    {
+        assert_eq!(parsed.offset_minute(), Some(5));
+        assert_eq!(parsed.offset_second(), Some(5));
+    }
+
+    let parsed = Parsed::new()
+        .with_offset_minute_signed(-5)
+        .and_then(|parsed| parsed.with_offset_second_signed(-5))
+        .expect("all values are valid");
+
+    assert_eq!(parsed.offset_minute_signed(), Some(-5));
+    assert_eq!(parsed.offset_second_signed(), Some(-5));
+
+    #[allow(deprecated)]
+    {
+        assert!(Parsed::new().with_offset_minute(200).is_none());
+        assert!(Parsed::new().with_offset_second(200).is_none());
+    }
+}
+
+#[test]
+fn single_item_parse() {
+    assert!(Time::parse("a", &BorrowedFormatItem::Literal(b"a")).is_err());
+    assert!(Time::parse("b", &BorrowedFormatItem::Literal(b"a")).is_err());
+}
+
+#[test]
+fn component_err() {
+    macro_rules! input_or_empty {
+        () => {
+            b""
+        };
+        ($input:expr) => {
+            $input
+        };
+    }
+    macro_rules! assert_invalid_component {
+        ($component_name:expr, $component:expr $(, $input:expr)?) => {{
+            let mut parsed = Parsed::new();
+            assert_eq!(
+                parsed.parse_component(input_or_empty!($($input)?), $component),
+                Err(error::ParseFromDescription::InvalidComponent(
+                    $component_name
+                ))
+            );
+        }};
+    }
+
+    assert_invalid_component!("day", Component::Day(<_>::default()));
+    assert_invalid_component!("month", Component::Month(<_>::default()));
+    assert_invalid_component!("ordinal", Component::Ordinal(<_>::default()));
+    assert_invalid_component!("weekday", Component::Weekday(<_>::default()));
+    assert_invalid_component!("week number", Component::WeekNumber(<_>::default()));
+    assert_invalid_component!("year", Component::Year(<_>::default()));
+    assert_invalid_component!("minute", Component::Minute(<_>::default()));
+    assert_invalid_component!("period", Component::Period(<_>::default()));
+    assert_invalid_component!("second", Component::Second(<_>::default()));
+    assert_invalid_component!("subsecond", Component::Subsecond(<_>::default()));
+    assert_invalid_component!("offset hour", Component::OffsetHour(<_>::default()));
+    assert_invalid_component!("offset minute", Component::OffsetMinute(<_>::default()));
+    assert_invalid_component!("offset second", Component::OffsetSecond(<_>::default()));
+
+    assert_invalid_component!(
+        "week number",
+        Component::WeekNumber(modifier!(WeekNumber {
+            repr: WeekNumberRepr::Iso,
+        })),
+        b"00"
+    );
+    assert_invalid_component!(
+        "hour",
+        Component::Hour(modifier!(Hour {
+            is_12_hour_clock: true,
+        })),
+        b"00"
+    );
+}
diff --git a/tests/parsing.rs b/tests/parsing.rs
new file mode 100644
index 000000000..518661d3b
--- /dev/null
+++ b/tests/parsing.rs
@@ -0,0 +1,1726 @@
+use std::num::{NonZeroU16, NonZeroU8};
+
+use time::format_description::modifier::Ignore;
+use time::format_description::well_known::{Iso8601, Rfc2822, Rfc3339};
+use time::format_description::{modifier, BorrowedFormatItem, Component, OwnedFormatItem};
+use time::macros::{date, datetime, offset, time};
+use time::parsing::Parsed;
+use time::{
+    error, format_description as fd, Date, Month, OffsetDateTime, PrimitiveDateTime, Time,
+    UtcOffset, Weekday,
+};
+
+macro_rules! invalid_literal {
+    () => {
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidLiteral { .. },
+        ))
+    };
+}
+macro_rules! invalid_component {
+    ($name:literal) => {
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent($name),
+        ))
+    };
+}
+
+#[test]
+fn rfc_2822() -> time::Result<()> {
+    assert_eq!(
+        OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 GMT", &Rfc2822)?,
+        datetime!(2021-01-02 03:04:05 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 UT", &Rfc2822)?,
+        datetime!(2021-01-02 03:04:05 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 +0000", &Rfc2822)?,
+        datetime!(2021-01-02 03:04:05 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 +0607", &Rfc2822)?,
+        datetime!(2021-01-02 03:04:05 +06:07),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 -0607", &Rfc2822)?,
+        datetime!(2021-01-02 03:04:05 -06:07),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Fri, 31 Dec 2021 23:59:60 Z", &Rfc2822)?,
+        datetime!(2021-12-31 23:59:59.999_999_999 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Fri, 31 Dec 2021 23:59:60 z", &Rfc2822)?,
+        datetime!(2021-12-31 23:59:59.999_999_999 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Fri, 31 Dec 2021 23:59:60 a", &Rfc2822)?,
+        datetime!(2021-12-31 23:59:59.999_999_999 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Fri, 31 Dec 2021 23:59:60 A", &Rfc2822)?,
+        datetime!(2021-12-31 23:59:59.999_999_999 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Fri, 31 Dec 2021 17:52:60 -0607", &Rfc2822)?,
+        datetime!(2021-12-31 17:52:59.999_999_999 -06:07),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("Sat, 01 Jan 2022 06:06:60 +0607", &Rfc2822)?,
+        datetime!(2022-01-01 06:06:59.999_999_999 +06:07),
+    );
+
+    assert_eq!(
+        Date::parse("Sat, 02 Jan 2021 03:04:05 GMT", &Rfc2822)?,
+        date!(2021 - 01 - 02)
+    );
+    assert_eq!(
+        Date::parse("Sat, 02 Jan 2021 03:04:05 +0607", &Rfc2822)?,
+        date!(2021 - 01 - 02)
+    );
+    assert_eq!(
+        Date::parse("Sat, 02 Jan 2021 03:04:05 -0607", &Rfc2822)?,
+        date!(2021 - 01 - 02)
+    );
+    assert_eq!(
+        Date::parse("Sat, 02 Jan 21 03:04:05 -0607", &Rfc2822)?,
+        date!(2021 - 01 - 02)
+    );
+    assert_eq!(
+        Date::parse("Sat, 02 Jan 71 03:04:05 -0607", &Rfc2822)?,
+        date!(1971 - 01 - 02)
+    );
+
+    assert_eq!(
+        OffsetDateTime::parse("Sat,(\\\u{a})02 Jan 2021 03:04:05 GMT", &Rfc2822)?,
+        datetime!(2021 - 01 - 02 03:04:05 UTC),
+    );
+    #[rustfmt::skip]
+    assert_eq!(
+        Time::parse(
+            "  \t Sat,\r\n \
+            (\tfoo012FOO!)\
+            (\u{1}\u{b}\u{e}\u{7f})\
+            (\\\u{1}\\\u{9}\\\u{28}\\\u{29}\\\\u{5c}\\\u{7f})\
+            (\\\n\\\u{b})\
+            02 \r\n  \r\n Jan 2021 03:04:05 GMT",
+            &Rfc2822
+        )?,
+        time!(03:04:05)
+    );
+
+    Ok(())
+}
+
+#[test]
+fn issue_661() -> time::Result<()> {
+    assert_eq!(
+        OffsetDateTime::parse("02 Jan 2021 03:04:05 +0607", &Rfc2822)?,
+        datetime!(2021-01-02 03:04:05 +06:07),
+    );
+    assert_eq!(
+        Date::parse("02 Jan 2021 03:04:05 +0607", &Rfc2822)?,
+        date!(2021 - 01 - 02)
+    );
+
+    Ok(())
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn rfc_2822_err() {
+    // In the first test, the "weekday" component is invalid, we're actually testing the whitespace
+    // parser. The error is because the parser attempts and fails to parse the whitespace, but it's
+    // optional so it backtracks and attempts to parse the weekday (while still having leading
+    // whitespace). The weekday is also optional, so it backtracks and attempts to parse the day.
+    // This component is required, so it fails at this point.
+    assert!(matches!(
+        OffsetDateTime::parse(" \r\nM", &Rfc2822),
+        invalid_component!("day")
+    ));
+
+    assert!(matches!(
+        OffsetDateTime::parse("Mon:", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, o2", &Rfc2822),
+        invalid_component!("day")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02_", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 jxn", &Rfc2822),
+        invalid_component!("month")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan_", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan abcd", &Rfc2822),
+        invalid_component!("year")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 1899", &Rfc2822),
+        invalid_component!("year")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021_", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 21_", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 ab", &Rfc2822),
+        invalid_component!("hour")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03_", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03:ab", &Rfc2822),
+        invalid_component!("minute")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03:04_", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03:04:ab", &Rfc2822),
+        invalid_component!("second")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03:04:05_", &Rfc2822),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03:04 6", &Rfc2822),
+        invalid_component!("offset hour")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03:04:05 -6", &Rfc2822),
+        invalid_component!("offset hour")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Mon, 02 Jan 2021 03:04:05 -060", &Rfc2822),
+        invalid_component!("offset minute")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Fri, 31 Dec 2021 23:59:61 Z", &Rfc2822),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component)))
+            if component.name() == "second" && !component.is_conditional()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Fri, 31 Dec 2021 03:04:60 Z", &Rfc2822),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component)))
+            if component.name() == "second" && component.is_conditional()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("Fri, 30 Dec 2021 23:59:60 Z", &Rfc2822),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component)))
+            if component.name() == "second" && component.is_conditional()
+    ));
+}
+
+#[test]
+fn rfc_3339() -> time::Result<()> {
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-12-31T23:59:60Z", &Rfc3339)?,
+        datetime!(2021-12-31 23:59:59.999_999_999 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2015-07-01T00:59:60+01:00", &Rfc3339)?,
+        datetime!(2015-06-30 23:59:59.999_999_999 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.1Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.1 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.12Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.12 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.123Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.1234Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_4 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.12345Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_45 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.123456Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_456 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.1234567Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_456_7 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.12345678Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_456_78 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.123456789Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_456_789 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.123456789-01:02", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_456_789 -01:02),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.123456789+01:02", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123_456_789 +01:02),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05.123-00:01", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05.123 -00:01),
+    );
+
+    assert_eq!(
+        Date::parse("2021-01-02T03:04:05Z", &Rfc3339)?,
+        date!(2021 - 01 - 02),
+    );
+    assert_eq!(
+        Date::parse("2021-01-02T03:04:05.123+01:02", &Rfc3339)?,
+        date!(2021 - 01 - 02),
+    );
+    assert_eq!(
+        Date::parse("2021-01-02T03:04:05.123-01:02", &Rfc3339)?,
+        date!(2021 - 01 - 02),
+    );
+
+    assert_eq!(
+        UtcOffset::parse("2021-01-02T03:04:05Z", &Rfc3339)?,
+        offset!(UTC),
+    );
+    assert_eq!(
+        UtcOffset::parse("2021-01-02T03:04:05.123+01:02", &Rfc3339)?,
+        offset!(+01:02),
+    );
+    assert_eq!(
+        UtcOffset::parse("2021-01-02T03:04:05.123-01:02", &Rfc3339)?,
+        offset!(-01:02),
+    );
+    assert_eq!(
+        UtcOffset::parse("2021-01-02T03:04:05.123-00:01", &Rfc3339)?,
+        offset!(-00:01),
+    );
+
+    // Any separator is allowed by RFC 3339, not just `T`.
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02 03:04:05Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05 UTC),
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02$03:04:05Z", &Rfc3339)?,
+        datetime!(2021-01-02 03:04:05 UTC),
+    );
+
+    Ok(())
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn rfc_3339_err() {
+    assert!(matches!(
+        PrimitiveDateTime::parse("x", &Rfc3339),
+        invalid_component!("year")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-x", &Rfc3339),
+        invalid_component!("month")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-0", &Rfc3339),
+        invalid_component!("month")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-0", &Rfc3339),
+        invalid_component!("day")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01", &Rfc3339),
+        invalid_component!("separator")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T0", &Rfc3339),
+        invalid_component!("hour")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:0", &Rfc3339),
+        invalid_component!("minute")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:00x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:00:0", &Rfc3339),
+        invalid_component!("second")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:00:00.x", &Rfc3339),
+        invalid_component!("subsecond")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:00:00x", &Rfc3339),
+        invalid_component!("offset hour")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:00:00+0", &Rfc3339),
+        invalid_component!("offset hour")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:00:00+00x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-01T00:00:00+00:0", &Rfc3339),
+        invalid_component!("offset minute")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-13-01T00:00:00Z", &Rfc3339),
+        invalid_component!("month")
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse("2021-01-02T03:04:60Z", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "second"
+    ));
+
+    // Conversions to offset-unaware types do not perform special treatment for leap seconds
+    // even if the input could refer to one.
+    assert!(matches!(
+        PrimitiveDateTime::parse("2022-01-01T00:59:60+01:00", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "second"
+    ));
+    assert!(matches!(
+        Time::parse("2021-12-31T23:04:60Z", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "second"
+    ));
+
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-02T03:04:05Z ", &Rfc3339),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("x", &Rfc3339),
+        invalid_component!("year")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-x", &Rfc3339),
+        invalid_component!("month")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-0", &Rfc3339),
+        invalid_component!("month")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-0", &Rfc3339),
+        invalid_component!("day")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01", &Rfc3339),
+        invalid_component!("separator")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T0", &Rfc3339),
+        invalid_component!("hour")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:0", &Rfc3339),
+        invalid_component!("minute")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:0", &Rfc3339),
+        invalid_component!("second")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:00.x", &Rfc3339),
+        invalid_component!("subsecond")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:00x", &Rfc3339),
+        invalid_component!("offset hour")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:00+0", &Rfc3339),
+        invalid_component!("offset hour")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:00+00x", &Rfc3339),
+        invalid_literal!()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:00+00:0", &Rfc3339),
+        invalid_component!("offset minute")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:00+24:00", &Rfc3339),
+        invalid_component!("offset hour")
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-01T00:00:00+00:60", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "offset minute"
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-13-01T00:00:00Z", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "month"
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-12-31T23:59:61Z", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "second" && !component.is_conditional()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-02T23:59:60Z", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "second" && component.is_conditional()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-12-31T03:04:60Z", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "second" && component.is_conditional()
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-12-31T23:59:60+01:00", &Rfc3339),
+        Err(error::Parse::TryFromParsed(error::TryFromParsed::ComponentRange(component))) if component.name() == "second" && component.is_conditional()
+    ));
+}
+
+#[test]
+fn iso_8601() {
+    assert_eq!(
+        OffsetDateTime::parse("2021-01-02T03:04:05Z", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-01-02 03:04:05 UTC))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-002T03:04:05Z", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-002 03:04:05 UTC))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021-W01-2T03:04:05Z", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-W 01-2 03:04:05 UTC))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("-002021-01-02T03:04:05+01:00", &Iso8601::DEFAULT),
+        Ok(datetime!(-002021-01-02 03:04:05 +01:00))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("20210102T03.1Z", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-01-02 03:06:00 UTC))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021002T0304.1Z", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-002 03:04:06 UTC))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("2021W012T030405.1-0100", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-W 01-2 03:04:05.1 -01:00))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("20210102T03Z", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-01-02 03:00:00 UTC))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("20210102T0304Z", &Iso8601::DEFAULT),
+        Ok(datetime!(2021-01-02 03:04:00 UTC))
+    );
+    assert_eq!(UtcOffset::parse("+07", &Iso8601::DEFAULT), Ok(offset!(+7)));
+    assert_eq!(
+        UtcOffset::parse("+0304", &Iso8601::DEFAULT),
+        Ok(offset!(+03:04))
+    );
+    assert_eq!(
+        PrimitiveDateTime::parse("2022-07-22T12:52:50.349409", &Iso8601::DEFAULT),
+        Ok(datetime!(2022-07-22 12:52:50.349409000))
+    );
+}
+
+#[test]
+fn iso_8601_error() {
+    assert!(matches!(
+        OffsetDateTime::parse("20210102T03:04Z", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("20210102T03.", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-0102", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-x", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-Wx", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-W012", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-W01-x", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-02T03:x", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-02T03:04x", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("2021-01-02T03:04:", &Iso8601::DEFAULT),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("01:02", &Iso8601::DEFAULT),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+}
+
+#[test]
+fn parse_time() -> time::Result<()> {
+    let format_input_output = [
+        (fd::parse("[hour repr:12] [period]")?, "01 PM", time!(1 PM)),
+        (fd::parse("[hour]")?, "12", time!(12:00)),
+        (
+            fd::parse("[hour]:[minute]:[second]")?,
+            "13:02:03",
+            time!(13:02:03),
+        ),
+        (
+            fd::parse("[hour repr:12]:[minute] [period]")?,
+            "01:02 PM",
+            time!(1:02 PM),
+        ),
+        (fd::parse("[hour]:[minute]")?, "01:02", time!(1:02)),
+        (
+            fd::parse("[hour repr:12]:[minute] [period]")?,
+            "01:02 AM",
+            time!(1:02 AM),
+        ),
+        (fd::parse("[hour]:[minute]")?, "01:02", time!(1:02)),
+        (fd::parse("[hour repr:12] [period]")?, "12 AM", time!(12 AM)),
+        (fd::parse("[hour repr:12] [period]")?, "12 PM", time!(12 PM)),
+    ];
+
+    for (format_description, input, output) in &format_input_output {
+        assert_eq!(&Time::parse(input, format_description)?, output);
+        assert_eq!(
+            &Time::parse(input, &OwnedFormatItem::from(format_description))?,
+            output
+        );
+        assert_eq!(
+            &Time::parse(
+                input,
+                [OwnedFormatItem::from(format_description)].as_slice()
+            )?,
+            output
+        );
+    }
+
+    Ok(())
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn parse_time_err() -> time::Result<()> {
+    assert!(matches!(
+        Time::try_from(Parsed::new()),
+        Err(error::TryFromParsed::InsufficientInformation { .. })
+    ));
+    assert!(matches!(
+        Time::parse("", &fd::parse("")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("12:34", &fd::parse("[hour]:[second]")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("12:34", &fd::parse("[hour]:[subsecond]")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("13 PM", &fd::parse("[hour repr:12] [period]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("hour")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse(" ", &fd::parse("")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("a", &fd::parse("[subsecond digits:1]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("1a", &fd::parse("[subsecond digits:2]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("1a", &fd::parse_owned::<2>("[subsecond digits:2]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse(
+            "1a",
+            [fd::parse_owned::<2>("[subsecond digits:2]")?].as_slice()
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("12a", &fd::parse("[subsecond digits:3]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("123a", &fd::parse("[subsecond digits:4]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("1234a", &fd::parse("[subsecond digits:5]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("12345a", &fd::parse("[subsecond digits:6]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("123456a", &fd::parse("[subsecond digits:7]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("1234567a", &fd::parse("[subsecond digits:8]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+    assert!(matches!(
+        Time::parse("12345678a", &fd::parse("[subsecond digits:9]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("subsecond")
+        ))
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn parse_date() -> time::Result<()> {
+    let format_input_output = [
+        (
+            fd::parse("[year]-[month]-[day]")?,
+            "2021-01-02",
+            date!(2021 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-[ordinal]")?,
+            "2021-002",
+            date!(2021 - 002),
+        ),
+        (
+            fd::parse("[year base:iso_week]-W[week_number]-[weekday repr:monday]")?,
+            "2020-W53-6",
+            date!(2021 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:monday]-[weekday repr:monday]")?,
+            "2021-W00-6",
+            date!(2021 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:sunday]")?,
+            "2021-W00-6",
+            date!(2021 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:sunday]")?,
+            "2023-W01-1",
+            date!(2023 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:sunday]")?,
+            "2022-W00-7",
+            date!(2022 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:sunday]")?,
+            "2026-W00-5",
+            date!(2026 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:sunday]")?,
+            "2025-W00-4",
+            date!(2025 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:sunday]")?,
+            "2019-W00-3",
+            date!(2019 - 01 - 02),
+        ),
+        (
+            fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:sunday]")?,
+            "2018-W01-2",
+            date!(2018 - 01 - 02),
+        ),
+        (
+            fd::parse(
+                "[year padding:space]-W[week_number repr:sunday padding:none]-[weekday \
+                 repr:sunday]",
+            )?,
+            " 2018-W01-2",
+            date!(2018 - 01 - 02),
+        ),
+    ];
+
+    for (format_description, input, output) in &format_input_output {
+        assert_eq!(&Date::parse(input, format_description)?, output);
+        assert_eq!(
+            &Date::parse(input, &OwnedFormatItem::from(format_description))?,
+            output
+        );
+    }
+
+    Ok(())
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn parse_date_err() -> time::Result<()> {
+    assert!(matches!(
+        Date::try_from(Parsed::new()),
+        Err(error::TryFromParsed::InsufficientInformation { .. })
+    ));
+    assert!(matches!(
+        Date::parse("", &fd::parse("")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("a", &fd::parse("[year]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("year")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("0001", &fd::parse("[year sign:mandatory]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("year")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("0a", &fd::parse("[year repr:last_two]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("year")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("2021-366", &fd::parse("[year]-[ordinal]")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::ComponentRange(component)
+        )) if component.name() == "ordinal"
+    ));
+    assert!(matches!(
+        Date::parse("2021-12-32", &fd::parse("[year]-[month]-[day]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("day")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("2021-02-30", &fd::parse("[year]-[month]-[day]")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::ComponentRange(component)
+        )) if component.name() == "day"
+    ));
+    assert!(matches!(
+        Date::parse("2019-W53-1", &fd::parse("[year base:iso_week]-W[week_number]-[weekday repr:monday]")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::ComponentRange(component)
+        )) if component.name() == "week"
+    ));
+    assert!(matches!(
+        Date::parse(
+            "2021-W54-1",
+            &fd::parse("[year base:iso_week]-W[week_number]-[weekday repr:monday]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("week number")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("2019-W53-1", &fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:monday]")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::ComponentRange(component)
+        )) if component.name() == "ordinal"
+    ));
+    assert!(matches!(
+        Date::parse(
+            "2021-W54-1",
+            &fd::parse("[year]-W[week_number repr:sunday]-[weekday repr:monday]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("week number")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("2019-W53-1", &fd::parse("[year]-W[week_number repr:monday]-[weekday repr:monday]")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::ComponentRange(component)
+        )) if component.name() == "ordinal"
+    ));
+    assert!(matches!(
+        Date::parse(
+            "2021-W54-1",
+            &fd::parse("[year]-W[week_number repr:monday]-[weekday repr:monday]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("week number")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("Ja", &fd::parse("[month repr:short]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("month")
+        ))
+    ));
+    assert!(matches!(
+        Date::parse("  2a21", &fd::parse("[year padding:space]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("year")
+        ))
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn parse_offset() -> time::Result<()> {
+    // Regression check for #522.
+    assert_eq!(
+        UtcOffset::parse(
+            "-00:01",
+            &fd::parse("[offset_hour sign:mandatory]:[offset_minute]")?,
+        ),
+        Ok(offset!(-00:01)),
+    );
+    assert_eq!(
+        UtcOffset::parse(
+            "-00:00:01",
+            &fd::parse("[offset_hour sign:mandatory]:[offset_minute]:[offset_second]")?,
+        ),
+        Ok(offset!(-00:00:01)),
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_offset_err() -> time::Result<()> {
+    assert!(matches!(
+        UtcOffset::parse("", &fd::parse("")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+    assert_eq!(
+        UtcOffset::parse("01", &fd::parse("[offset_hour sign:mandatory]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("offset hour")
+        ))
+    );
+    assert!(matches!(
+        UtcOffset::parse("24", &fd::parse("[offset_hour]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("offset hour")
+        ))
+    ));
+    assert!(matches!(
+        UtcOffset::parse("00:60", &fd::parse("[offset_hour]:[offset_minute]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("offset minute")
+        ))
+    ));
+    assert!(matches!(
+        UtcOffset::parse(
+            "00:00:60",
+            &fd::parse("[offset_hour]:[offset_minute]:[offset_second]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("offset second")
+        ))
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn parse_primitive_date_time() -> time::Result<()> {
+    assert_eq!(
+        PrimitiveDateTime::parse("2023-07-27 23", &fd::parse("[year]-[month]-[day] [hour]")?),
+        Ok(datetime!(2023-07-27 23:00))
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_primitive_date_time_err() -> time::Result<()> {
+    assert!(matches!(
+        PrimitiveDateTime::parse("", &fd::parse("")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse(
+            "2021-001 13 PM",
+            &fd::parse("[year]-[ordinal] [hour repr:12] [period]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("hour")
+        ))
+    ));
+    assert!(matches!(
+        PrimitiveDateTime::parse(
+            "2023-07-27 23:30",
+            &fd::parse("[year]-[month]-[day] [hour]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn parse_offset_date_time_err() -> time::Result<()> {
+    assert!(matches!(
+        OffsetDateTime::parse("", &fd::parse("")?),
+        Err(error::Parse::TryFromParsed(
+            error::TryFromParsed::InsufficientInformation { .. }
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse("x", &fd::parse("[year]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("year")
+        ))
+    ));
+    assert!(matches!(
+        OffsetDateTime::parse(
+            "2021-001 12 PM +25",
+            &fd::parse("[year]-[ordinal] [hour repr:12] [period] [offset_hour sign:mandatory]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("offset hour")
+        ))
+    ));
+
+    Ok(())
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn parse_components() -> time::Result<()> {
+    macro_rules! parse_component {
+        ($component:expr, $input:expr,_. $property:ident() == $expected:expr) => {
+            let mut parsed = Parsed::new();
+            parsed.parse_component($input, $component)?;
+            assert_eq!(parsed.$property(), $expected);
+        };
+    }
+
+    parse_component!(
+        Component::Year(modifier!(Year {
+            padding: modifier::Padding::Zero,
+            repr: modifier::YearRepr::Full,
+            iso_week_based: false,
+            sign_is_mandatory: false,
+        })),
+        b"2021",
+        _.year() == Some(2021)
+    );
+    parse_component!(
+        Component::Year(modifier!(Year {
+            padding: modifier::Padding::Zero,
+            repr: modifier::YearRepr::LastTwo,
+            iso_week_based: false,
+            sign_is_mandatory: false,
+        })),
+        b"21",
+        _.year_last_two() == Some(21)
+    );
+    parse_component!(
+        Component::Year(modifier!(Year {
+            padding: modifier::Padding::Zero,
+            repr: modifier::YearRepr::Full,
+            iso_week_based: true,
+            sign_is_mandatory: false,
+        })),
+        b"2021",
+        _.iso_year() == Some(2021)
+    );
+    parse_component!(
+        Component::Year(modifier!(Year {
+            padding: modifier::Padding::Zero,
+            repr: modifier::YearRepr::LastTwo,
+            iso_week_based: true,
+            sign_is_mandatory: false,
+        })),
+        b"21",
+        _.iso_year_last_two() == Some(21)
+    );
+    parse_component!(
+        Component::Month(modifier!(Month {
+            padding: modifier::Padding::Space,
+            repr: modifier::MonthRepr::Numerical,
+        })),
+        b" 1",
+        _.month() == Some(Month::January)
+    );
+    parse_component!(
+        Component::Month(modifier!(Month {
+            padding: modifier::Padding::None,
+            repr: modifier::MonthRepr::Short,
+            case_sensitive: true,
+        })),
+        b"Jan",
+        _.month() == Some(Month::January)
+    );
+    parse_component!(
+        Component::Month(modifier!(Month {
+            padding: modifier::Padding::None,
+            repr: modifier::MonthRepr::Short,
+            case_sensitive: false,
+        })),
+        b"jAn",
+        _.month() == Some(Month::January)
+    );
+    parse_component!(
+        Component::Month(modifier!(Month {
+            padding: modifier::Padding::None,
+            repr: modifier::MonthRepr::Long,
+            case_sensitive: true,
+        })),
+        b"January",
+        _.month() == Some(Month::January)
+    );
+    parse_component!(
+        Component::Month(modifier!(Month {
+            padding: modifier::Padding::None,
+            repr: modifier::MonthRepr::Long,
+            case_sensitive: false,
+        })),
+        b"jAnUaRy",
+        _.month() == Some(Month::January)
+    );
+    parse_component!(
+        Component::Ordinal(modifier!(Ordinal {
+            padding: modifier::Padding::Zero,
+        })),
+        b"012",
+        _.ordinal() == 12.try_into().ok()
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Short,
+            one_indexed: false,
+            case_sensitive: true,
+        })),
+        b"Sun",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Short,
+            one_indexed: false,
+            case_sensitive: false,
+        })),
+        b"sUn",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Long,
+            one_indexed: false,
+            case_sensitive: true,
+        })),
+        b"Sunday",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Long,
+            one_indexed: false,
+            case_sensitive: false,
+        })),
+        b"sUnDaY",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Sunday,
+            one_indexed: false,
+        })),
+        b"0",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Sunday,
+            one_indexed: true,
+        })),
+        b"1",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Monday,
+            one_indexed: false,
+        })),
+        b"6",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::Weekday(modifier!(Weekday {
+            repr: modifier::WeekdayRepr::Monday,
+            one_indexed: true,
+        })),
+        b"7",
+        _.weekday() == Some(Weekday::Sunday)
+    );
+    parse_component!(
+        Component::WeekNumber(modifier!(WeekNumber {
+            padding: modifier::Padding::None,
+            repr: modifier::WeekNumberRepr::Sunday,
+        })),
+        b"2",
+        _.sunday_week_number() == Some(2)
+    );
+    parse_component!(
+        Component::WeekNumber(modifier!(WeekNumber {
+            padding: modifier::Padding::None,
+            repr: modifier::WeekNumberRepr::Monday,
+        })),
+        b"2",
+        _.monday_week_number() == Some(2)
+    );
+    parse_component!(
+        Component::WeekNumber(modifier!(WeekNumber {
+            padding: modifier::Padding::None,
+            repr: modifier::WeekNumberRepr::Iso,
+        })),
+        b"2",
+        _.iso_week_number() == 2.try_into().ok()
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::One
+        })),
+        b"1",
+        _.subsecond() == Some(100_000_000)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Two
+        })),
+        b"12",
+        _.subsecond() == Some(120_000_000)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Three
+        })),
+        b"123",
+        _.subsecond() == Some(123_000_000)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Four
+        })),
+        b"1234",
+        _.subsecond() == Some(123_400_000)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Five
+        })),
+        b"12345",
+        _.subsecond() == Some(123_450_000)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Six
+        })),
+        b"123456",
+        _.subsecond() == Some(123_456_000)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Seven
+        })),
+        b"1234567",
+        _.subsecond() == Some(123_456_700)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Eight
+        })),
+        b"12345678",
+        _.subsecond() == Some(123_456_780)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::Nine
+        })),
+        b"123456789",
+        _.subsecond() == Some(123_456_789)
+    );
+    parse_component!(
+        Component::Subsecond(modifier!(Subsecond {
+            digits: modifier::SubsecondDigits::OneOrMore
+        })),
+        b"123456789",
+        _.subsecond() == Some(123_456_789)
+    );
+    parse_component!(
+        Component::Period(modifier!(Period {
+            is_uppercase: false,
+            case_sensitive: true,
+        })),
+        b"am",
+        _.hour_12_is_pm() == Some(false)
+    );
+    parse_component!(
+        Component::Period(modifier!(Period {
+            is_uppercase: false,
+            case_sensitive: false,
+        })),
+        b"aM",
+        _.hour_12_is_pm() == Some(false)
+    );
+    let mut parsed = Parsed::new();
+    let result = parsed.parse_component(
+        b"abcdef",
+        Component::Ignore(Ignore::count(NonZeroU16::new(3).expect("3 is not zero"))),
+    )?;
+    assert_eq!(result, b"def");
+    let mut parsed = Parsed::new();
+    let result = parsed.parse_component(
+        b"abcdef",
+        Component::Ignore(Ignore::count(NonZeroU16::new(7).expect("7 is not zero"))),
+    );
+    assert!(matches!(
+        result,
+        Err(error::ParseFromDescription::InvalidComponent("ignore"))
+    ));
+    parse_component!(
+        Component::UnixTimestamp(modifier!(UnixTimestamp {
+            precision: modifier::UnixTimestampPrecision::Second,
+            sign_is_mandatory: false,
+        })),
+        b"1234567890",
+        _.unix_timestamp_nanos() == Some(1_234_567_890_000_000_000)
+    );
+    parse_component!(
+        Component::UnixTimestamp(modifier!(UnixTimestamp {
+            precision: modifier::UnixTimestampPrecision::Millisecond,
+            sign_is_mandatory: false,
+        })),
+        b"1234567890123",
+        _.unix_timestamp_nanos() == Some(1_234_567_890_123_000_000)
+    );
+    parse_component!(
+        Component::UnixTimestamp(modifier!(UnixTimestamp {
+            precision: modifier::UnixTimestampPrecision::Microsecond,
+            sign_is_mandatory: false,
+        })),
+        b"1234567890123456",
+        _.unix_timestamp_nanos() == Some(1_234_567_890_123_456_000)
+    );
+    parse_component!(
+        Component::UnixTimestamp(modifier!(UnixTimestamp {
+            precision: modifier::UnixTimestampPrecision::Nanosecond,
+            sign_is_mandatory: false,
+        })),
+        b"1234567890123456789",
+        _.unix_timestamp_nanos() == Some(1_234_567_890_123_456_789)
+    );
+    parse_component!(
+        Component::UnixTimestamp(modifier!(UnixTimestamp {
+            precision: modifier::UnixTimestampPrecision::Nanosecond,
+            sign_is_mandatory: false,
+        })),
+        b"-1234567890123456789",
+        _.unix_timestamp_nanos() == Some(-1_234_567_890_123_456_789)
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_optional() -> time::Result<()> {
+    // Ensure full parsing works as expected.
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01-02",
+        &BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(&fd::parse(
+            "[year]-[month]-[day]",
+        )?)),
+    )?;
+    assert!(remaining_input.is_empty());
+    assert_eq!(parsed.year(), Some(2021));
+    assert_eq!(parsed.month(), Some(Month::January));
+    assert_eq!(parsed.day().map(NonZeroU8::get), Some(2));
+
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01-02",
+        &OwnedFormatItem::from(BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(
+            &fd::parse("[year]-[month]-[day]")?,
+        ))),
+    )?;
+    assert!(remaining_input.is_empty());
+    assert_eq!(parsed.year(), Some(2021));
+    assert_eq!(parsed.month(), Some(Month::January));
+    assert_eq!(parsed.day().map(NonZeroU8::get), Some(2));
+
+    // Ensure a successful partial parse *does not* mutate `parsed`.
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01",
+        &BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(&fd::parse(
+            "[year]-[month]-[day]",
+        )?)),
+    )?;
+    assert_eq!(remaining_input, b"2021-01");
+    assert!(parsed.year().is_none());
+    assert!(parsed.month().is_none());
+    assert!(parsed.day().is_none());
+
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01",
+        &OwnedFormatItem::from(BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(
+            &fd::parse("[year]-[month]-[day]")?,
+        ))),
+    )?;
+    assert_eq!(remaining_input, b"2021-01");
+    assert!(parsed.year().is_none());
+    assert!(parsed.month().is_none());
+    assert!(parsed.day().is_none());
+
+    Ok(())
+}
+
+#[allow(clippy::cognitive_complexity)] // all test the same thing
+#[test]
+fn parse_first() -> time::Result<()> {
+    // Ensure the first item is parsed correctly.
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01-02",
+        &BorrowedFormatItem::First(&[BorrowedFormatItem::Compound(&fd::parse(
+            "[year]-[month]-[day]",
+        )?)]),
+    )?;
+    assert!(remaining_input.is_empty());
+    assert_eq!(parsed.year(), Some(2021));
+    assert_eq!(parsed.month(), Some(Month::January));
+    assert_eq!(parsed.day().map(NonZeroU8::get), Some(2));
+
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01-02",
+        &OwnedFormatItem::from(BorrowedFormatItem::First(&[BorrowedFormatItem::Compound(
+            &fd::parse("[year]-[month]-[day]")?,
+        )])),
+    )?;
+    assert!(remaining_input.is_empty());
+    assert_eq!(parsed.year(), Some(2021));
+    assert_eq!(parsed.month(), Some(Month::January));
+    assert_eq!(parsed.day().map(NonZeroU8::get), Some(2));
+
+    // Ensure an empty slice is a no-op success.
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(b"2021-01-02", &BorrowedFormatItem::First(&[]))?;
+    assert_eq!(remaining_input, b"2021-01-02");
+    assert!(parsed.year().is_none());
+    assert!(parsed.month().is_none());
+    assert!(parsed.day().is_none());
+
+    let mut parsed = Parsed::new();
+    let remaining_input =
+        parsed.parse_item(b"2021-01-02", &OwnedFormatItem::First(Box::new([])))?;
+    assert_eq!(remaining_input, b"2021-01-02");
+    assert!(parsed.year().is_none());
+    assert!(parsed.month().is_none());
+    assert!(parsed.day().is_none());
+
+    // Ensure success when the first item fails.
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01-02",
+        &BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Compound(&fd::parse("[period]")?),
+            BorrowedFormatItem::Compound(&fd::parse("x")?),
+            BorrowedFormatItem::Compound(&fd::parse("[year]-[month]-[day]")?),
+        ]),
+    )?;
+    assert!(remaining_input.is_empty());
+    assert_eq!(parsed.year(), Some(2021));
+    assert_eq!(parsed.month(), Some(Month::January));
+    assert_eq!(parsed.day().map(NonZeroU8::get), Some(2));
+
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"2021-01-02",
+        &OwnedFormatItem::from(BorrowedFormatItem::First(&[
+            BorrowedFormatItem::Compound(&fd::parse("[period]")?),
+            BorrowedFormatItem::Compound(&fd::parse("x")?),
+            BorrowedFormatItem::Compound(&fd::parse("[year]-[month]-[day]")?),
+        ])),
+    )?;
+    assert!(remaining_input.is_empty());
+    assert_eq!(parsed.year(), Some(2021));
+    assert_eq!(parsed.month(), Some(Month::January));
+    assert_eq!(parsed.day().map(NonZeroU8::get), Some(2));
+
+    // Ensure the first error is returned.
+    let mut parsed = Parsed::new();
+    let err = parsed
+        .parse_item(
+            b"2021-01-02",
+            &BorrowedFormatItem::First(&[
+                BorrowedFormatItem::Compound(&fd::parse("[period]")?),
+                BorrowedFormatItem::Compound(&fd::parse("x")?),
+            ]),
+        )
+        .expect_err("parsing should fail");
+    assert_eq!(err, error::ParseFromDescription::InvalidComponent("period"));
+
+    let mut parsed = Parsed::new();
+    let err = parsed
+        .parse_item(
+            b"2021-01-02",
+            &OwnedFormatItem::from(BorrowedFormatItem::First(&[
+                BorrowedFormatItem::Compound(&fd::parse("[period]")?),
+                BorrowedFormatItem::Compound(&fd::parse("x")?),
+            ])),
+        )
+        .expect_err("parsing should fail");
+    assert_eq!(err, error::ParseFromDescription::InvalidComponent("period"));
+
+    Ok(())
+}
+
+#[test]
+fn parse_unix_timestamp() -> time::Result<()> {
+    assert_eq!(
+        OffsetDateTime::parse("1234567890", &fd::parse("[unix_timestamp]")?)?,
+        datetime!(2009-02-13 23:31:30 UTC)
+    );
+    assert_eq!(
+        OffsetDateTime::parse(
+            "1234567890123",
+            &fd::parse("[unix_timestamp precision:millisecond]")?
+        )?,
+        datetime!(2009-02-13 23:31:30.123 UTC)
+    );
+    assert_eq!(
+        OffsetDateTime::parse(
+            "1234567890123456",
+            &fd::parse("[unix_timestamp precision:microsecond]")?
+        )?,
+        datetime!(2009-02-13 23:31:30.123456 UTC)
+    );
+    assert_eq!(
+        OffsetDateTime::parse(
+            "1234567890123456789",
+            &fd::parse("[unix_timestamp precision:nanosecond]")?
+        )?,
+        datetime!(2009-02-13 23:31:30.123456789 UTC)
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_unix_timestamp_err() -> time::Result<()> {
+    assert_eq!(
+        OffsetDateTime::parse("1234567890", &fd::parse("[unix_timestamp sign:mandatory]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("unix_timestamp")
+        ))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("a", &fd::parse("[unix_timestamp precision:second]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("unix_timestamp")
+        ))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("a", &fd::parse("[unix_timestamp precision:millisecond]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("unix_timestamp")
+        ))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("a", &fd::parse("[unix_timestamp precision:microsecond]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("unix_timestamp")
+        ))
+    );
+    assert_eq!(
+        OffsetDateTime::parse("a", &fd::parse("[unix_timestamp precision:nanosecond]")?),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::InvalidComponent("unix_timestamp")
+        ))
+    );
+
+    Ok(())
+}
+
+#[test]
+fn issue_601() {
+    let date = OffsetDateTime::parse(
+        "1234567890.123",
+        &fd::parse("[unix_timestamp].[subsecond digits:3]").expect("format description is valid"),
+    );
+
+    assert_eq!(date, Ok(datetime!(2009-02-13 23:31:30.123 +00:00:00)));
+}
+
+#[test]
+fn end() -> time::Result<()> {
+    let mut parsed = Parsed::new();
+    let remaining_input = parsed.parse_item(
+        b"",
+        &BorrowedFormatItem::Component(Component::End(modifier::End::default())),
+    );
+    assert_eq!(remaining_input, Ok(b"".as_slice()));
+
+    assert_eq!(
+        Time::parse("00:00", &fd::parse("[hour]:[minute][end]")?),
+        Ok(time!(0:00))
+    );
+    assert_eq!(
+        Time::parse(
+            "00:00:00",
+            &fd::parse_owned::<2>("[hour]:[minute][optional [[end]]]:[second]")?
+        ),
+        Ok(time!(0:00))
+    );
+    assert!(matches!(
+        Time::parse(
+            "00:00:00",
+            &fd::parse_owned::<2>("[hour]:[minute][end]:[second]")?
+        ),
+        Err(error::Parse::ParseFromDescription(
+            error::ParseFromDescription::UnexpectedTrailingCharacters { .. }
+        ))
+    ));
+
+    Ok(())
+}
diff --git a/tests/primitive_date_time.rs b/tests/primitive_date_time.rs
new file mode 100644
index 000000000..80b6da9e8
--- /dev/null
+++ b/tests/primitive_date_time.rs
@@ -0,0 +1,813 @@
+use std::cmp::Ordering;
+
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::{date, datetime, offset, time};
+use time::{Duration, Month, PrimitiveDateTime, Weekday};
+
+#[test]
+fn new() {
+    assert_eq!(
+        PrimitiveDateTime::new(date!(2019 - 01 - 01), time!(0:00)),
+        datetime!(2019-01-01 0:00),
+    );
+}
+
+#[test]
+fn date() {
+    assert_eq!(datetime!(2019-01-01 0:00).date(), date!(2019 - 01 - 01));
+}
+
+#[test]
+fn time() {
+    assert_eq!(datetime!(2019-01-01 0:00).time(), time!(0:00));
+}
+
+#[test]
+fn year() {
+    assert_eq!(datetime!(2019-01-01 0:00).year(), 2019);
+    assert_eq!(datetime!(2019-12-31 0:00).year(), 2019);
+    assert_eq!(datetime!(2020-01-01 0:00).year(), 2020);
+}
+
+#[test]
+fn month() {
+    assert_eq!(datetime!(2019-01-01 0:00).month(), Month::January);
+    assert_eq!(datetime!(2019-12-31 0:00).month(), Month::December);
+}
+
+#[test]
+fn day() {
+    assert_eq!(datetime!(2019-01-01 0:00).day(), 1);
+    assert_eq!(datetime!(2019-12-31 0:00).day(), 31);
+}
+
+#[test]
+fn ordinal() {
+    assert_eq!(datetime!(2019-01-01 0:00).ordinal(), 1);
+    assert_eq!(datetime!(2019-12-31 0:00).ordinal(), 365);
+}
+
+#[test]
+fn iso_week() {
+    assert_eq!(datetime!(2019-01-01 0:00).iso_week(), 1);
+    assert_eq!(datetime!(2019-10-04 0:00).iso_week(), 40);
+    assert_eq!(datetime!(2020-01-01 0:00).iso_week(), 1);
+    assert_eq!(datetime!(2020-12-31 0:00).iso_week(), 53);
+    assert_eq!(datetime!(2021-01-01 0:00).iso_week(), 53);
+}
+
+#[test]
+fn sunday_based_week() {
+    assert_eq!(datetime!(2019-01-01 0:00).sunday_based_week(), 0);
+    assert_eq!(datetime!(2020-01-01 0:00).sunday_based_week(), 0);
+    assert_eq!(datetime!(2020-12-31 0:00).sunday_based_week(), 52);
+    assert_eq!(datetime!(2021-01-01 0:00).sunday_based_week(), 0);
+}
+
+#[test]
+fn monday_based_week() {
+    assert_eq!(datetime!(2019-01-01 0:00).monday_based_week(), 0);
+    assert_eq!(datetime!(2020-01-01 0:00).monday_based_week(), 0);
+    assert_eq!(datetime!(2020-12-31 0:00).monday_based_week(), 52);
+    assert_eq!(datetime!(2021-01-01 0:00).monday_based_week(), 0);
+}
+
+#[test]
+fn to_calendar_date() {
+    assert_eq!(
+        datetime!(2019-01-02 0:00).to_calendar_date(),
+        (2019, Month::January, 2)
+    );
+}
+
+#[test]
+fn to_ordinal_date() {
+    assert_eq!(datetime!(2019-01-01 0:00).to_ordinal_date(), (2019, 1));
+}
+
+#[test]
+fn to_iso_week_date() {
+    use Weekday::*;
+    assert_eq!(
+        datetime!(2019-01-01 0:00).to_iso_week_date(),
+        (2019, 1, Tuesday)
+    );
+    assert_eq!(
+        datetime!(2019-10-04 0:00).to_iso_week_date(),
+        (2019, 40, Friday)
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00).to_iso_week_date(),
+        (2020, 1, Wednesday)
+    );
+    assert_eq!(
+        datetime!(2020-12-31 0:00).to_iso_week_date(),
+        (2020, 53, Thursday)
+    );
+    assert_eq!(
+        datetime!(2021-01-01 0:00).to_iso_week_date(),
+        (2020, 53, Friday)
+    );
+}
+
+#[test]
+fn weekday() {
+    use Weekday::*;
+    assert_eq!(datetime!(2019-01-01 0:00).weekday(), Tuesday);
+    assert_eq!(datetime!(2019-02-01 0:00).weekday(), Friday);
+    assert_eq!(datetime!(2019-03-01 0:00).weekday(), Friday);
+    assert_eq!(datetime!(2019-04-01 0:00).weekday(), Monday);
+    assert_eq!(datetime!(2019-05-01 0:00).weekday(), Wednesday);
+    assert_eq!(datetime!(2019-06-01 0:00).weekday(), Saturday);
+    assert_eq!(datetime!(2019-07-01 0:00).weekday(), Monday);
+    assert_eq!(datetime!(2019-08-01 0:00).weekday(), Thursday);
+    assert_eq!(datetime!(2019-09-01 0:00).weekday(), Sunday);
+    assert_eq!(datetime!(2019-10-01 0:00).weekday(), Tuesday);
+    assert_eq!(datetime!(2019-11-01 0:00).weekday(), Friday);
+    assert_eq!(datetime!(2019-12-01 0:00).weekday(), Sunday);
+}
+
+#[test]
+fn to_julian_day() {
+    assert_eq!(datetime!(-999_999-01-01 0:00).to_julian_day(), -363_521_074);
+    assert_eq!(datetime!(-4713-11-24 0:00).to_julian_day(), 0);
+    assert_eq!(datetime!(2000-01-01 0:00).to_julian_day(), 2_451_545);
+    assert_eq!(datetime!(2019-01-01 0:00).to_julian_day(), 2_458_485);
+    assert_eq!(datetime!(2019-12-31 0:00).to_julian_day(), 2_458_849);
+}
+
+#[test]
+fn as_hms() {
+    assert_eq!(datetime!(2020-01-01 1:02:03).as_hms(), (1, 2, 3));
+}
+
+#[test]
+fn as_hms_milli() {
+    assert_eq!(
+        datetime!(2020-01-01 1:02:03.004).as_hms_milli(),
+        (1, 2, 3, 4)
+    );
+}
+
+#[test]
+fn as_hms_micro() {
+    assert_eq!(
+        datetime!(2020-01-01 1:02:03.004_005).as_hms_micro(),
+        (1, 2, 3, 4_005)
+    );
+}
+
+#[test]
+fn as_hms_nano() {
+    assert_eq!(
+        datetime!(2020-01-01 1:02:03.004_005_006).as_hms_nano(),
+        (1, 2, 3, 4_005_006)
+    );
+}
+
+#[test]
+fn hour() {
+    assert_eq!(datetime!(2019-01-01 0:00).hour(), 0);
+    assert_eq!(datetime!(2019-01-01 23:59:59).hour(), 23);
+}
+
+#[test]
+fn minute() {
+    assert_eq!(datetime!(2019-01-01 0:00).minute(), 0);
+    assert_eq!(datetime!(2019-01-01 23:59:59).minute(), 59);
+}
+
+#[test]
+fn second() {
+    assert_eq!(datetime!(2019-01-01 0:00).second(), 0);
+    assert_eq!(datetime!(2019-01-01 23:59:59).second(), 59);
+}
+
+#[test]
+fn millisecond() {
+    assert_eq!(datetime!(2019-01-01 0:00).millisecond(), 0);
+    assert_eq!(datetime!(2019-01-01 23:59:59.999).millisecond(), 999);
+}
+
+#[test]
+fn microsecond() {
+    assert_eq!(datetime!(2019-01-01 0:00).microsecond(), 0);
+    assert_eq!(
+        datetime!(2019-01-01 23:59:59.999_999).microsecond(),
+        999_999
+    );
+}
+
+#[test]
+fn nanosecond() {
+    assert_eq!(datetime!(2019-01-01 0:00).nanosecond(), 0);
+    assert_eq!(
+        datetime!(2019-01-01 23:59:59.999_999_999).nanosecond(),
+        999_999_999
+    );
+}
+
+#[test]
+fn assume_offset() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00)
+            .assume_offset(offset!(UTC))
+            .unix_timestamp(),
+        1_546_300_800,
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00)
+            .assume_offset(offset!(-1))
+            .unix_timestamp(),
+        1_546_304_400,
+    );
+}
+
+#[test]
+fn assume_utc() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00).assume_utc().unix_timestamp(),
+        1_546_300_800,
+    );
+}
+
+#[test]
+fn replace_time() {
+    assert_eq!(
+        datetime!(2020-01-01 12:00).replace_time(time!(5:00)),
+        datetime!(2020-01-01 5:00)
+    );
+}
+
+#[test]
+fn replace_date() {
+    assert_eq!(
+        datetime!(2020-01-01 12:00).replace_date(date!(2020 - 01 - 30)),
+        datetime!(2020-01-30 12:00)
+    );
+}
+
+#[test]
+fn replace_year() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00).replace_year(2019),
+        Ok(datetime!(2019 - 02 - 18 12:00))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 12:00)
+            .replace_year(-1_000_000_000)
+            .is_err()
+    ); // -1_000_000_000 isn't a valid year
+    assert!(
+        datetime!(2022 - 02 - 18 12:00)
+            .replace_year(1_000_000_000)
+            .is_err()
+    ); // 1_000_000_000 isn't a valid year
+}
+
+#[test]
+fn replace_month() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00).replace_month(Month::January),
+        Ok(datetime!(2022 - 01 - 18 12:00))
+    );
+    assert!(
+        datetime!(2022 - 01 - 30 12:00)
+            .replace_month(Month::February)
+            .is_err()
+    ); // 30 isn't a valid day in February
+}
+
+#[test]
+fn replace_day() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00).replace_day(1),
+        Ok(datetime!(2022 - 02 - 01 12:00))
+    );
+    assert!(datetime!(2022 - 02 - 18 12:00).replace_day(0).is_err()); // 00 isn't a valid day
+    assert!(datetime!(2022 - 02 - 18 12:00).replace_day(30).is_err()); // 30 isn't a valid day in February
+}
+
+#[test]
+fn replace_ordinal() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 12:00).replace_ordinal(1),
+        Ok(datetime!(2022 - 001 12:00))
+    );
+    assert_eq!(
+        datetime!(2024 - 02 - 29 12:00).replace_ordinal(366),
+        Ok(datetime!(2024 - 366 12:00))
+    );
+    assert!(datetime!(2022 - 049 12:00).replace_ordinal(0).is_err()); // 0 isn't a valid day
+    assert!(datetime!(2022 - 049 12:00).replace_ordinal(366).is_err()); // 2022 isn't a leap year
+    assert!(datetime!(2022 - 049 12:00).replace_ordinal(367).is_err()); // 367 isn't a valid day
+}
+
+#[test]
+fn replace_hour() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_hour(7),
+        Ok(datetime!(2022 - 02 - 18 07:02:03.004_005_006))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006)
+            .replace_hour(24)
+            .is_err()
+    ); // 24 isn't a valid hour
+}
+
+#[test]
+fn replace_minute() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_minute(7),
+        Ok(datetime!(2022 - 02 - 18 01:07:03.004_005_006))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006)
+            .replace_minute(60)
+            .is_err()
+    ); // 60 isn't a valid minute
+}
+
+#[test]
+fn replace_second() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_second(7),
+        Ok(datetime!(2022 - 02 - 18 01:02:07.004_005_006))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006)
+            .replace_second(60)
+            .is_err()
+    ); // 60 isn't a valid second
+}
+
+#[test]
+fn replace_millisecond() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_millisecond(7),
+        Ok(datetime!(2022 - 02 - 18 01:02:03.007))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006)
+            .replace_millisecond(1_000)
+            .is_err()
+    ); // 1_000 isn't a valid millisecond
+}
+
+#[test]
+fn replace_microsecond() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_microsecond(7_008),
+        Ok(datetime!(2022 - 02 - 18 01:02:03.007_008))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006)
+            .replace_microsecond(1_000_000)
+            .is_err()
+    ); // 1_000_000 isn't a valid microsecond
+}
+
+#[test]
+fn replace_nanosecond() {
+    assert_eq!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_nanosecond(7_008_009),
+        Ok(datetime!(2022 - 02 - 18 01:02:03.007_008_009))
+    );
+    assert!(
+        datetime!(2022 - 02 - 18 01:02:03.004_005_006)
+            .replace_nanosecond(1_000_000_000)
+            .is_err()
+    ); // 1_000_000_000 isn't a valid nanosecond
+}
+
+#[test]
+fn add_duration() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00) + 5.days(),
+        datetime!(2019-01-06 0:00),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 0:00) + 1.days(),
+        datetime!(2020-01-01 0:00),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 23:59:59) + 2.seconds(),
+        datetime!(2020-01-01 0:00:01),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00:01) + (-2).seconds(),
+        datetime!(2019-12-31 23:59:59),
+    );
+    assert_eq!(
+        datetime!(1999-12-31 23:00) + 1.hours(),
+        datetime!(2000-01-01 0:00),
+    );
+}
+
+#[test]
+fn add_std_duration() {
+    assert_eq!(
+        datetime!(2019-01-01 0:00) + 5.std_days(),
+        datetime!(2019-01-06 0:00),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 0:00) + 1.std_days(),
+        datetime!(2020-01-01 0:00),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 23:59:59) + 2.std_seconds(),
+        datetime!(2020-01-01 0:00:01),
+    );
+}
+
+#[test]
+fn add_assign_duration() {
+    let mut new_years_day_2019 = datetime!(2019-01-01 0:00);
+    new_years_day_2019 += 5.days();
+    assert_eq!(new_years_day_2019, datetime!(2019-01-06 0:00));
+
+    let mut new_years_eve_2020_days = datetime!(2019-12-31 0:00);
+    new_years_eve_2020_days += 1.days();
+    assert_eq!(new_years_eve_2020_days, datetime!(2020-01-01 0:00));
+
+    let mut new_years_eve_2020_seconds = datetime!(2019-12-31 23:59:59);
+    new_years_eve_2020_seconds += 2.seconds();
+    assert_eq!(new_years_eve_2020_seconds, datetime!(2020-01-01 0:00:01));
+
+    let mut new_years_day_2020_days = datetime!(2020-01-01 0:00:01);
+    new_years_day_2020_days += (-2).seconds();
+    assert_eq!(new_years_day_2020_days, datetime!(2019-12-31 23:59:59));
+}
+
+#[test]
+fn add_assign_std_duration() {
+    let mut ny19 = datetime!(2019-01-01 0:00);
+    ny19 += 5.std_days();
+    assert_eq!(ny19, datetime!(2019-01-06 0:00));
+
+    let mut nye20 = datetime!(2019-12-31 0:00);
+    nye20 += 1.std_days();
+    assert_eq!(nye20, datetime!(2020-01-01 0:00));
+
+    let mut nye20t = datetime!(2019-12-31 23:59:59);
+    nye20t += 2.std_seconds();
+    assert_eq!(nye20t, datetime!(2020-01-01 0:00:01));
+}
+
+#[test]
+fn sub_duration() {
+    assert_eq!(
+        datetime!(2019-01-06 0:00) - 5.days(),
+        datetime!(2019-01-01 0:00),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00) - 1.days(),
+        datetime!(2019-12-31 0:00),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00:01) - 2.seconds(),
+        datetime!(2019-12-31 23:59:59),
+    );
+    assert_eq!(
+        datetime!(2019-12-31 23:59:59) - (-2).seconds(),
+        datetime!(2020-01-01 0:00:01),
+    );
+    assert_eq!(
+        datetime!(1999-12-31 23:00) - (-1).hours(),
+        datetime!(2000-01-01 0:00),
+    );
+}
+
+#[test]
+fn sub_std_duration() {
+    assert_eq!(
+        datetime!(2019-01-06 0:00) - 5.std_days(),
+        datetime!(2019-01-01 0:00),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00) - 1.std_days(),
+        datetime!(2019-12-31 0:00),
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00:01) - 2.std_seconds(),
+        datetime!(2019-12-31 23:59:59),
+    );
+}
+
+#[test]
+fn sub_assign_duration() {
+    let mut new_years_day_2019 = datetime!(2019-01-06 0:00);
+    new_years_day_2019 -= 5.days();
+    assert_eq!(new_years_day_2019, datetime!(2019-01-01 0:00));
+
+    let mut new_years_day_2020_days = datetime!(2020-01-01 0:00);
+    new_years_day_2020_days -= 1.days();
+    assert_eq!(new_years_day_2020_days, datetime!(2019-12-31 0:00));
+
+    let mut new_years_day_2020_seconds = datetime!(2020-01-01 0:00:01);
+    new_years_day_2020_seconds -= 2.seconds();
+    assert_eq!(new_years_day_2020_seconds, datetime!(2019-12-31 23:59:59));
+
+    let mut new_years_eve_2020_seconds = datetime!(2019-12-31 23:59:59);
+    new_years_eve_2020_seconds -= (-2).seconds();
+    assert_eq!(new_years_eve_2020_seconds, datetime!(2020-01-01 0:00:01));
+}
+
+#[test]
+fn sub_assign_std_duration() {
+    let mut ny19 = datetime!(2019-01-06 0:00);
+    ny19 -= 5.std_days();
+    assert_eq!(ny19, datetime!(2019-01-01 0:00));
+
+    let mut ny20 = datetime!(2020-01-01 0:00);
+    ny20 -= 1.std_days();
+    assert_eq!(ny20, datetime!(2019-12-31 0:00));
+
+    let mut ny20t = datetime!(2020-01-01 0:00:01);
+    ny20t -= 2.std_seconds();
+    assert_eq!(ny20t, datetime!(2019-12-31 23:59:59));
+}
+
+#[test]
+fn sub_datetime() {
+    assert_eq!(
+        datetime!(2019-01-02 0:00) - datetime!(2019-01-01 0:00),
+        1.days()
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00) - datetime!(2019-01-02 0:00),
+        (-1).days()
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00) - datetime!(2019-12-31 0:00),
+        1.days()
+    );
+    assert_eq!(
+        datetime!(2019-12-31 0:00) - datetime!(2020-01-01 0:00),
+        (-1).days()
+    );
+}
+
+#[test]
+fn ord() {
+    use Ordering::*;
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Equal)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2020-01-01 0:00)),
+        Some(Less)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-02-01 0:00)),
+        Some(Less)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-02 0:00)),
+        Some(Less)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 1:00)),
+        Some(Less)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:01)),
+        Some(Less)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00:01)),
+        Some(Less)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00:00.000_000_001)),
+        Some(Less)
+    );
+    assert_eq!(
+        datetime!(2020-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Greater)
+    );
+    assert_eq!(
+        datetime!(2019-02-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Greater)
+    );
+    assert_eq!(
+        datetime!(2019-01-02 0:00).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Greater)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 1:00).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Greater)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:01).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Greater)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00:01).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Greater)
+    );
+    assert_eq!(
+        datetime!(2019-01-01 0:00:00.000_000_001).partial_cmp(&datetime!(2019-01-01 0:00)),
+        Some(Greater)
+    );
+}
+
+#[test]
+fn checked_add_duration() {
+    // Successful addition
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add(5.nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.450_000_005))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add(4.seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:57.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add(2.days()),
+        Some(datetime!(2021 - 10 - 27 14:01:53.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add(1.weeks()),
+        Some(datetime!(2021 - 11 - 01 14:01:53.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add((-5).nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.449_999_995))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add((-4).seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:49.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add((-2).days()),
+        Some(datetime!(2021 - 10 - 23 14:01:53.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_add((-1).weeks()),
+        Some(datetime!(2021 - 10 - 18 14:01:53.45))
+    );
+
+    // Addition with underflow
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00).checked_add((-1).nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00).checked_add(Duration::MIN),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_990 - 01 - 01 0:00).checked_add((-530).weeks()),
+        None
+    );
+
+    // Addition with overflow
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999).checked_add(1.nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999).checked_add(Duration::MAX),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_990 - 12 - 31 23:59:59.999_999_999).checked_add(530.weeks()),
+        None
+    );
+}
+
+#[test]
+fn checked_sub_duration() {
+    // Successful subtraction
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub((-5).nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.450_000_005))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub((-4).seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:57.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub((-2).days()),
+        Some(datetime!(2021 - 10 - 27 14:01:53.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub((-1).weeks()),
+        Some(datetime!(2021 - 11 - 01 14:01:53.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub(5.nanoseconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:53.449_999_995))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub(4.seconds()),
+        Some(datetime!(2021 - 10 - 25 14:01:49.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub(2.days()),
+        Some(datetime!(2021 - 10 - 23 14:01:53.45))
+    );
+    assert_eq!(
+        datetime!(2021 - 10 - 25 14:01:53.45).checked_sub(1.weeks()),
+        Some(datetime!(2021 - 10 - 18 14:01:53.45))
+    );
+
+    // Subtraction with underflow
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00).checked_sub(1.nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_999 - 01 - 01 0:00).checked_sub(Duration::MAX),
+        None
+    );
+    assert_eq!(
+        datetime!(-999_990 - 01 - 01 0:00).checked_sub(530.weeks()),
+        None
+    );
+
+    // Subtraction with overflow
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999).checked_sub((-1).nanoseconds()),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_999 - 12 - 31 23:59:59.999_999_999).checked_sub(Duration::MIN),
+        None
+    );
+    assert_eq!(
+        datetime!(+999_990 - 12 - 31 23:59:59.999_999_999).checked_sub((-530).weeks()),
+        None
+    );
+}
+
+#[test]
+fn saturating_add_duration() {
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47).saturating_add(2.days()),
+        datetime!(2021 - 11 - 14 17:47)
+    );
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47).saturating_add((-2).days()),
+        datetime!(2021 - 11 - 10 17:47)
+    );
+
+    // Adding with underflow
+    assert_eq!(
+        PrimitiveDateTime::MIN.saturating_add((-10).days()),
+        PrimitiveDateTime::MIN
+    );
+
+    // Adding with overflow
+    assert_eq!(
+        PrimitiveDateTime::MAX.saturating_add(10.days()),
+        PrimitiveDateTime::MAX
+    );
+
+    // Adding zero duration at boundaries
+    assert_eq!(
+        PrimitiveDateTime::MIN.saturating_add(Duration::ZERO),
+        PrimitiveDateTime::MIN
+    );
+    assert_eq!(
+        PrimitiveDateTime::MAX.saturating_add(Duration::ZERO),
+        PrimitiveDateTime::MAX
+    );
+}
+
+#[test]
+fn saturating_sub_duration() {
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47).saturating_sub(2.days()),
+        datetime!(2021 - 11 - 10 17:47)
+    );
+    assert_eq!(
+        datetime!(2021 - 11 - 12 17:47).saturating_sub((-2).days()),
+        datetime!(2021 - 11 - 14 17:47)
+    );
+
+    // Subtracting with underflow
+    assert_eq!(
+        PrimitiveDateTime::MIN.saturating_sub(10.days()),
+        PrimitiveDateTime::MIN
+    );
+
+    // Subtracting with overflow
+    assert_eq!(
+        PrimitiveDateTime::MAX.saturating_sub((-10).days()),
+        PrimitiveDateTime::MAX
+    );
+
+    // Subtracting zero duration at boundaries
+    assert_eq!(
+        PrimitiveDateTime::MIN.saturating_sub(Duration::ZERO),
+        PrimitiveDateTime::MIN
+    );
+    assert_eq!(
+        PrimitiveDateTime::MAX.saturating_sub(Duration::ZERO),
+        PrimitiveDateTime::MAX
+    );
+}
diff --git a/tests/quickcheck.rs b/tests/quickcheck.rs
new file mode 100644
index 000000000..5823111b1
--- /dev/null
+++ b/tests/quickcheck.rs
@@ -0,0 +1,357 @@
+use num_conv::prelude::*;
+use quickcheck::{Arbitrary, TestResult};
+use quickcheck_macros::quickcheck;
+use time::macros::time;
+use time::Weekday::*;
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+macro_rules! test_shrink {
+    ($type:ty,
+     $fn_name:ident,
+     $($method:ident()).+
+     $(, min=$min_value:literal)?
+    ) => {
+        #[quickcheck]
+        fn $fn_name(v: $type) -> TestResult {
+            let method_value = v.$($method()).+;
+            if method_value == test_shrink!(@min_or_zero $($min_value)?) {
+                TestResult::discard()
+            } else {
+                TestResult::from_bool(v.shrink().any(|shrunk|
+                    if method_value > 0 {
+                        shrunk.$($method()).+ < v.$($method()).+
+                    } else {
+                        shrunk.$($method()).+ > v.$($method()).+
+                    }
+                ))
+            }
+        }
+    };
+    (@min_or_zero) => { 0 };
+    (@min_or_zero $min:literal) => { $min };
+}
+
+macro_rules! no_panic {
+    ($($x:tt)*) => {
+        std::panic::catch_unwind(|| {
+            $($x)*
+        })
+        .is_ok()
+    }
+}
+
+#[quickcheck]
+fn date_yo_roundtrip(d: Date) -> bool {
+    Date::from_ordinal_date(d.year(), d.ordinal()) == Ok(d)
+}
+
+#[quickcheck]
+fn date_ymd_roundtrip(d: Date) -> bool {
+    Date::from_calendar_date(d.year(), d.month(), d.day()) == Ok(d)
+}
+
+#[quickcheck]
+fn date_ywd_roundtrip(d: Date) -> bool {
+    let (year, week, weekday) = d.to_iso_week_date();
+    Date::from_iso_week_date(year, week, weekday) == Ok(d)
+}
+
+#[quickcheck]
+fn julian_day_roundtrip(d: Date) -> bool {
+    Date::from_julian_day(d.to_julian_day()) == Ok(d)
+}
+
+#[quickcheck]
+fn duration_roundtrip(d: Duration) -> bool {
+    Duration::new(d.whole_seconds(), d.subsec_nanoseconds()) == d
+}
+
+#[quickcheck]
+fn time_roundtrip(t: Time) -> bool {
+    Time::from_hms_nano(t.hour(), t.minute(), t.second(), t.nanosecond()) == Ok(t)
+}
+
+#[quickcheck]
+fn primitive_date_time_roundtrip(a: PrimitiveDateTime) -> bool {
+    PrimitiveDateTime::new(a.date(), a.time()) == a
+}
+
+#[quickcheck]
+fn utc_offset_roundtrip(o: UtcOffset) -> bool {
+    let (hours, minutes, seconds) = o.as_hms();
+    UtcOffset::from_hms(hours, minutes, seconds) == Ok(o)
+}
+
+#[quickcheck]
+fn offset_date_time_roundtrip(a: OffsetDateTime) -> TestResult {
+    // Values near the edge of what is allowed may panic if the conversion brings the underlying
+    // value outside the valid range of values.
+    if a.date() == Date::MIN || a.date() == Date::MAX {
+        return TestResult::discard();
+    }
+
+    TestResult::from_bool(PrimitiveDateTime::new(a.date(), a.time()).assume_offset(a.offset()) == a)
+}
+
+#[quickcheck]
+fn unix_timestamp_roundtrip(odt: OffsetDateTime) -> TestResult {
+    match odt.date() {
+        Date::MIN | Date::MAX => TestResult::discard(),
+        _ => TestResult::from_bool({
+            // nanoseconds are not stored in the basic Unix timestamp
+            let odt = odt - Duration::nanoseconds(odt.nanosecond().into());
+            OffsetDateTime::from_unix_timestamp(odt.unix_timestamp()) == Ok(odt)
+        }),
+    }
+}
+
+#[quickcheck]
+fn unix_timestamp_nanos_roundtrip(odt: OffsetDateTime) -> TestResult {
+    match odt.date() {
+        Date::MIN | Date::MAX => TestResult::discard(),
+        _ => TestResult::from_bool(
+            OffsetDateTime::from_unix_timestamp_nanos(odt.unix_timestamp_nanos()) == Ok(odt),
+        ),
+    }
+}
+
+#[quickcheck]
+fn number_from_monday_roundtrip(w: Weekday) -> bool {
+    Monday.nth_next(w.number_from_monday() + 7 - 1) == w
+}
+
+#[quickcheck]
+fn number_from_sunday_roundtrip(w: Weekday) -> bool {
+    Sunday.nth_next(w.number_from_sunday() + 7 - 1) == w
+}
+
+#[quickcheck]
+fn number_days_from_monday_roundtrip(w: Weekday) -> bool {
+    Monday.nth_next(w.number_days_from_monday()) == w
+}
+
+#[quickcheck]
+fn number_days_from_sunday_roundtrip(w: Weekday) -> bool {
+    Sunday.nth_next(w.number_days_from_sunday()) == w
+}
+
+#[quickcheck]
+fn weekday_supports_arbitrary(w: Weekday) -> bool {
+    (1..=7).contains(&w.number_from_monday())
+}
+
+#[quickcheck]
+fn weekday_can_shrink(w: Weekday) -> bool {
+    match w {
+        Monday => w.shrink().next().is_none(),
+        _ => w.shrink().next() == Some(w.previous()),
+    }
+}
+
+#[quickcheck]
+fn month_supports_arbitrary(m: Month) -> bool {
+    (1..=12).contains(&u8::from(m))
+}
+
+#[quickcheck]
+fn month_can_shrink(m: Month) -> bool {
+    match m {
+        Month::January => m.shrink().next().is_none(),
+        _ => m.shrink().next() == Some(m.previous()),
+    }
+}
+
+#[quickcheck]
+fn date_replace_year(date: Date, year: i32) -> bool {
+    date.replace_year(year) == Date::from_calendar_date(year, date.month(), date.day())
+}
+
+#[quickcheck]
+fn date_replace_month(date: Date, month: Month) -> bool {
+    date.replace_month(month) == Date::from_calendar_date(date.year(), month, date.day())
+}
+
+#[quickcheck]
+fn date_replace_day(date: Date, day: u8) -> bool {
+    date.replace_day(day) == Date::from_calendar_date(date.year(), date.month(), day)
+}
+
+#[quickcheck]
+fn time_replace_hour(time: Time, hour: u8) -> bool {
+    time.replace_hour(hour)
+        == Time::from_hms_nano(hour, time.minute(), time.second(), time.nanosecond())
+}
+
+#[quickcheck]
+fn pdt_replace_year(pdt: PrimitiveDateTime, year: i32) -> bool {
+    pdt.replace_year(year)
+        == Date::from_calendar_date(year, pdt.month(), pdt.day())
+            .map(|date| date.with_time(pdt.time()))
+}
+
+#[quickcheck]
+fn pdt_replace_month(pdt: PrimitiveDateTime, month: Month) -> bool {
+    pdt.replace_month(month)
+        == Date::from_calendar_date(pdt.year(), month, pdt.day())
+            .map(|date| date.with_time(pdt.time()))
+}
+
+#[quickcheck]
+fn pdt_replace_day(pdt: PrimitiveDateTime, day: u8) -> bool {
+    pdt.replace_day(day)
+        == Date::from_calendar_date(pdt.year(), pdt.month(), day)
+            .map(|date| date.with_time(pdt.time()))
+}
+
+// Regression test for #481
+#[quickcheck]
+fn time_sub_time_no_panic(time_a: Time, time_b: Time) -> bool {
+    no_panic! {
+        let _ = time_a - time_b;
+        let _ = time_b - time_a;
+    }
+}
+
+#[quickcheck]
+fn from_julian_day_no_panic(julian_day: i32) -> TestResult {
+    if !(Date::MIN.to_julian_day()..=Date::MAX.to_julian_day()).contains(&julian_day) {
+        return TestResult::discard();
+    }
+
+    TestResult::from_bool(
+        std::panic::catch_unwind(|| {
+            let _ = Date::from_julian_day(julian_day);
+        })
+        .is_ok(),
+    )
+}
+
+#[quickcheck]
+fn odt_eq_no_panic(left: OffsetDateTime, right: OffsetDateTime) -> bool {
+    no_panic! {
+        let _ = left == right;
+    }
+}
+
+#[quickcheck]
+fn odt_ord_no_panic(left: OffsetDateTime, right: OffsetDateTime) -> bool {
+    no_panic! {
+        let _ = left < right;
+        let _ = left > right;
+    }
+}
+
+#[quickcheck]
+fn odt_sub_no_panic(left: OffsetDateTime, right: OffsetDateTime) -> bool {
+    no_panic! {
+        let _ = left - right;
+    }
+}
+
+#[quickcheck]
+fn odt_to_offset_no_panic(odt: OffsetDateTime, offset: UtcOffset) -> TestResult {
+    if Date::MIN
+        .midnight()
+        .assume_utc()
+        .checked_add(Duration::seconds(offset.whole_seconds().extend()))
+        .is_none()
+        || Date::MAX
+            .with_time(time!(23:59:59.999_999_999))
+            .assume_utc()
+            .checked_add(Duration::seconds(offset.whole_seconds().extend()))
+            .is_none()
+    {
+        return TestResult::discard();
+    }
+
+    TestResult::from_bool(no_panic! {
+        let _ = odt.to_offset(offset);
+    })
+}
+
+#[quickcheck]
+fn odt_replace_offset_no_panic(odt: OffsetDateTime, offset: UtcOffset) -> TestResult {
+    if Date::MIN
+        .midnight()
+        .assume_offset(odt.offset())
+        .checked_add(Duration::seconds(offset.whole_seconds().extend()))
+        .is_none()
+        || Date::MAX
+            .with_time(time!(23:59:59.999_999_999))
+            .assume_offset(odt.offset())
+            .checked_add(Duration::seconds(offset.whole_seconds().extend()))
+            .is_none()
+    {
+        return TestResult::discard();
+    }
+
+    TestResult::from_bool(no_panic! {
+        let _ = odt.replace_offset(offset);
+    })
+}
+
+test_shrink!(Date, date_can_shrink_year, year());
+test_shrink!(Date, date_can_shrink_ordinal, ordinal(), min = 1);
+
+test_shrink!(Duration, duration_can_shrink_seconds, whole_seconds());
+test_shrink!(Duration, duration_can_shrink_ns, subsec_nanoseconds());
+
+test_shrink!(Time, time_can_shrink_hour, hour());
+test_shrink!(Time, time_can_shrink_minute, minute());
+test_shrink!(Time, time_can_shrink_second, second());
+test_shrink!(Time, time_can_shrink_nanosecond, nanosecond());
+
+test_shrink!(
+    PrimitiveDateTime,
+    primitive_date_time_can_shrink_year,
+    year()
+);
+test_shrink!(
+    PrimitiveDateTime,
+    primitive_date_time_can_shrink_ordinal,
+    ordinal(),
+    min = 1
+);
+test_shrink!(
+    PrimitiveDateTime,
+    primitive_date_time_can_shrink_hour,
+    hour()
+);
+test_shrink!(
+    PrimitiveDateTime,
+    primitive_date_time_can_shrink_minute,
+    minute()
+);
+test_shrink!(
+    PrimitiveDateTime,
+    primitive_date_time_can_shrink_second,
+    second()
+);
+test_shrink!(
+    PrimitiveDateTime,
+    primitive_date_time_can_shrink_nanosecond,
+    nanosecond()
+);
+
+test_shrink!(UtcOffset, utc_offset_can_shrink, whole_seconds());
+
+test_shrink!(
+    OffsetDateTime,
+    offset_date_time_can_shrink_offset,
+    offset().whole_seconds()
+);
+test_shrink!(OffsetDateTime, offset_date_time_can_shrink_year, year());
+test_shrink!(
+    OffsetDateTime,
+    offset_date_time_can_shrink_ordinal,
+    ordinal(),
+    min = 1
+);
+test_shrink!(OffsetDateTime, offset_date_time_can_shrink_hour, hour());
+test_shrink!(OffsetDateTime, offset_date_time_can_shrink_minute, minute());
+test_shrink!(OffsetDateTime, offset_date_time_can_shrink_second, second());
+test_shrink!(
+    OffsetDateTime,
+    offset_date_time_can_shrink_nanosecond,
+    nanosecond()
+);
diff --git a/tests/rand.rs b/tests/rand.rs
new file mode 100644
index 000000000..9e6dce6f3
--- /dev/null
+++ b/tests/rand.rs
@@ -0,0 +1,21 @@
+use rand::Rng;
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+#[test]
+fn support() {
+    // Work around rust-random/rand#1020.
+    let mut rng = rand::rngs::mock::StepRng::new(0, 656_175_560);
+
+    for _ in 0..7 {
+        let _ = rng.r#gen::<Weekday>();
+    }
+    for _ in 0..12 {
+        let _ = rng.r#gen::<Month>();
+    }
+    let _ = rng.r#gen::<Time>();
+    let _ = rng.r#gen::<Date>();
+    let _ = rng.r#gen::<UtcOffset>();
+    let _ = rng.r#gen::<PrimitiveDateTime>();
+    let _ = rng.r#gen::<OffsetDateTime>();
+    let _ = rng.r#gen::<Duration>();
+}
diff --git a/tests/serde/error_conditions.rs b/tests/serde/error_conditions.rs
new file mode 100644
index 000000000..e2aed9d66
--- /dev/null
+++ b/tests/serde/error_conditions.rs
@@ -0,0 +1,46 @@
+use serde::{Deserialize, Serialize, Serializer};
+use serde_test::{assert_ser_tokens_error, Token};
+use time::macros::{datetime, format_description};
+use time::{error, OffsetDateTime};
+
+/// Trigger `time::error::Format::StdIo` errors.
+///
+/// `StdIo` won't be reached during normal serde operation: it's instantiated
+/// only during calls to `format_into()`, but most `Serializable`
+/// implementations will only call `format()` because serde `Serializer`
+/// interface doesn't expose the underlying `io::Write`.
+///
+/// Therefore, we need a contrived serializer to trigger coverage.
+fn serialize<S: Serializer>(datetime: &OffsetDateTime, _serializer: S) -> Result<S::Ok, S::Error> {
+    Err(datetime
+        .format_into(
+            &mut [0u8; 0].as_mut_slice(),
+            format_description!("nonempty format description"),
+        )
+        .map_err(error::Format::into_invalid_serde_value::<S>)
+        .expect_err("Writing to a zero-length buffer should always error."))
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct TestBadIo {
+    #[serde(serialize_with = "serialize")]
+    dt: OffsetDateTime,
+}
+
+#[test]
+fn custom_serialize_io_error() {
+    let value = TestBadIo {
+        dt: datetime!(2000-01-01 00:00 -4:00),
+    };
+    assert_ser_tokens_error::<TestBadIo>(
+        &value,
+        &[
+            Token::Struct {
+                name: "TestBadIo",
+                len: 1,
+            },
+            Token::Str("dt"),
+        ],
+        "failed to write whole buffer",
+    );
+}
diff --git a/tests/serde/iso8601.rs b/tests/serde/iso8601.rs
new file mode 100644
index 000000000..096d09caa
--- /dev/null
+++ b/tests/serde/iso8601.rs
@@ -0,0 +1,113 @@
+use serde::{Deserialize, Serialize};
+use serde_test::{
+    assert_de_tokens_error, assert_ser_tokens_error, assert_tokens, Configure, Token,
+};
+use time::macros::datetime;
+use time::serde::iso8601;
+use time::OffsetDateTime;
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct Test {
+    #[serde(with = "iso8601")]
+    dt: OffsetDateTime,
+    #[serde(with = "iso8601::option")]
+    option_dt: Option<OffsetDateTime>,
+}
+
+#[test]
+fn serialize() {
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 UTC),
+        option_dt: Some(datetime!(2000-01-01 00:00:00 UTC)),
+    };
+    assert_tokens(
+        &value.compact(),
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("+002000-01-01T00:00:00.000000000Z"),
+            Token::Str("option_dt"),
+            Token::Some,
+            Token::BorrowedStr("+002000-01-01T00:00:00.000000000Z"),
+            Token::StructEnd,
+        ],
+    );
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 UTC),
+        option_dt: None,
+    };
+    assert_tokens(
+        &value.compact(),
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("+002000-01-01T00:00:00.000000000Z"),
+            Token::Str("option_dt"),
+            Token::None,
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn serialize_error() {
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 +00:00:01),
+        option_dt: None,
+    };
+    assert_ser_tokens_error::<Test>(
+        &value,
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+        ],
+        "The offset_second component cannot be formatted into the requested format.",
+    );
+}
+
+#[test]
+fn deserialize_error() {
+    assert_de_tokens_error::<Test>(
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("bad"),
+            Token::StructEnd,
+        ],
+        "the 'year' component could not be parsed",
+    );
+}
+
+#[test]
+fn issue_674_leap_second_support() {
+    serde_test::assert_de_tokens::<Test>(
+        &Test {
+            dt: datetime!(2016-12-31 23:59:59.999999999 UTC),
+            option_dt: Some(datetime!(2016-12-31 23:59:59.999999999 UTC)),
+        },
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("2016-12-31T23:59:60.000Z"),
+            Token::Str("option_dt"),
+            Token::Some,
+            Token::BorrowedStr("2016-12-31T23:59:60.000Z"),
+            Token::StructEnd,
+        ],
+    );
+}
diff --git a/tests/serde/json.rs b/tests/serde/json.rs
new file mode 100644
index 000000000..6c708d020
--- /dev/null
+++ b/tests/serde/json.rs
@@ -0,0 +1,148 @@
+use std::error::Error;
+
+use serde::{Deserialize, Serialize};
+use serde_test::Configure;
+use time::macros::{date, datetime, time};
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, Weekday};
+
+enum Format {
+    Compact,
+    Readable,
+}
+
+use Format::*;
+
+fn serialize<T: Serialize>(val: T) -> Result<String, Box<dyn Error>> {
+    let mut buf: Vec<u8> = Vec::new();
+    let mut ser = serde_json::Serializer::new(&mut buf);
+    val.serialize(&mut ser)?;
+    let str = String::from_utf8(buf)?;
+    Ok(str)
+}
+
+fn deserialize<'a, T: Deserialize<'a>>(from: &'a str, fmt: Format) -> serde_json::Result<T> {
+    let mut de = serde_json::Deserializer::from_str(from);
+    match fmt {
+        Compact => T::deserialize((&mut de).compact()),
+        Readable => T::deserialize((&mut de).readable()),
+    }
+}
+
+#[test]
+fn weekday_json() -> Result<(), Box<dyn Error>> {
+    use Weekday::*;
+
+    assert_eq!(serialize(Monday.compact())?, "1");
+    assert_eq!(deserialize::<Weekday>("1", Compact)?, Monday);
+
+    assert_eq!(serialize(Monday.readable())?, "\"Monday\"");
+    assert_eq!(deserialize::<Weekday>("\"Monday\"", Readable)?, Monday);
+    assert_eq!(deserialize::<Weekday>("1", Readable)?, Monday);
+
+    Ok(())
+}
+
+#[test]
+fn month_json() -> Result<(), Box<dyn Error>> {
+    use Month::*;
+
+    assert_eq!(serialize(March.compact())?, "3");
+    assert_eq!(deserialize::<Month>("3", Compact)?, March);
+
+    assert_eq!(serialize(March.readable())?, "\"March\"");
+    assert_eq!(deserialize::<Month>("\"March\"", Readable)?, March);
+    assert_eq!(deserialize::<Month>("3", Readable)?, March);
+
+    Ok(())
+}
+
+#[test]
+fn time_json() -> Result<(), Box<dyn Error>> {
+    let time = time!(12:40:20);
+
+    assert_eq!(serialize(time.compact())?, "[12,40,20,0]");
+    assert_eq!(deserialize::<Time>("[12,40,20,0]", Compact)?, time);
+
+    assert_eq!(serialize(time.readable())?, "\"12:40:20.0\"");
+    assert_eq!(deserialize::<Time>("\"12:40:20.0\"", Readable)?, time);
+    assert_eq!(deserialize::<Time>("[12,40,20,0]", Readable)?, time);
+
+    Ok(())
+}
+
+#[test]
+fn primitive_datetime_json() -> Result<(), Box<dyn Error>> {
+    let dt = datetime!(2022-05-20 12:40:20);
+
+    assert_eq!(serialize(dt.compact())?, "[2022,140,12,40,20,0]");
+    assert_eq!(
+        deserialize::<PrimitiveDateTime>("[2022,140,12,40,20,0]", Compact)?,
+        dt
+    );
+
+    assert_eq!(serialize(dt.readable())?, "\"2022-05-20 12:40:20.0\"");
+    assert_eq!(
+        deserialize::<PrimitiveDateTime>("\"2022-05-20 12:40:20.0\"", Readable)?,
+        dt
+    );
+    assert_eq!(
+        deserialize::<PrimitiveDateTime>("[2022,140,12,40,20,0]", Readable)?,
+        dt
+    );
+
+    Ok(())
+}
+
+#[test]
+fn offset_datetime_json() -> Result<(), Box<dyn Error>> {
+    let dt = datetime!(2022-05-20 12:40:20).assume_utc();
+
+    assert_eq!(serialize(dt.compact())?, "[2022,140,12,40,20,0,0,0,0]");
+    assert_eq!(
+        deserialize::<OffsetDateTime>("[2022,140,12,40,20,0,0,0,0]", Compact)?,
+        dt
+    );
+
+    assert_eq!(
+        serialize(dt.readable())?,
+        "\"2022-05-20 12:40:20.0 +00:00:00\""
+    );
+    assert_eq!(
+        deserialize::<OffsetDateTime>("\"2022-05-20 12:40:20.0 +00:00:00\"", Readable)?,
+        dt
+    );
+    assert_eq!(
+        deserialize::<OffsetDateTime>("[2022,140,12,40,20,0,0,0,0]", Readable)?,
+        dt
+    );
+
+    Ok(())
+}
+
+#[test]
+fn duration_json() -> Result<(), Box<dyn Error>> {
+    let dur = Duration::new(50, 0);
+
+    assert_eq!(serialize(dur.compact())?, "[50,0]");
+    assert_eq!(deserialize::<Duration>("[50,0]", Compact)?, dur);
+
+    assert_eq!(serialize(dur.readable())?, "\"50.000000000\"");
+    assert_eq!(deserialize::<Duration>("\"50.000000000\"", Readable)?, dur);
+    assert_eq!(deserialize::<Duration>("[50,0]", Readable)?, dur);
+
+    Ok(())
+}
+
+#[test]
+fn date_json() -> Result<(), Box<dyn Error>> {
+    let date = date!(2022 - 04 - 05);
+
+    assert_eq!(serialize(date.compact())?, "[2022,95]");
+    assert_eq!(deserialize::<Date>("[2022,95]", Compact)?, date);
+
+    assert_eq!(serialize(date.readable())?, "\"2022-04-05\"");
+    assert_eq!(deserialize::<Date>("\"2022-04-05\"", Readable)?, date);
+    assert_eq!(deserialize::<Date>("[2022,95]", Readable)?, date);
+
+    Ok(())
+}
diff --git a/tests/serde/macros.rs b/tests/serde/macros.rs
new file mode 100644
index 000000000..6a02344f4
--- /dev/null
+++ b/tests/serde/macros.rs
@@ -0,0 +1,289 @@
+#[rustfmt::skip] // Tries to remove the leading `::`, which breaks compilation.
+use ::serde::{Deserialize, Serialize};
+use serde_test::{
+    assert_de_tokens, assert_de_tokens_error, assert_ser_tokens_error, assert_tokens, Configure,
+    Token,
+};
+use time::format_description::well_known::{iso8601, Iso8601};
+use time::format_description::BorrowedFormatItem;
+use time::macros::{date, datetime, offset, time};
+use time::{serde, Date, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};
+
+// Not used in the tests, but ensures that the macro compiles.
+#[allow(dead_code)]
+const ISO_FORMAT: Iso8601<{ iso8601::Config::DEFAULT.encode() }> =
+    Iso8601::<{ iso8601::Config::DEFAULT.encode() }>;
+time::serde::format_description!(my_format, OffsetDateTime, ISO_FORMAT);
+
+serde::format_description!(
+    offset_dt_format,
+    OffsetDateTime,
+    "custom format: [year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
+     sign:mandatory]:[offset_minute]"
+);
+serde::format_description!(
+    primitive_dt_format,
+    PrimitiveDateTime,
+    "custom format: [year]-[month]-[day] [hour]:[minute]:[second]"
+);
+serde::format_description!(time_format, Time, "custom format: [minute]:[second]");
+serde::format_description!(date_format, Date, "custom format: [year]-[month]-[day]");
+serde::format_description!(
+    offset_format,
+    UtcOffset,
+    "custom format: [offset_hour sign:mandatory]:[offset_minute]"
+);
+
+const TIME_FORMAT_ALT: &[BorrowedFormatItem<'_>] =
+    time::macros::format_description!("[hour]:[minute]");
+serde::format_description!(time_format_alt, Time, TIME_FORMAT_ALT);
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct TestCustomFormat {
+    #[serde(with = "offset_dt_format")]
+    offset_dt: OffsetDateTime,
+    #[serde(with = "primitive_dt_format::option")]
+    primitive_dt: Option<PrimitiveDateTime>,
+    #[serde(with = "date_format")]
+    date: Date,
+    #[serde(with = "time_format::option")]
+    time: Option<Time>,
+    #[serde(with = "offset_format")]
+    offset: UtcOffset,
+    #[serde(with = "time_format_alt")]
+    time_alt: Time,
+}
+
+#[test]
+fn custom_serialize() {
+    let value = TestCustomFormat {
+        offset_dt: datetime!(2000-01-01 00:00 -4:00),
+        primitive_dt: Some(datetime!(2000-01-01 00:00)),
+        date: date!(2000 - 01 - 01),
+        time: None,
+        offset: offset!(-4),
+        time_alt: time!(12:34),
+    };
+    assert_tokens(
+        &value.compact(),
+        &[
+            Token::Struct {
+                name: "TestCustomFormat",
+                len: 6,
+            },
+            Token::Str("offset_dt"),
+            Token::BorrowedStr("custom format: 2000-01-01 00:00:00 -04:00"),
+            Token::Str("primitive_dt"),
+            Token::Some,
+            Token::BorrowedStr("custom format: 2000-01-01 00:00:00"),
+            Token::Str("date"),
+            Token::BorrowedStr("custom format: 2000-01-01"),
+            Token::Str("time"),
+            Token::None,
+            Token::Str("offset"),
+            Token::BorrowedStr("custom format: -04:00"),
+            Token::Str("time_alt"),
+            Token::BorrowedStr("12:34"),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn custom_serialize_error() {
+    // Deserialization error due to parse problem.
+    assert_de_tokens_error::<TestCustomFormat>(
+        &[
+            Token::Struct {
+                name: "TestCustomFormat",
+                len: 5,
+            },
+            Token::Str("offset_dt"),
+            Token::BorrowedStr("custom format: 2000-01-01 0:00:00 -04:00"),
+        ],
+        "the 'hour' component could not be parsed",
+    );
+    // Parse problem in optional field.
+    assert_de_tokens_error::<TestCustomFormat>(
+        &[
+            Token::Struct {
+                name: "TestCustomFormat",
+                len: 5,
+            },
+            Token::Str("offset_dt"),
+            Token::BorrowedStr("custom format: 2000-01-01 00:00:00 -04:00"),
+            Token::Str("primitive_dt"),
+            Token::Some,
+            Token::BorrowedStr("custom format: 2000-01-01 0:00:00 -04:00"),
+        ],
+        "the 'hour' component could not be parsed",
+    );
+    // Type error
+    assert_de_tokens_error::<TestCustomFormat>(
+        &[
+            Token::Struct {
+                name: "TestCustomFormat",
+                len: 5,
+            },
+            Token::Str("offset_dt"),
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected a(n) `OffsetDateTime` in the format \"custom \
+         format: [year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
+         sign:mandatory]:[offset_minute]\"",
+    );
+    assert_de_tokens_error::<TestCustomFormat>(
+        &[
+            Token::Struct {
+                name: "TestCustomFormat",
+                len: 5,
+            },
+            Token::Str("offset_dt"),
+            Token::BorrowedStr("custom format: 2000-01-01 00:00:00 -04:00"),
+            Token::Str("primitive_dt"),
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected an `Option<PrimitiveDateTime>` in the format \
+         \"custom format: [year]-[month]-[day] [hour]:[minute]:[second]\"",
+    );
+}
+
+// This format string has offset_hour and offset_minute, but is for formatting PrimitiveDateTime.
+serde::format_description!(
+    primitive_date_time_format_bad,
+    PrimitiveDateTime,
+    "[offset_hour]:[offset_minute]"
+);
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct TestCustomFormatPrimitiveDateTimeBad {
+    #[serde(with = "primitive_date_time_format_bad")]
+    dt: PrimitiveDateTime,
+}
+
+#[test]
+fn custom_serialize_bad_type_error() {
+    let value = TestCustomFormatPrimitiveDateTimeBad {
+        dt: datetime!(2000-01-01 00:00),
+    };
+
+    assert_ser_tokens_error::<TestCustomFormatPrimitiveDateTimeBad>(
+        &value,
+        &[
+            Token::Struct {
+                name: "TestCustomFormatPrimitiveDateTimeBad",
+                len: 1,
+            },
+            Token::Str("dt"),
+        ],
+        "The type being formatted does not contain sufficient information to format a component.",
+    );
+}
+
+// Test the behavior of versioning.
+serde::format_description!(version = 1, version_test_1, Time, "[[ [hour]:[minute]");
+serde::format_description!(version = 1, version_test_2, Time, r"\\ [hour]:[minute]");
+serde::format_description!(version = 2, version_test_3, Time, r"\\ [hour]:[minute]");
+serde::format_description!(version, Time, "[hour]:[minute]");
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct TestVersioning {
+    #[serde(with = "version_test_1")]
+    time_1: Time,
+    #[serde(with = "version_test_2")]
+    time_2: Time,
+    #[serde(with = "version_test_3")]
+    time_3: Time,
+    #[serde(with = "version")]
+    time_4: Time,
+}
+
+#[test]
+fn versioning() {
+    let value = TestVersioning {
+        time_1: Time::MIDNIGHT,
+        time_2: Time::MIDNIGHT,
+        time_3: Time::MIDNIGHT,
+        time_4: Time::MIDNIGHT,
+    };
+    assert_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "TestVersioning",
+                len: 4,
+            },
+            Token::Str("time_1"),
+            Token::Str("[ 00:00"),
+            Token::Str("time_2"),
+            Token::Str(r"\\ 00:00"),
+            Token::Str("time_3"),
+            Token::Str(r"\ 00:00"),
+            Token::Str("time_4"),
+            Token::Str("00:00"),
+            Token::StructEnd,
+        ],
+    );
+}
+
+serde::format_description!(
+    version = 1,
+    nested_v1,
+    Time,
+    "[hour]:[minute][optional [:[second]]]"
+);
+serde::format_description!(
+    version = 2,
+    nested_v2,
+    Time,
+    "[hour]:[minute][optional [:[second]]]"
+);
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct TestNested {
+    #[serde(with = "nested_v1")]
+    time_1: Time,
+    #[serde(with = "nested_v2")]
+    time_2: Time,
+}
+
+#[test]
+fn nested() {
+    let value = TestNested {
+        time_1: time!(12:34:56),
+        time_2: time!(12:34:56),
+    };
+    assert_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "TestNested",
+                len: 2,
+            },
+            Token::Str("time_1"),
+            Token::Str("12:34:56"),
+            Token::Str("time_2"),
+            Token::Str("12:34:56"),
+            Token::StructEnd,
+        ],
+    );
+
+    let expected = TestNested {
+        time_1: time!(12:34),
+        time_2: time!(12:34),
+    };
+    assert_de_tokens(
+        &expected,
+        &[
+            Token::Struct {
+                name: "TestNested",
+                len: 2,
+            },
+            Token::Str("time_1"),
+            Token::Str("12:34"),
+            Token::Str("time_2"),
+            Token::Str("12:34"),
+            Token::StructEnd,
+        ],
+    );
+}
diff --git a/tests/serde/mod.rs b/tests/serde/mod.rs
new file mode 100644
index 000000000..3f40c7f77
--- /dev/null
+++ b/tests/serde/mod.rs
@@ -0,0 +1,988 @@
+use serde_test::{
+    assert_de_tokens, assert_de_tokens_error, assert_tokens, Compact, Configure, Readable, Token,
+};
+use time::macros::{date, datetime, offset, time};
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+mod error_conditions;
+mod iso8601;
+mod json;
+mod macros;
+mod rfc2822;
+mod rfc3339;
+mod timestamps;
+
+#[test]
+fn time() {
+    assert_tokens(
+        &Time::MIDNIGHT.compact(),
+        &[
+            Token::Tuple { len: 4 },
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &time!(23:58:59.123_456_789).compact(),
+        &[
+            Token::Tuple { len: 4 },
+            Token::U8(23),
+            Token::U8(58),
+            Token::U8(59),
+            Token::U32(123_456_789),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &Time::MIDNIGHT.readable(),
+        &[Token::BorrowedStr("00:00:00.0")],
+    );
+    assert_tokens(
+        &time!(23:58:59.123_456_789).readable(),
+        &[Token::BorrowedStr("23:58:59.123456789")],
+    );
+}
+
+#[test]
+fn time_error() {
+    assert_de_tokens_error::<Compact<Time>>(
+        &[
+            Token::Tuple { len: 4 },
+            Token::U8(24),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `24`, expected a value in the range 0..=23",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[Token::BorrowedStr("24:00:00.0")],
+        "the 'hour' component could not be parsed",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[Token::BorrowedStr("23-00:00.0")],
+        "a character literal was not valid",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[Token::BorrowedStr("0:00:00.0")],
+        "the 'hour' component could not be parsed",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[Token::BorrowedStr("00:00:00.0x")],
+        "unexpected trailing characters; the end of input was expected",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Time`",
+    );
+    assert_de_tokens_error::<Compact<Time>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Time`",
+    );
+}
+
+#[test]
+fn time_partial() {
+    assert_de_tokens_error::<Compact<Time>>(
+        &[Token::Tuple { len: 4 }, Token::TupleEnd],
+        "expected hour",
+    );
+    assert_de_tokens_error::<Compact<Time>>(
+        &[Token::Tuple { len: 4 }, Token::U8(0), Token::TupleEnd],
+        "expected minute",
+    );
+    assert_de_tokens_error::<Compact<Time>>(
+        &[
+            Token::Tuple { len: 4 },
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected second",
+    );
+    assert_de_tokens_error::<Compact<Time>>(
+        &[
+            Token::Tuple { len: 4 },
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected nanosecond",
+    );
+
+    assert_de_tokens_error::<Readable<Time>>(
+        &[Token::Tuple { len: 4 }, Token::TupleEnd],
+        "expected hour",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[Token::Tuple { len: 4 }, Token::U8(0), Token::TupleEnd],
+        "expected minute",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[
+            Token::Tuple { len: 4 },
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected second",
+    );
+    assert_de_tokens_error::<Readable<Time>>(
+        &[
+            Token::Tuple { len: 4 },
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected nanosecond",
+    );
+}
+
+#[test]
+fn date() {
+    assert_tokens(
+        &date!(-9999 - 001).compact(),
+        &[
+            Token::Tuple { len: 2 },
+            Token::I32(-9999),
+            Token::U16(1),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &date!(+9999-365).compact(),
+        &[
+            Token::Tuple { len: 2 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &date!(-9999 - 001).readable(),
+        &[Token::BorrowedStr("-9999-01-01")],
+    );
+    assert_tokens(
+        &date!(+9999-365).readable(),
+        &[Token::BorrowedStr("9999-12-31")],
+    );
+}
+
+#[test]
+fn date_error() {
+    assert_de_tokens_error::<Readable<Date>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Date`",
+    );
+    assert_de_tokens_error::<Compact<Date>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Date`",
+    );
+}
+
+#[test]
+fn date_partial() {
+    assert_de_tokens_error::<Compact<Date>>(
+        &[Token::Tuple { len: 2 }, Token::TupleEnd],
+        "expected year",
+    );
+    assert_de_tokens_error::<Compact<Date>>(
+        &[Token::Tuple { len: 2 }, Token::I32(9999), Token::TupleEnd],
+        "expected day of year",
+    );
+
+    assert_de_tokens_error::<Readable<Date>>(
+        &[Token::Tuple { len: 2 }, Token::TupleEnd],
+        "expected year",
+    );
+    assert_de_tokens_error::<Readable<Date>>(
+        &[Token::Tuple { len: 2 }, Token::I32(9999), Token::TupleEnd],
+        "expected day of year",
+    );
+}
+
+#[test]
+fn primitive_date_time() {
+    assert_tokens(
+        &datetime!(-9999-001 0:00).compact(),
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(-9999),
+            Token::U16(1),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &datetime!(+9999-365 23:58:59.123_456_789).compact(),
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(23),
+            Token::U8(58),
+            Token::U8(59),
+            Token::U32(123_456_789),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &datetime!(-9999-001 0:00).readable(),
+        &[Token::BorrowedStr("-9999-01-01 00:00:00.0")],
+    );
+    assert_tokens(
+        &datetime!(+9999-365 23:58:59.123_456_789).readable(),
+        &[Token::BorrowedStr("9999-12-31 23:58:59.123456789")],
+    );
+}
+
+#[test]
+fn primitive_date_time_error() {
+    assert_de_tokens_error::<Readable<PrimitiveDateTime>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `PrimitiveDateTime`",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `PrimitiveDateTime`",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(2021),
+            Token::U16(366),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `366`, expected a value in the range 1..=365",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(2021),
+            Token::U16(1),
+            Token::U8(24),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `24`, expected a value in the range 0..=23",
+    );
+}
+
+#[test]
+fn primitive_date_time_partial() {
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[Token::Tuple { len: 6 }, Token::TupleEnd],
+        "expected year",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[Token::Tuple { len: 6 }, Token::I32(9999), Token::TupleEnd],
+        "expected day of year",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::TupleEnd,
+        ],
+        "expected hour",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(23),
+            Token::TupleEnd,
+        ],
+        "expected minute",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(23),
+            Token::U8(58),
+            Token::TupleEnd,
+        ],
+        "expected second",
+    );
+    assert_de_tokens_error::<Compact<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(23),
+            Token::U8(58),
+            Token::U8(59),
+            Token::TupleEnd,
+        ],
+        "expected nanosecond",
+    );
+
+    assert_de_tokens_error::<Readable<PrimitiveDateTime>>(
+        &[Token::Tuple { len: 6 }, Token::TupleEnd],
+        "expected year",
+    );
+    assert_de_tokens_error::<Readable<PrimitiveDateTime>>(
+        &[Token::Tuple { len: 6 }, Token::I32(9999), Token::TupleEnd],
+        "expected day of year",
+    );
+    assert_de_tokens_error::<Readable<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::TupleEnd,
+        ],
+        "expected hour",
+    );
+    assert_de_tokens_error::<Readable<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(23),
+            Token::TupleEnd,
+        ],
+        "expected minute",
+    );
+    assert_de_tokens_error::<Readable<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(23),
+            Token::U8(58),
+            Token::TupleEnd,
+        ],
+        "expected second",
+    );
+    assert_de_tokens_error::<Readable<PrimitiveDateTime>>(
+        &[
+            Token::Tuple { len: 6 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(23),
+            Token::U8(58),
+            Token::U8(59),
+            Token::TupleEnd,
+        ],
+        "expected nanosecond",
+    );
+}
+
+#[test]
+fn offset_date_time() {
+    assert_tokens(
+        &datetime!(-9999-001 0:00 UTC)
+            .to_offset(offset!(+23:58:59))
+            .compact(),
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(-9999),
+            Token::U16(1),
+            Token::U8(23),
+            Token::U8(58),
+            Token::U8(59),
+            Token::U32(0),
+            Token::I8(23),
+            Token::I8(58),
+            Token::I8(59),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &datetime!(+9999-365 23:58:59.123_456_789 UTC)
+            .to_offset(offset!(-23:58:59))
+            .compact(),
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(123_456_789),
+            Token::I8(-23),
+            Token::I8(-58),
+            Token::I8(-59),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &datetime!(-9999-001 0:00 UTC)
+            .to_offset(offset!(+23:58:59))
+            .readable(),
+        &[Token::BorrowedStr("-9999-01-01 23:58:59.0 +23:58:59")],
+    );
+    assert_tokens(
+        &datetime!(+9999-365 23:58:59.123_456_789 UTC)
+            .to_offset(offset!(-23:58:59))
+            .readable(),
+        &[Token::BorrowedStr(
+            "9999-12-31 00:00:00.123456789 -23:58:59",
+        )],
+    );
+}
+
+#[test]
+fn offset_date_time_error() {
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected an `OffsetDateTime`",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected an `OffsetDateTime`",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(2021),
+            Token::U16(366),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::I8(0),
+            Token::I8(0),
+            Token::I8(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `366`, expected a value in the range 1..=365",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(2021),
+            Token::U16(1),
+            Token::U8(24),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::I8(0),
+            Token::I8(0),
+            Token::I8(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `24`, expected a value in the range 0..=23",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(2021),
+            Token::U16(1),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(0),
+            Token::I8(26),
+            Token::I8(0),
+            Token::I8(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `26`, expected a value in the range -25..=25",
+    );
+    // the Deserialize impl does not recognize leap second times as valid
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(2021),
+            Token::U16(365),
+            Token::U8(23),
+            Token::U8(59),
+            Token::U8(60),
+            Token::U32(0),
+            Token::I8(0),
+            Token::I8(0),
+            Token::I8(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `60`, expected a value in the range 0..=59",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[Token::BorrowedStr("2021-12-31 23:59:60.0 +00:00:00")],
+        "second must be in the range 0..=59",
+    );
+}
+
+#[test]
+fn offset_date_time_partial() {
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[Token::Tuple { len: 9 }, Token::TupleEnd],
+        "expected year",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[Token::Tuple { len: 9 }, Token::I32(9999), Token::TupleEnd],
+        "expected day of year",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::TupleEnd,
+        ],
+        "expected hour",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected minute",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected second",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected nanosecond",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(123_456_789),
+            Token::TupleEnd,
+        ],
+        "expected offset hours",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(123_456_789),
+            Token::I8(-23),
+            Token::TupleEnd,
+        ],
+        "expected offset minutes",
+    );
+    assert_de_tokens_error::<Compact<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(123_456_789),
+            Token::I8(-23),
+            Token::I8(-58),
+            Token::TupleEnd,
+        ],
+        "expected offset seconds",
+    );
+
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[Token::Tuple { len: 9 }, Token::TupleEnd],
+        "expected year",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[Token::Tuple { len: 9 }, Token::I32(9999), Token::TupleEnd],
+        "expected day of year",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::TupleEnd,
+        ],
+        "expected hour",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected minute",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected second",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::TupleEnd,
+        ],
+        "expected nanosecond",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(123_456_789),
+            Token::TupleEnd,
+        ],
+        "expected offset hours",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(123_456_789),
+            Token::I8(-23),
+            Token::TupleEnd,
+        ],
+        "expected offset minutes",
+    );
+    assert_de_tokens_error::<Readable<OffsetDateTime>>(
+        &[
+            Token::Tuple { len: 9 },
+            Token::I32(9999),
+            Token::U16(365),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U8(0),
+            Token::U32(123_456_789),
+            Token::I8(-23),
+            Token::I8(-58),
+            Token::TupleEnd,
+        ],
+        "expected offset seconds",
+    );
+}
+
+#[test]
+fn utc_offset() {
+    assert_tokens(
+        &offset!(-23:58:59).compact(),
+        &[
+            Token::Tuple { len: 3 },
+            Token::I8(-23),
+            Token::I8(-58),
+            Token::I8(-59),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &offset!(+23:58:59).compact(),
+        &[
+            Token::Tuple { len: 3 },
+            Token::I8(23),
+            Token::I8(58),
+            Token::I8(59),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &offset!(-23:58:59).readable(),
+        &[Token::BorrowedStr("-23:58:59")],
+    );
+    assert_tokens(
+        &offset!(+23:58:59).readable(),
+        &[Token::BorrowedStr("+23:58:59")],
+    );
+}
+
+#[test]
+fn utc_offset_error() {
+    assert_de_tokens_error::<Readable<UtcOffset>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `UtcOffset`",
+    );
+    assert_de_tokens_error::<Compact<UtcOffset>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `UtcOffset`",
+    );
+    assert_de_tokens_error::<Compact<UtcOffset>>(
+        &[
+            Token::Tuple { len: 3 },
+            Token::I8(26),
+            Token::I8(0),
+            Token::I8(0),
+            Token::TupleEnd,
+        ],
+        "invalid value: integer `26`, expected a value in the range -25..=25",
+    );
+}
+
+#[test]
+fn utc_offset_partial() {
+    assert_de_tokens_error::<Compact<UtcOffset>>(
+        &[Token::Tuple { len: 0 }, Token::TupleEnd],
+        "expected offset hours",
+    );
+    assert_de_tokens_error::<Readable<UtcOffset>>(
+        &[Token::Tuple { len: 0 }, Token::TupleEnd],
+        "expected offset hours",
+    );
+
+    let value = offset!(+23);
+    assert_de_tokens::<Compact<UtcOffset>>(
+        &value.compact(),
+        &[Token::Tuple { len: 1 }, Token::I8(23), Token::TupleEnd],
+    );
+    let value = offset!(+23);
+    assert_de_tokens::<Readable<UtcOffset>>(
+        &value.readable(),
+        &[Token::Tuple { len: 1 }, Token::I8(23), Token::TupleEnd],
+    );
+
+    let value = offset!(+23:58);
+    assert_de_tokens::<Compact<UtcOffset>>(
+        &value.compact(),
+        &[
+            Token::Tuple { len: 2 },
+            Token::I8(23),
+            Token::I8(58),
+            Token::TupleEnd,
+        ],
+    );
+    let value = offset!(+23:58);
+    assert_de_tokens::<Readable<UtcOffset>>(
+        &value.readable(),
+        &[
+            Token::Tuple { len: 2 },
+            Token::I8(23),
+            Token::I8(58),
+            Token::TupleEnd,
+        ],
+    );
+}
+
+#[test]
+fn duration() {
+    assert_tokens(
+        &Duration::MIN.compact(),
+        &[
+            Token::Tuple { len: 2 },
+            Token::I64(i64::MIN),
+            Token::I32(-999_999_999),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &Duration::MAX.compact(),
+        &[
+            Token::Tuple { len: 2 },
+            Token::I64(i64::MAX),
+            Token::I32(999_999_999),
+            Token::TupleEnd,
+        ],
+    );
+    assert_tokens(
+        &Duration::MIN.readable(),
+        &[Token::BorrowedStr("-9223372036854775808.999999999")],
+    );
+    assert_tokens(
+        &Duration::MAX.readable(),
+        &[Token::BorrowedStr("9223372036854775807.999999999")],
+    );
+    assert_tokens(
+        &Duration::ZERO.readable(),
+        &[Token::BorrowedStr("0.000000000")],
+    );
+}
+
+#[test]
+fn duration_error() {
+    assert_de_tokens_error::<Readable<Duration>>(
+        &[Token::BorrowedStr("x")],
+        r#"invalid value: string "x", expected a decimal point"#,
+    );
+    assert_de_tokens_error::<Readable<Duration>>(
+        &[Token::BorrowedStr("x.0")],
+        r#"invalid value: string "x", expected seconds"#,
+    );
+    assert_de_tokens_error::<Readable<Duration>>(
+        &[Token::BorrowedStr("0.x")],
+        r#"invalid value: string "x", expected nanoseconds"#,
+    );
+    assert_de_tokens_error::<Readable<Duration>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Duration`",
+    );
+    assert_de_tokens_error::<Compact<Duration>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Duration`",
+    );
+}
+
+#[test]
+fn duration_partial() {
+    assert_de_tokens_error::<Compact<Duration>>(
+        &[Token::Tuple { len: 2 }, Token::TupleEnd],
+        "expected seconds",
+    );
+    assert_de_tokens_error::<Compact<Duration>>(
+        &[
+            Token::Tuple { len: 2 },
+            Token::I64(i64::MAX),
+            Token::TupleEnd,
+        ],
+        "expected nanoseconds",
+    );
+
+    assert_de_tokens_error::<Readable<Duration>>(
+        &[Token::Tuple { len: 2 }, Token::TupleEnd],
+        "expected seconds",
+    );
+    assert_de_tokens_error::<Readable<Duration>>(
+        &[
+            Token::Tuple { len: 2 },
+            Token::I64(i64::MAX),
+            Token::TupleEnd,
+        ],
+        "expected nanoseconds",
+    );
+}
+
+#[test]
+fn weekday() {
+    use Weekday::*;
+    assert_tokens(&Monday.compact(), &[Token::U8(1)]);
+    assert_tokens(&Tuesday.compact(), &[Token::U8(2)]);
+    assert_tokens(&Wednesday.compact(), &[Token::U8(3)]);
+    assert_tokens(&Thursday.compact(), &[Token::U8(4)]);
+    assert_tokens(&Friday.compact(), &[Token::U8(5)]);
+    assert_tokens(&Saturday.compact(), &[Token::U8(6)]);
+    assert_tokens(&Sunday.compact(), &[Token::U8(7)]);
+
+    assert_tokens(&Monday.readable(), &[Token::BorrowedStr("Monday")]);
+    assert_tokens(&Tuesday.readable(), &[Token::BorrowedStr("Tuesday")]);
+    assert_tokens(&Wednesday.readable(), &[Token::BorrowedStr("Wednesday")]);
+    assert_tokens(&Thursday.readable(), &[Token::BorrowedStr("Thursday")]);
+    assert_tokens(&Friday.readable(), &[Token::BorrowedStr("Friday")]);
+    assert_tokens(&Saturday.readable(), &[Token::BorrowedStr("Saturday")]);
+    assert_tokens(&Sunday.readable(), &[Token::BorrowedStr("Sunday")]);
+}
+
+#[test]
+fn weekday_error() {
+    assert_de_tokens_error::<Compact<Weekday>>(
+        &[Token::U8(0)],
+        "invalid value: integer `0`, expected a value in the range 1..=7",
+    );
+    assert_de_tokens_error::<Readable<Weekday>>(
+        &[Token::BorrowedStr("NotADay")],
+        r#"invalid value: string "NotADay", expected a `Weekday`"#,
+    );
+    assert_de_tokens_error::<Readable<Weekday>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Weekday`",
+    );
+    assert_de_tokens_error::<Compact<Weekday>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Weekday`",
+    );
+}
+
+#[test]
+fn month() {
+    use Month::*;
+    assert_tokens(&January.compact(), &[Token::U8(1)]);
+    assert_tokens(&February.compact(), &[Token::U8(2)]);
+    assert_tokens(&March.compact(), &[Token::U8(3)]);
+    assert_tokens(&April.compact(), &[Token::U8(4)]);
+    assert_tokens(&May.compact(), &[Token::U8(5)]);
+    assert_tokens(&June.compact(), &[Token::U8(6)]);
+    assert_tokens(&July.compact(), &[Token::U8(7)]);
+    assert_tokens(&August.compact(), &[Token::U8(8)]);
+    assert_tokens(&September.compact(), &[Token::U8(9)]);
+    assert_tokens(&October.compact(), &[Token::U8(10)]);
+    assert_tokens(&November.compact(), &[Token::U8(11)]);
+    assert_tokens(&December.compact(), &[Token::U8(12)]);
+
+    assert_tokens(&January.readable(), &[Token::BorrowedStr("January")]);
+    assert_tokens(&February.readable(), &[Token::BorrowedStr("February")]);
+    assert_tokens(&March.readable(), &[Token::BorrowedStr("March")]);
+    assert_tokens(&April.readable(), &[Token::BorrowedStr("April")]);
+    assert_tokens(&May.readable(), &[Token::BorrowedStr("May")]);
+    assert_tokens(&June.readable(), &[Token::BorrowedStr("June")]);
+    assert_tokens(&July.readable(), &[Token::BorrowedStr("July")]);
+    assert_tokens(&August.readable(), &[Token::BorrowedStr("August")]);
+    assert_tokens(&September.readable(), &[Token::BorrowedStr("September")]);
+    assert_tokens(&October.readable(), &[Token::BorrowedStr("October")]);
+    assert_tokens(&November.readable(), &[Token::BorrowedStr("November")]);
+    assert_tokens(&December.readable(), &[Token::BorrowedStr("December")]);
+}
+
+#[test]
+fn month_error() {
+    assert_de_tokens_error::<Compact<Month>>(
+        &[Token::U8(0)],
+        "invalid value: integer `0`, expected a value in the range 1..=12",
+    );
+    assert_de_tokens_error::<Readable<Month>>(
+        &[Token::BorrowedStr("NotAMonth")],
+        r#"invalid value: string "NotAMonth", expected a `Month`"#,
+    );
+    assert_de_tokens_error::<Readable<Month>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Month`",
+    );
+    assert_de_tokens_error::<Compact<Month>>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected a `Month`",
+    );
+}
diff --git a/tests/serde/rfc2822.rs b/tests/serde/rfc2822.rs
new file mode 100644
index 000000000..74a85313c
--- /dev/null
+++ b/tests/serde/rfc2822.rs
@@ -0,0 +1,56 @@
+use serde::{Deserialize, Serialize};
+use serde_test::{assert_tokens, Configure, Token};
+use time::serde::rfc2822;
+use time::OffsetDateTime;
+use time_macros::datetime;
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct Test {
+    #[serde(with = "rfc2822")]
+    dt: OffsetDateTime,
+    #[serde(with = "rfc2822::option")]
+    option_dt: Option<OffsetDateTime>,
+}
+
+#[test]
+fn serialize_deserialize() {
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 UTC),
+        option_dt: Some(datetime!(2000-01-01 00:00:00 UTC)),
+    };
+    assert_tokens(
+        &value.compact(),
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("Sat, 01 Jan 2000 00:00:00 +0000"),
+            Token::Str("option_dt"),
+            Token::Some,
+            Token::BorrowedStr("Sat, 01 Jan 2000 00:00:00 +0000"),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn parse_json() -> serde_json::Result<()> {
+    #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+    #[serde(untagged)]
+    enum Wrapper {
+        A(Test),
+    }
+    assert_eq!(
+        serde_json::from_str::<Wrapper>(
+            r#"{"dt": "Sat, 01 Jan 2000 00:00:00 +0000", "option_dt": null}"#
+        )?,
+        Wrapper::A(Test {
+            dt: datetime!(2000-01-01 00:00:00 UTC),
+            option_dt: None,
+        })
+    );
+
+    Ok(())
+}
diff --git a/tests/serde/rfc3339.rs b/tests/serde/rfc3339.rs
new file mode 100644
index 000000000..3fffeb4f9
--- /dev/null
+++ b/tests/serde/rfc3339.rs
@@ -0,0 +1,141 @@
+use serde::{Deserialize, Serialize};
+use serde_test::{
+    assert_de_tokens_error, assert_ser_tokens_error, assert_tokens, Configure, Token,
+};
+use time::macros::datetime;
+use time::serde::rfc3339;
+use time::OffsetDateTime;
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct Test {
+    #[serde(with = "rfc3339")]
+    dt: OffsetDateTime,
+    #[serde(with = "rfc3339::option")]
+    option_dt: Option<OffsetDateTime>,
+}
+
+#[test]
+fn serialize_deserialize() {
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 UTC),
+        option_dt: Some(datetime!(2000-01-01 00:00:00 UTC)),
+    };
+    assert_tokens(
+        &value.compact(),
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("2000-01-01T00:00:00Z"),
+            Token::Str("option_dt"),
+            Token::Some,
+            Token::BorrowedStr("2000-01-01T00:00:00Z"),
+            Token::StructEnd,
+        ],
+    );
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 UTC),
+        option_dt: None,
+    };
+    assert_tokens(
+        &value.compact(),
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("2000-01-01T00:00:00Z"),
+            Token::Str("option_dt"),
+            Token::None,
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens_error::<Test>(
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+            Token::BorrowedStr("bad"),
+            Token::StructEnd,
+        ],
+        "the 'year' component could not be parsed",
+    );
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 +00:00:01),
+        option_dt: None,
+    };
+    assert_ser_tokens_error::<Test>(
+        &value,
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 2,
+            },
+            Token::Str("dt"),
+        ],
+        "The offset_second component cannot be formatted into the requested format.",
+    );
+}
+
+#[test]
+fn parse_json() -> serde_json::Result<()> {
+    #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+    #[serde(untagged)]
+    enum Wrapper {
+        A(Test),
+    }
+    assert_eq!(
+        serde_json::from_str::<Wrapper>("{\"dt\": \"2000-01-01T00:00:00Z\", \"option_dt\": null}")?,
+        Wrapper::A(Test {
+            dt: datetime!(2000-01-01 00:00:00 UTC),
+            option_dt: None,
+        })
+    );
+
+    Ok(())
+}
+
+#[test]
+fn issue_479() -> serde_json::Result<()> {
+    const A: &str = r#"{
+        "date": "2022-05-01T10:20:42.123Z"
+    }"#;
+
+    const B: &str = r#"{
+        "date": "2022-05-01T10:20:42.123Z",
+        "maybe_date": "2022-05-01T10:20:42.123Z"
+    }"#;
+
+    #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+    struct S {
+        #[serde(with = "time::serde::rfc3339")]
+        date: OffsetDateTime,
+        #[serde(with = "time::serde::rfc3339::option", default)]
+        maybe_date: Option<OffsetDateTime>,
+    }
+
+    let a = serde_json::from_str::<S>(A)?;
+    let b = serde_json::from_str::<S>(B)?;
+
+    assert_eq!(
+        a,
+        S {
+            date: datetime!(2022-05-01 10:20:42.123 UTC),
+            maybe_date: None
+        }
+    );
+    assert_eq!(
+        b,
+        S {
+            date: datetime!(2022-05-01 10:20:42.123 UTC),
+            maybe_date: Some(datetime!(2022-05-01 10:20:42.123 UTC))
+        }
+    );
+
+    Ok(())
+}
diff --git a/tests/serde/timestamps.rs b/tests/serde/timestamps.rs
new file mode 100644
index 000000000..208278be8
--- /dev/null
+++ b/tests/serde/timestamps.rs
@@ -0,0 +1,138 @@
+use serde::{Deserialize, Serialize};
+use serde_test::{assert_de_tokens_error, assert_tokens, Configure, Token};
+use time::macros::datetime;
+use time::serde::timestamp;
+use time::OffsetDateTime;
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct Test {
+    #[serde(with = "timestamp")]
+    dt: OffsetDateTime,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct TestMilliseconds {
+    #[serde(with = "timestamp::milliseconds")]
+    dt: OffsetDateTime,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct TestMicroseconds {
+    #[serde(with = "timestamp::microseconds")]
+    dt: OffsetDateTime,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct TestNanoseconds {
+    #[serde(with = "timestamp::nanoseconds")]
+    dt: OffsetDateTime,
+}
+
+#[test]
+fn serialize_timestamp() {
+    let value = Test {
+        dt: datetime!(2000-01-01 00:00:00 UTC),
+    };
+    assert_tokens(
+        &value.compact(),
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 1,
+            },
+            Token::Str("dt"),
+            Token::I64(946684800),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens_error::<Test>(
+        &[
+            Token::Struct {
+                name: "Test",
+                len: 1,
+            },
+            Token::Str("dt"),
+            Token::Str("bad"),
+            Token::StructEnd,
+        ],
+        "invalid type: string \"bad\", expected i64",
+    );
+}
+
+#[test]
+fn serialize_timestamp_milliseconds() -> serde_json::Result<()> {
+    let value_milliseconds = TestMilliseconds {
+        dt: datetime!(2000-01-01 00:00:00.999 UTC),
+    };
+    assert_de_tokens_error::<TestMilliseconds>(
+        &[
+            Token::Struct {
+                name: "TestMilliseconds",
+                len: 1,
+            },
+            Token::Str("dt"),
+            Token::Str("bad"),
+            Token::StructEnd,
+        ],
+        "invalid type: string \"bad\", expected i128",
+    );
+    // serde_test does not support I128, see: https://github.com/serde-rs/test/issues/18
+    let milliseconds_str = r#"{"dt":946684800999}"#;
+    let deserialized_milliseconds: TestMilliseconds = serde_json::from_str(milliseconds_str)?;
+    let serialized_milliseconds = serde_json::to_string(&value_milliseconds)?;
+    assert_eq!(value_milliseconds.dt, deserialized_milliseconds.dt);
+    assert_eq!(serialized_milliseconds, milliseconds_str);
+    Ok(())
+}
+
+#[test]
+fn serialize_timestamp_microseconds() -> serde_json::Result<()> {
+    let value_microseconds = TestMicroseconds {
+        dt: datetime!(2000-01-01 00:00:00.999_999 UTC),
+    };
+    assert_de_tokens_error::<TestMicroseconds>(
+        &[
+            Token::Struct {
+                name: "TestMicroseconds",
+                len: 1,
+            },
+            Token::Str("dt"),
+            Token::Str("bad"),
+            Token::StructEnd,
+        ],
+        "invalid type: string \"bad\", expected i128",
+    );
+    // serde_test does not support I128, see: https://github.com/serde-rs/test/issues/18
+    let microseconds_str = r#"{"dt":946684800999999}"#;
+    let deserialized_microseconds: TestMicroseconds = serde_json::from_str(microseconds_str)?;
+    let serialized_microseconds = serde_json::to_string(&value_microseconds)?;
+    assert_eq!(value_microseconds.dt, deserialized_microseconds.dt);
+    assert_eq!(serialized_microseconds, microseconds_str);
+    Ok(())
+}
+
+#[test]
+fn serialize_timestamp_nanoseconds() -> serde_json::Result<()> {
+    let value_nanoseconds = TestNanoseconds {
+        dt: datetime!(2000-01-01 00:00:00.999_999_999 UTC),
+    };
+    assert_de_tokens_error::<TestNanoseconds>(
+        &[
+            Token::Struct {
+                name: "TestNanoseconds",
+                len: 1,
+            },
+            Token::Str("dt"),
+            Token::Str("bad"),
+            Token::StructEnd,
+        ],
+        "invalid type: string \"bad\", expected i128",
+    );
+    // serde_test does not support I128, see: https://github.com/serde-rs/test/issues/18
+    let nanoseconds_str = r#"{"dt":946684800999999999}"#;
+    let deserialized_nanoseconds: TestNanoseconds = serde_json::from_str(nanoseconds_str)?;
+    let serialized_nanoseconds = serde_json::to_string(&value_nanoseconds)?;
+    assert_eq!(value_nanoseconds.dt, deserialized_nanoseconds.dt);
+    assert_eq!(serialized_nanoseconds, nanoseconds_str);
+    Ok(())
+}
diff --git a/tests/serde_helpers.rs b/tests/serde_helpers.rs
new file mode 100644
index 000000000..d7dfa6698
--- /dev/null
+++ b/tests/serde_helpers.rs
@@ -0,0 +1,225 @@
+use serde::{Deserialize, Serialize};
+use serde_test::{assert_de_tokens_error, assert_ser_tokens_error, assert_tokens, Token};
+use time::macros::datetime;
+use time::OffsetDateTime;
+
+#[test]
+fn success() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Full(
+        #[serde(with = "time::serde::rfc2822")] OffsetDateTime,
+        #[serde(with = "time::serde::rfc2822::option")] Option<OffsetDateTime>,
+        #[serde(with = "time::serde::rfc2822::option")] Option<OffsetDateTime>,
+        #[serde(with = "time::serde::rfc3339")] OffsetDateTime,
+        #[serde(with = "time::serde::rfc3339::option")] Option<OffsetDateTime>,
+        #[serde(with = "time::serde::rfc3339::option")] Option<OffsetDateTime>,
+        #[serde(with = "time::serde::timestamp")] OffsetDateTime,
+        #[serde(with = "time::serde::timestamp::option")] Option<OffsetDateTime>,
+        #[serde(with = "time::serde::timestamp::option")] Option<OffsetDateTime>,
+    );
+
+    assert_tokens(
+        &Full(
+            datetime!(2021-01-02 03:04:05 UTC),
+            Some(datetime!(2021-01-02 03:04:05 UTC)),
+            None,
+            datetime!(2021-01-02 03:04:05 UTC),
+            Some(datetime!(2021-01-02 03:04:05 UTC)),
+            None,
+            datetime!(2021-01-02 03:04:05 UTC),
+            Some(datetime!(2021-01-02 03:04:05 UTC)),
+            None,
+        ),
+        &[
+            Token::TupleStruct {
+                name: "Full",
+                len: 9,
+            },
+            Token::Str("Sat, 02 Jan 2021 03:04:05 +0000"),
+            Token::Some,
+            Token::Str("Sat, 02 Jan 2021 03:04:05 +0000"),
+            Token::None,
+            Token::Str("2021-01-02T03:04:05Z"),
+            Token::Some,
+            Token::Str("2021-01-02T03:04:05Z"),
+            Token::None,
+            Token::I64(1_609_556_645),
+            Token::Some,
+            Token::I64(1_609_556_645),
+            Token::None,
+            Token::TupleStructEnd,
+        ],
+    );
+}
+
+#[test]
+fn rfc2822_error() {
+    #[derive(Serialize, Deserialize)]
+    struct Rfc2822(
+        #[serde(with = "time::serde::rfc2822")] OffsetDateTime,
+        #[serde(with = "time::serde::rfc2822::option")] Option<OffsetDateTime>,
+        #[serde(with = "time::serde::rfc2822::option")] Option<OffsetDateTime>,
+    );
+
+    assert_ser_tokens_error(
+        &Rfc2822(
+            datetime!(2021-01-02 03:04:05 +0:00:01),
+            Some(datetime!(2021-01-02 03:04:05 UTC)),
+            None,
+        ),
+        &[Token::TupleStruct {
+            name: "Rfc2822",
+            len: 3,
+        }],
+        "The offset_second component cannot be formatted into the requested format.",
+    );
+    assert_ser_tokens_error(
+        &Rfc2822(
+            datetime!(2021-01-02 03:04:05 UTC),
+            Some(datetime!(2021-01-02 03:04:05 +0:00:01)),
+            None,
+        ),
+        &[
+            Token::TupleStruct {
+                name: "Rfc2822",
+                len: 3,
+            },
+            Token::Str("Sat, 02 Jan 2021 03:04:05 +0000"),
+        ],
+        "The offset_second component cannot be formatted into the requested format.",
+    );
+    assert_de_tokens_error::<Rfc2822>(
+        &[
+            Token::TupleStruct {
+                name: "Rfc2822",
+                len: 3,
+            },
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected an RFC2822-formatted `OffsetDateTime`",
+    );
+    assert_de_tokens_error::<Rfc2822>(
+        &[
+            Token::TupleStruct {
+                name: "Rfc2822",
+                len: 3,
+            },
+            Token::Str("Sat, 02 Jan 2021 03:04:05 +0000"),
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected an RFC2822-formatted `Option<OffsetDateTime>`",
+    );
+    assert_de_tokens_error::<Rfc2822>(
+        &[
+            Token::TupleStruct {
+                name: "Rfc2822",
+                len: 3,
+            },
+            Token::Str("Sat, 02 Jan 2021 03:04:05 +0000"),
+            Token::Some,
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected an RFC2822-formatted `OffsetDateTime`",
+    );
+}
+
+#[test]
+fn rfc3339_error() {
+    #[derive(Serialize, Deserialize)]
+    struct Rfc3339(
+        #[serde(with = "time::serde::rfc3339")] OffsetDateTime,
+        #[serde(with = "time::serde::rfc3339::option")] Option<OffsetDateTime>,
+        #[serde(with = "time::serde::rfc3339::option")] Option<OffsetDateTime>,
+    );
+
+    assert_ser_tokens_error(
+        &Rfc3339(
+            datetime!(2021-01-02 03:04:05 +0:00:01),
+            Some(datetime!(2021-01-02 03:04:05 UTC)),
+            None,
+        ),
+        &[Token::TupleStruct {
+            name: "Rfc3339",
+            len: 3,
+        }],
+        "The offset_second component cannot be formatted into the requested format.",
+    );
+    assert_ser_tokens_error(
+        &Rfc3339(
+            datetime!(2021-01-02 03:04:05 UTC),
+            Some(datetime!(2021-01-02 03:04:05 +0:00:01)),
+            None,
+        ),
+        &[
+            Token::TupleStruct {
+                name: "Rfc3339",
+                len: 3,
+            },
+            Token::Str("2021-01-02T03:04:05Z"),
+        ],
+        "The offset_second component cannot be formatted into the requested format.",
+    );
+    assert_de_tokens_error::<Rfc3339>(
+        &[
+            Token::TupleStruct {
+                name: "Rfc3339",
+                len: 3,
+            },
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected an RFC3339-formatted `OffsetDateTime`",
+    );
+    assert_de_tokens_error::<Rfc3339>(
+        &[
+            Token::TupleStruct {
+                name: "Rfc3339",
+                len: 3,
+            },
+            Token::Str("2021-01-02T03:04:05Z"),
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected an RFC3339-formatted `Option<OffsetDateTime>`",
+    );
+    assert_de_tokens_error::<Rfc3339>(
+        &[
+            Token::TupleStruct {
+                name: "Rfc3339",
+                len: 3,
+            },
+            Token::Str("2021-01-02T03:04:05Z"),
+            Token::Some,
+            Token::Bool(false),
+        ],
+        "invalid type: boolean `false`, expected an RFC3339-formatted `OffsetDateTime`",
+    );
+}
+
+#[test]
+fn timestamp_error() {
+    #[derive(Serialize, Deserialize)]
+    #[serde(transparent)]
+    struct Timestamp(#[serde(with = "time::serde::timestamp")] OffsetDateTime);
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(transparent)]
+    struct OptTimestamp(#[serde(with = "time::serde::timestamp::option")] Option<OffsetDateTime>);
+
+    assert_de_tokens_error::<Timestamp>(
+        &[Token::Bool(false)],
+        "invalid type: boolean `false`, expected i64",
+    );
+    assert_de_tokens_error::<OptTimestamp>(
+        &[Token::Some, Token::Bool(false)],
+        "invalid type: boolean `false`, expected i64",
+    );
+    assert_de_tokens_error::<Timestamp>(
+        &[Token::I64(100_000_000_000_000)],
+        "invalid value: integer `100000000000000`, expected a value in the range \
+         -31619087596800..=31494784780799",
+    );
+    assert_de_tokens_error::<OptTimestamp>(
+        &[Token::Some, Token::I64(-100_000_000_000_000)],
+        "invalid value: integer `-100000000000000`, expected a value in the range \
+         -31619087596800..=31494784780799",
+    );
+}
diff --git a/tests/time.rs b/tests/time.rs
new file mode 100644
index 000000000..764852996
--- /dev/null
+++ b/tests/time.rs
@@ -0,0 +1,368 @@
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::time;
+use time::{Result, Time};
+
+#[test]
+fn from_hms() -> Result<()> {
+    let time = Time::from_hms(1, 2, 3)?;
+    assert_eq!(time.hour(), 1);
+    assert_eq!(time.minute(), 2);
+    assert_eq!(time.second(), 3);
+    assert_eq!(time.nanosecond(), 0);
+
+    assert!(Time::from_hms(24, 0, 0).is_err());
+    assert!(Time::from_hms(0, 60, 0).is_err());
+    assert!(Time::from_hms(0, 0, 60).is_err());
+    Ok(())
+}
+
+#[test]
+fn from_hms_milli() -> Result<()> {
+    let time = Time::from_hms_milli(1, 2, 3, 4)?;
+    assert_eq!(time.hour(), 1);
+    assert_eq!(time.minute(), 2);
+    assert_eq!(time.second(), 3);
+    assert_eq!(time.millisecond(), 4);
+    assert_eq!(time.nanosecond(), 4_000_000);
+
+    assert!(Time::from_hms_milli(24, 0, 0, 0).is_err());
+    assert!(Time::from_hms_milli(0, 60, 0, 0).is_err());
+    assert!(Time::from_hms_milli(0, 0, 60, 0).is_err());
+    assert!(Time::from_hms_milli(0, 0, 0, 1_000).is_err());
+    Ok(())
+}
+
+#[test]
+fn from_hms_micro() -> Result<()> {
+    let time = Time::from_hms_micro(1, 2, 3, 4)?;
+    assert_eq!(time.hour(), 1);
+    assert_eq!(time.minute(), 2);
+    assert_eq!(time.second(), 3);
+    assert_eq!(time.microsecond(), 4);
+    assert_eq!(time.nanosecond(), 4_000);
+
+    assert!(Time::from_hms_micro(24, 0, 0, 0).is_err());
+    assert!(Time::from_hms_micro(0, 60, 0, 0).is_err());
+    assert!(Time::from_hms_micro(0, 0, 60, 0).is_err());
+    assert!(Time::from_hms_micro(0, 0, 0, 1_000_000).is_err());
+    Ok(())
+}
+
+#[test]
+fn from_hms_nano() -> Result<()> {
+    let time = Time::from_hms_nano(1, 2, 3, 4)?;
+    assert_eq!(time.hour(), 1);
+    assert_eq!(time.minute(), 2);
+    assert_eq!(time.second(), 3);
+    assert_eq!(time.nanosecond(), 4);
+
+    assert!(Time::from_hms_nano(24, 0, 0, 0).is_err());
+    assert!(Time::from_hms_nano(0, 60, 0, 0).is_err());
+    assert!(Time::from_hms_nano(0, 0, 60, 0).is_err());
+    assert!(Time::from_hms_nano(0, 0, 0, 1_000_000_000).is_err());
+    Ok(())
+}
+
+#[test]
+fn as_hms() {
+    assert_eq!(time!(1:02:03).as_hms(), (1, 2, 3));
+}
+
+#[test]
+fn as_hms_milli() {
+    assert_eq!(time!(1:02:03.004).as_hms_milli(), (1, 2, 3, 4));
+}
+
+#[test]
+fn as_hms_micro() {
+    assert_eq!(time!(1:02:03.004_005).as_hms_micro(), (1, 2, 3, 4_005));
+}
+
+#[test]
+fn as_hms_nano() {
+    assert_eq!(
+        time!(1:02:03.004_005_006).as_hms_nano(),
+        (1, 2, 3, 4_005_006)
+    );
+}
+
+#[test]
+fn hour() -> Result<()> {
+    for hour in 0..24 {
+        assert_eq!(Time::from_hms(hour, 0, 0)?.hour(), hour);
+        assert_eq!(Time::from_hms(hour, 59, 59)?.hour(), hour);
+    }
+    Ok(())
+}
+
+#[test]
+fn minute() -> Result<()> {
+    for minute in 0..60 {
+        assert_eq!(Time::from_hms(0, minute, 0)?.minute(), minute);
+        assert_eq!(Time::from_hms(23, minute, 59)?.minute(), minute);
+    }
+    Ok(())
+}
+
+#[test]
+fn second() -> Result<()> {
+    for second in 0..60 {
+        assert_eq!(Time::from_hms(0, 0, second)?.second(), second);
+        assert_eq!(Time::from_hms(23, 59, second)?.second(), second);
+    }
+    Ok(())
+}
+
+#[test]
+fn millisecond() -> Result<()> {
+    for milli in 0..1_000 {
+        assert_eq!(Time::from_hms_milli(0, 0, 0, milli)?.millisecond(), milli);
+        assert_eq!(
+            Time::from_hms_milli(23, 59, 59, milli)?.millisecond(),
+            milli
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn microsecond() -> Result<()> {
+    for micro in (0..1_000_000).step_by(1_000) {
+        assert_eq!(Time::from_hms_micro(0, 0, 0, micro)?.microsecond(), micro);
+        assert_eq!(
+            Time::from_hms_micro(23, 59, 59, micro)?.microsecond(),
+            micro
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn nanosecond() -> Result<()> {
+    for nano in (0..1_000_000_000).step_by(1_000_000) {
+        assert_eq!(Time::from_hms_nano(0, 0, 0, nano)?.nanosecond(), nano);
+        assert_eq!(Time::from_hms_nano(23, 59, 59, nano)?.nanosecond(), nano);
+    }
+    Ok(())
+}
+
+#[test]
+fn replace_hour() {
+    assert_eq!(
+        time!(1:02:03.004_005_006).replace_hour(7),
+        Ok(time!(7:02:03.004_005_006))
+    );
+    assert!(time!(1:02:03.004_005_006).replace_hour(24).is_err());
+}
+
+#[test]
+fn replace_minute() {
+    assert_eq!(
+        time!(1:02:03.004_005_006).replace_minute(7),
+        Ok(time!(1:07:03.004_005_006))
+    );
+    assert!(time!(1:02:03.004_005_006).replace_minute(60).is_err());
+}
+
+#[test]
+fn replace_second() {
+    assert_eq!(
+        time!(1:02:03.004_005_006).replace_second(7),
+        Ok(time!(1:02:07.004_005_006))
+    );
+    assert!(time!(1:02:03.004_005_006).replace_second(60).is_err());
+}
+
+#[test]
+fn replace_millisecond() {
+    assert_eq!(
+        time!(1:02:03.004_005_006).replace_millisecond(7),
+        Ok(time!(1:02:03.007))
+    );
+    assert!(
+        time!(1:02:03.004_005_006)
+            .replace_millisecond(1_000)
+            .is_err()
+    );
+}
+
+#[test]
+fn replace_millisecond_regression() {
+    assert!(Time::MIDNIGHT.replace_millisecond(9999).is_err());
+    assert!(Time::MIDNIGHT.replace_millisecond(4294).is_err());
+    assert!(Time::MIDNIGHT.replace_millisecond(4295).is_err());
+}
+
+#[test]
+fn replace_microsecond() {
+    assert_eq!(
+        time!(1:02:03.004_005_006).replace_microsecond(7_008),
+        Ok(time!(1:02:03.007_008))
+    );
+    assert!(
+        time!(1:02:03.004_005_006)
+            .replace_microsecond(1_000_000)
+            .is_err()
+    );
+}
+
+#[test]
+fn replace_nanosecond() {
+    assert_eq!(
+        time!(1:02:03.004_005_006).replace_nanosecond(7_008_009),
+        Ok(time!(1:02:03.007_008_009))
+    );
+    assert!(
+        time!(1:02:03.004_005_006)
+            .replace_nanosecond(1_000_000_000)
+            .is_err()
+    );
+}
+
+#[test]
+fn add_duration() {
+    assert_eq!(time!(0:00) + 1.seconds(), time!(0:00:01));
+    assert_eq!(time!(0:00) + 1.minutes(), time!(0:01));
+    assert_eq!(time!(0:00) + 1.hours(), time!(1:00));
+    assert_eq!(time!(0:00) + 1.days(), time!(0:00));
+}
+
+#[test]
+fn add_assign_duration() {
+    let mut time = time!(0:00);
+
+    time += 1.seconds();
+    assert_eq!(time, time!(0:00:01));
+
+    time += 1.minutes();
+    assert_eq!(time, time!(0:01:01));
+
+    time += 1.hours();
+    assert_eq!(time, time!(1:01:01));
+
+    time += 1.days();
+    assert_eq!(time, time!(1:01:01));
+}
+
+#[test]
+fn sub_duration() {
+    assert_eq!(time!(12:00) - 1.hours(), time!(11:00));
+
+    // Underflow
+    assert_eq!(time!(0:00) - 1.seconds(), time!(23:59:59));
+    assert_eq!(time!(0:00) - 1.minutes(), time!(23:59));
+    assert_eq!(time!(0:00) - 1.hours(), time!(23:00));
+    assert_eq!(time!(0:00) - 1.days(), time!(0:00));
+}
+
+#[test]
+fn sub_assign_duration() {
+    let mut time = time!(0:00);
+
+    time -= 1.seconds();
+    assert_eq!(time, time!(23:59:59));
+
+    time -= 1.minutes();
+    assert_eq!(time, time!(23:58:59));
+
+    time -= 1.hours();
+    assert_eq!(time, time!(22:58:59));
+
+    time -= 1.days();
+    assert_eq!(time, time!(22:58:59));
+}
+
+#[test]
+fn add_std_duration() {
+    assert_eq!(time!(0:00) + 1.std_milliseconds(), time!(0:00:00.001));
+    assert_eq!(time!(0:00) + 1.std_seconds(), time!(0:00:01));
+    assert_eq!(time!(0:00) + 1.std_minutes(), time!(0:01));
+    assert_eq!(time!(0:00) + 1.std_hours(), time!(1:00));
+    assert_eq!(time!(0:00) + 1.std_days(), time!(0:00));
+}
+
+#[test]
+fn add_assign_std_duration() {
+    let mut time = time!(0:00);
+
+    time += 1.std_seconds();
+    assert_eq!(time, time!(0:00:01));
+
+    time += 1.std_minutes();
+    assert_eq!(time, time!(0:01:01));
+
+    time += 1.std_hours();
+    assert_eq!(time, time!(1:01:01));
+
+    time += 1.std_days();
+    assert_eq!(time, time!(1:01:01));
+}
+
+#[test]
+fn sub_std_duration() {
+    assert_eq!(time!(12:00) - 1.std_hours(), time!(11:00));
+
+    // Underflow
+    assert_eq!(time!(0:00) - 1.std_milliseconds(), time!(23:59:59.999));
+    assert_eq!(time!(0:00) - 1.std_seconds(), time!(23:59:59));
+    assert_eq!(time!(0:00) - 1.std_minutes(), time!(23:59));
+    assert_eq!(time!(0:00) - 1.std_hours(), time!(23:00));
+    assert_eq!(time!(0:00) - 1.std_days(), time!(0:00));
+}
+
+#[test]
+fn sub_assign_std_duration() {
+    let mut time = time!(0:00);
+
+    time -= 1.std_seconds();
+    assert_eq!(time, time!(23:59:59));
+
+    time -= 1.std_minutes();
+    assert_eq!(time, time!(23:58:59));
+
+    time -= 1.std_hours();
+    assert_eq!(time, time!(22:58:59));
+
+    time -= 1.std_days();
+    assert_eq!(time, time!(22:58:59));
+}
+
+#[test]
+fn sub_time() {
+    assert_eq!(time!(0:00) - time!(0:00), 0.seconds());
+    assert_eq!(time!(1:00) - time!(0:00), 1.hours());
+    assert_eq!(time!(1:00) - time!(0:00:01), 59.minutes() + 59.seconds());
+}
+
+#[test]
+fn ordering() {
+    assert!(time!(0:00) < time!(0:00:00.000_000_001));
+    assert!(time!(0:00) < time!(0:00:01));
+    assert!(time!(12:00) > time!(11:00));
+    assert_eq!(time!(0:00), time!(0:00));
+}
+
+#[test]
+fn ordering_lexico_endianness() {
+    // Endianness of nanoseconds
+    assert!(time!(00:00:00.4) > time!(00:00:00.1));
+    // Endianness of one field wrt the others
+    // Hourt wrt others
+    assert!(time!(01:00:00) > time!(00:01:00.0));
+    assert!(time!(01:00:00) > time!(00:00:01.0));
+    assert!(time!(01:00:00) > time!(00:00:00.1));
+    // Minutes wrt to others
+    assert!(time!(00:01:00) > time!(00:00:01.0));
+    assert!(time!(00:01:00) > time!(00:00:00.1));
+    // Second wrt to others
+    assert!(time!(00:00:01) > time!(00:00:00.1));
+}
+
+#[test]
+fn issue_481() {
+    assert_eq!(time!(0:00) - time!(01:00:00.1), (-3600.1).seconds());
+    assert_eq!(
+        time!(0:00) - time!(23:59:59.999_999_999),
+        (-86_399.999_999_999).seconds()
+    );
+}
diff --git a/tests/utc_offset.rs b/tests/utc_offset.rs
new file mode 100644
index 000000000..d8054c333
--- /dev/null
+++ b/tests/utc_offset.rs
@@ -0,0 +1,206 @@
+use rstest::rstest;
+use time::macros::offset;
+use time::{OffsetDateTime, UtcOffset};
+
+#[test]
+fn utc_is_zero() {
+    assert_eq!(offset!(UTC), offset!(+0));
+}
+
+#[rstest]
+#[case(0, 0, 0, offset!(UTC))]
+#[case(0, 0, 1, offset!(+0:00:01))]
+#[case(0, 0, -1, offset!(-0:00:01))]
+#[case(1, 0, 0, offset!(+1))]
+#[case(-1, 0, 0, offset!(-1))]
+#[case(23, 59, 0, offset!(+23:59))]
+#[case(-23, -59, 0, offset!(-23:59))]
+#[case(23, 59, 59, offset!(+23:59:59))]
+#[case(-23, -59, -59, offset!(-23:59:59))]
+#[case(1, 2, 3, offset!(+1:02:03))]
+#[case(1, -2, -3, offset!(+1:02:03))]
+#[case(0, 2, -3, offset!(+0:02:03))]
+fn from_hms(
+    #[case] hours: i8,
+    #[case] minutes: i8,
+    #[case] seconds: i8,
+    #[case] expected: UtcOffset,
+) {
+    assert_eq!(UtcOffset::from_hms(hours, minutes, seconds), Ok(expected));
+}
+
+#[rstest]
+#[case(0, offset!(UTC))]
+#[case(1, offset!(+0:00:01))]
+#[case(-1, offset!(-0:00:01))]
+#[case(3_600, offset!(+1))]
+#[case(-3_600, offset!(-1))]
+#[case(86_340, offset!(+23:59))]
+#[case(-86_340, offset!(-23:59))]
+#[case(86_399, offset!(+23:59:59))]
+#[case(-86_399, offset!(-23:59:59))]
+fn from_whole_seconds(#[case] seconds: i32, #[case] expected: UtcOffset) {
+    assert_eq!(UtcOffset::from_whole_seconds(seconds), Ok(expected));
+}
+
+#[rstest]
+#[case(offset!(UTC), (0, 0, 0))]
+#[case(offset!(+0:00:01), (0, 0, 1))]
+#[case(offset!(-0:00:01), (0, 0, -1))]
+#[case(offset!(+1), (1, 0, 0))]
+#[case(offset!(-1), (-1, 0, 0))]
+#[case(offset!(+23:59), (23, 59, 0))]
+#[case(offset!(-23:59), (-23, -59, 0))]
+#[case(offset!(+23:59:59), (23, 59, 59))]
+#[case(offset!(-23:59:59), (-23, -59, -59))]
+fn as_hms(#[case] offset: UtcOffset, #[case] expected: (i8, i8, i8)) {
+    assert_eq!(offset.as_hms(), expected);
+}
+
+#[rstest]
+#[case(offset!(+1:02:03), 1)]
+#[case(offset!(-1:02:03), -1)]
+fn whole_hours(#[case] offset: UtcOffset, #[case] expected: i8) {
+    assert_eq!(offset.whole_hours(), expected);
+}
+
+#[rstest]
+#[case(offset!(+1:02:03), 62)]
+#[case(offset!(-1:02:03), -62)]
+fn whole_minutes(#[case] offset: UtcOffset, #[case] expected: i16) {
+    assert_eq!(offset.whole_minutes(), expected);
+}
+
+#[rstest]
+#[case(offset!(+1:02:03), 2)]
+#[case(offset!(-1:02:03), -2)]
+fn minutes_past_hour(#[case] offset: UtcOffset, #[case] expected: i8) {
+    assert_eq!(offset.minutes_past_hour(), expected);
+}
+
+#[rstest]
+#[case(offset!(UTC), 0)]
+#[case(offset!(+0:00:01), 1)]
+#[case(offset!(-0:00:01), -1)]
+#[case(offset!(+1), 3_600)]
+#[case(offset!(-1), -3_600)]
+#[case(offset!(+23:59), 86_340)]
+#[case(offset!(-23:59), -86_340)]
+#[case(offset!(+23:59:59), 86_399)]
+#[case(offset!(-23:59:59), -86_399)]
+fn whole_seconds(#[case] offset: UtcOffset, #[case] expected: i32) {
+    assert_eq!(offset.whole_seconds(), expected);
+}
+
+#[rstest]
+#[case(offset!(+1:02:03), 3)]
+#[case(offset!(-1:02:03), -3)]
+fn seconds_past_minute(#[case] offset: UtcOffset, #[case] expected: i8) {
+    assert_eq!(offset.seconds_past_minute(), expected);
+}
+
+#[rstest]
+#[case(offset!(UTC), true)]
+#[case(offset!(+0:00:01), false)]
+#[case(offset!(-0:00:01), false)]
+#[case(offset!(+1), false)]
+#[case(offset!(-1), false)]
+#[case(offset!(+23:59), false)]
+#[case(offset!(-23:59), false)]
+#[case(offset!(+23:59:59), false)]
+#[case(offset!(-23:59:59), false)]
+fn is_utc(#[case] offset: UtcOffset, #[case] expected: bool) {
+    assert_eq!(offset.is_utc(), expected);
+}
+
+#[rstest]
+#[case(offset!(UTC), false)]
+#[case(offset!(+0:00:01), true)]
+#[case(offset!(-0:00:01), false)]
+#[case(offset!(+1), true)]
+#[case(offset!(-1), false)]
+#[case(offset!(+23:59), true)]
+#[case(offset!(-23:59), false)]
+#[case(offset!(+23:59:59), true)]
+#[case(offset!(-23:59:59), false)]
+fn is_positive(#[case] offset: UtcOffset, #[case] expected: bool) {
+    assert_eq!(offset.is_positive(), expected);
+}
+
+#[rstest]
+#[case(offset!(UTC), false)]
+#[case(offset!(+0:00:01), false)]
+#[case(offset!(-0:00:01), true)]
+#[case(offset!(+1), false)]
+#[case(offset!(-1), true)]
+#[case(offset!(+23:59), false)]
+#[case(offset!(-23:59), true)]
+#[case(offset!(+23:59:59), false)]
+#[case(offset!(-23:59:59), true)]
+fn is_negative(#[case] offset: UtcOffset, #[case] expected: bool) {
+    assert_eq!(offset.is_negative(), expected);
+}
+
+#[rstest]
+#[case(offset!(UTC), offset!(UTC))]
+#[case(offset!(+0:00:01), offset!(-0:00:01))]
+#[case(offset!(-0:00:01), offset!(+0:00:01))]
+#[case(offset!(+1), offset!(-1))]
+#[case(offset!(-1), offset!(+1))]
+#[case(offset!(+23:59), offset!(-23:59))]
+#[case(offset!(-23:59), offset!(+23:59))]
+#[case(offset!(+23:59:59), offset!(-23:59:59))]
+#[case(offset!(-23:59:59), offset!(+23:59:59))]
+fn neg(#[case] offset: UtcOffset, #[case] expected: UtcOffset) {
+    assert_eq!(-offset, expected);
+}
+
+#[cfg_attr(miri, ignore)]
+#[test]
+fn local_offset_at() {
+    use time::util::local_offset::*;
+
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
+
+    // Safety: Technically not sound. However, this is a test, and it's highly improbable that we
+    // will run into issues with setting an environment variable a few times.
+    unsafe { set_soundness(Soundness::Unsound) };
+    assert!(UtcOffset::local_offset_at(OffsetDateTime::UNIX_EPOCH).is_ok());
+    // Safety: We're setting it back to sound.
+    unsafe { set_soundness(Soundness::Sound) };
+}
+
+#[cfg_attr(miri, ignore)]
+#[test]
+fn current_local_offset() {
+    use time::util::local_offset::*;
+
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
+
+    // Safety: Technically not sound. However, this is a test, and it's highly improbable that we
+    // will run into issues with setting an environment variable a few times.
+    unsafe { set_soundness(Soundness::Unsound) };
+    assert!(UtcOffset::current_local_offset().is_ok());
+    // Safety: We're setting it back to sound.
+    unsafe { set_soundness(Soundness::Sound) };
+}
+
+// Note: This behavior is not guaranteed and will hopefully be changed in the future.
+#[test]
+#[cfg_attr(
+    any(
+        target_os = "netbsd",
+        target_os = "illumos",
+        not(target_family = "unix")
+    ),
+    ignore
+)]
+fn local_offset_error_when_multithreaded() {
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
+
+    std::thread::spawn(|| {
+        assert!(UtcOffset::current_local_offset().is_err());
+    })
+    .join()
+    .expect("failed to join thread");
+}
diff --git a/tests/util.rs b/tests/util.rs
new file mode 100644
index 000000000..8f0f67cf7
--- /dev/null
+++ b/tests/util.rs
@@ -0,0 +1,96 @@
+use rstest::rstest;
+use time::Month::*;
+use time::{util, Month};
+
+#[rstest]
+#[case(2019, January, 31)]
+#[case(2019, February, 28)]
+#[case(2019, March, 31)]
+#[case(2019, April, 30)]
+#[case(2019, May, 31)]
+#[case(2019, June, 30)]
+#[case(2019, July, 31)]
+#[case(2019, August, 31)]
+#[case(2019, September, 30)]
+#[case(2019, October, 31)]
+#[case(2019, November, 30)]
+#[case(2019, December, 31)]
+#[case(2020, January, 31)]
+#[case(2020, February, 29)]
+#[case(2020, March, 31)]
+#[case(2020, April, 30)]
+#[case(2020, May, 31)]
+#[case(2020, June, 30)]
+#[case(2020, July, 31)]
+#[case(2020, August, 31)]
+#[case(2020, September, 30)]
+#[case(2020, October, 31)]
+#[case(2020, November, 30)]
+#[case(2020, December, 31)]
+fn days_in_year_month(#[case] year: i32, #[case] month: Month, #[case] expected: u8) {
+    assert_eq!(util::days_in_year_month(year, month), expected);
+}
+
+#[rstest]
+#[case(1900, false)]
+#[case(2000, true)]
+#[case(2004, true)]
+#[case(2005, false)]
+#[case(2100, false)]
+fn is_leap_year(#[case] year: i32, #[case] expected: bool) {
+    assert_eq!(util::is_leap_year(year), expected);
+}
+
+#[rstest]
+#[case(1900, 365)]
+#[case(2000, 366)]
+#[case(2004, 366)]
+#[case(2005, 365)]
+#[case(2100, 365)]
+fn days_in_year(#[case] year: i32, #[case] expected: u16) {
+    assert_eq!(util::days_in_year(year), expected);
+}
+
+#[rstest]
+fn weeks_in_year() {
+    let num_weeks_for_years = [
+        52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52,
+        52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52,
+        52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52,
+        52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52,
+        52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52,
+        52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52,
+        52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52,
+        53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52,
+        53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52,
+        53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53,
+        52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53,
+        52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52,
+        52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52,
+        52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52,
+        52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52,
+        52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52,
+        52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52, 52, 53, 52, 52, 52, 52, 52, 53, 52, 52, 52,
+        52, 53, 52, 52, 52, 52, 52, 53, 52,
+    ];
+
+    for (year, &num_weeks) in (0..400).zip(&num_weeks_for_years) {
+        assert_eq!(util::weeks_in_year(year), num_weeks);
+    }
+}
+
+#[rstest]
+fn local_offset_soundness() {
+    use time::util::local_offset::*;
+
+    let _guard = crate::SOUNDNESS_LOCK.lock().expect("lock is poisoned");
+
+    assert_eq!(get_soundness(), Soundness::Sound);
+    // Safety: Technically not sound. However, this is a test, and it's highly improbable that we
+    // will run into issues with setting an environment variable a few times.
+    unsafe { set_soundness(Soundness::Unsound) };
+    assert_eq!(get_soundness(), Soundness::Unsound);
+    // Safety: We're setting it back to sound.
+    unsafe { set_soundness(Soundness::Sound) };
+    assert_eq!(get_soundness(), Soundness::Sound);
+}
diff --git a/tests/weekday.rs b/tests/weekday.rs
new file mode 100644
index 000000000..9b6ed54e0
--- /dev/null
+++ b/tests/weekday.rs
@@ -0,0 +1,145 @@
+use rstest::rstest;
+use time::Weekday::{self, *};
+
+#[rstest]
+#[case(Sunday, Saturday)]
+#[case(Monday, Sunday)]
+#[case(Tuesday, Monday)]
+#[case(Wednesday, Tuesday)]
+#[case(Thursday, Wednesday)]
+#[case(Friday, Thursday)]
+#[case(Saturday, Friday)]
+fn previous(#[case] current: Weekday, #[case] expected: Weekday) {
+    assert_eq!(current.previous(), expected);
+}
+
+#[rstest]
+#[case(Sunday, Monday)]
+#[case(Monday, Tuesday)]
+#[case(Tuesday, Wednesday)]
+#[case(Wednesday, Thursday)]
+#[case(Thursday, Friday)]
+#[case(Friday, Saturday)]
+#[case(Saturday, Sunday)]
+fn next(#[case] current: Weekday, #[case] expected: Weekday) {
+    assert_eq!(current.next(), expected);
+}
+
+#[rstest]
+#[case(Sunday, 0, Sunday)]
+#[case(Sunday, 1, Monday)]
+#[case(Sunday, 2, Tuesday)]
+#[case(Sunday, 3, Wednesday)]
+#[case(Sunday, 4, Thursday)]
+#[case(Sunday, 5, Friday)]
+#[case(Sunday, 6, Saturday)]
+#[case(Monday, 0, Monday)]
+#[case(Monday, 1, Tuesday)]
+#[case(Monday, 2, Wednesday)]
+#[case(Monday, 3, Thursday)]
+#[case(Monday, 4, Friday)]
+#[case(Monday, 5, Saturday)]
+#[case(Monday, 6, Sunday)]
+#[case(Sunday, 7, Sunday)]
+#[case(Sunday, u8::MAX, Wednesday)]
+#[case(Monday, 7, Monday)]
+#[case(Monday, u8::MAX, Thursday)]
+fn nth_next(#[case] current: Weekday, #[case] n: u8, #[case] expected: Weekday) {
+    assert_eq!(current.nth_next(n), expected);
+}
+
+#[rstest]
+#[case(Sunday, 0, Sunday)]
+#[case(Sunday, 1, Saturday)]
+#[case(Sunday, 2, Friday)]
+#[case(Sunday, 3, Thursday)]
+#[case(Sunday, 4, Wednesday)]
+#[case(Sunday, 5, Tuesday)]
+#[case(Sunday, 6, Monday)]
+#[case(Monday, 0, Monday)]
+#[case(Monday, 1, Sunday)]
+#[case(Monday, 2, Saturday)]
+#[case(Monday, 3, Friday)]
+#[case(Monday, 4, Thursday)]
+#[case(Monday, 5, Wednesday)]
+#[case(Monday, 6, Tuesday)]
+#[case(Sunday, 7, Sunday)]
+#[case(Sunday, u8::MAX, Thursday)]
+#[case(Monday, 7, Monday)]
+#[case(Monday, u8::MAX, Friday)]
+fn nth_prev(#[case] current: Weekday, #[case] n: u8, #[case] expected: Weekday) {
+    assert_eq!(current.nth_prev(n), expected);
+}
+
+#[rstest]
+#[case(Monday, 1)]
+#[case(Tuesday, 2)]
+#[case(Wednesday, 3)]
+#[case(Thursday, 4)]
+#[case(Friday, 5)]
+#[case(Saturday, 6)]
+#[case(Sunday, 7)]
+fn number_from_monday(#[case] weekday: Weekday, #[case] expected: u8) {
+    assert_eq!(weekday.number_from_monday(), expected);
+}
+
+#[rstest]
+#[case(Sunday, 1)]
+#[case(Monday, 2)]
+#[case(Tuesday, 3)]
+#[case(Wednesday, 4)]
+#[case(Thursday, 5)]
+#[case(Friday, 6)]
+#[case(Saturday, 7)]
+fn number_from_sunday(#[case] weekday: Weekday, #[case] expected: u8) {
+    assert_eq!(weekday.number_from_sunday(), expected);
+}
+
+#[rstest]
+#[case(Monday, 0)]
+#[case(Tuesday, 1)]
+#[case(Wednesday, 2)]
+#[case(Thursday, 3)]
+#[case(Friday, 4)]
+#[case(Saturday, 5)]
+#[case(Sunday, 6)]
+fn number_days_from_monday(#[case] weekday: Weekday, #[case] expected: u8) {
+    assert_eq!(weekday.number_days_from_monday(), expected);
+}
+
+#[rstest]
+#[case(Sunday, 0)]
+#[case(Monday, 1)]
+#[case(Tuesday, 2)]
+#[case(Wednesday, 3)]
+#[case(Thursday, 4)]
+#[case(Friday, 5)]
+#[case(Saturday, 6)]
+fn number_days_from_sunday(#[case] weekday: Weekday, #[case] expected: u8) {
+    assert_eq!(weekday.number_days_from_sunday(), expected);
+}
+
+#[rstest]
+#[case(Monday, "Monday")]
+#[case(Tuesday, "Tuesday")]
+#[case(Wednesday, "Wednesday")]
+#[case(Thursday, "Thursday")]
+#[case(Friday, "Friday")]
+#[case(Saturday, "Saturday")]
+#[case(Sunday, "Sunday")]
+fn display(#[case] weekday: Weekday, #[case] expected: &str) {
+    assert_eq!(weekday.to_string(), expected);
+}
+
+#[rstest]
+#[case("Monday", Ok(Monday))]
+#[case("Tuesday", Ok(Tuesday))]
+#[case("Wednesday", Ok(Wednesday))]
+#[case("Thursday", Ok(Thursday))]
+#[case("Friday", Ok(Friday))]
+#[case("Saturday", Ok(Saturday))]
+#[case("Sunday", Ok(Sunday))]
+#[case("foo", Err(time::error::InvalidVariant))]
+fn from_str(#[case] input: &str, #[case] expected: Result<Weekday, time::error::InvalidVariant>) {
+    assert_eq!(input.parse::<Weekday>(), expected);
+}
diff --git a/time-core/Cargo.toml b/time-core/Cargo.toml
new file mode 100644
index 000000000..c11597177
--- /dev/null
+++ b/time-core/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "time-core"
+version = "0.1.2"
+authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
+edition = "2021"
+rust-version = "1.67.0"
+repository = "https://github.com/time-rs/time"
+keywords = ["date", "time", "calendar", "duration"]
+categories = ["date-and-time"]
+license = "MIT OR Apache-2.0"
+description = "This crate is an implementation detail and should not be relied upon directly."
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--generate-link-to-definition"]
+
+[lints]
+workspace = true
+
+[dependencies]
diff --git a/time-core/LICENSE-Apache b/time-core/LICENSE-Apache
new file mode 120000
index 000000000..0cd69a3e2
--- /dev/null
+++ b/time-core/LICENSE-Apache
@@ -0,0 +1 @@
+../LICENSE-Apache
\ No newline at end of file
diff --git a/time-core/LICENSE-MIT b/time-core/LICENSE-MIT
new file mode 120000
index 000000000..76219eb72
--- /dev/null
+++ b/time-core/LICENSE-MIT
@@ -0,0 +1 @@
+../LICENSE-MIT
\ No newline at end of file
diff --git a/time-core/src/convert.rs b/time-core/src/convert.rs
new file mode 100644
index 000000000..9c28f0263
--- /dev/null
+++ b/time-core/src/convert.rs
@@ -0,0 +1,104 @@
+//! Conversion between units of time.
+
+use self::sealed::Per;
+
+mod sealed {
+    /// A trait for defining the ratio of two units of time.
+    ///
+    /// This trait is used to implement the `per` method on the various structs.
+    pub trait Per<T> {
+        /// The smallest unsigned integer type that can represent [`VALUE`](Self::VALUE).
+        type Output;
+
+        /// The number of one unit of time in the other.
+        const VALUE: Self::Output;
+    }
+}
+
+/// Declare and implement `Per` for all relevant types. Identity implementations are automatic.
+macro_rules! impl_per {
+    ($($t:ident ($str:literal) per {$(
+        $larger:ident : $output:ty = $value:expr
+    )*})*) => {$(
+        #[doc = concat!("A unit of time representing exactly one ", $str, ".")]
+        #[derive(Debug, Clone, Copy)]
+        pub struct $t;
+
+        impl $t {
+            #[doc = concat!("Obtain the number of times `", stringify!($t), "` can fit into `T`.")]
+            #[doc = concat!("If `T` is smaller than `", stringify!($t), "`, the code will fail to")]
+            /// compile. The return type is the smallest unsigned integer type that can represent
+            /// the value.
+            ///
+            /// Valid calls:
+            ///
+            #[doc = concat!("  - `", stringify!($t), "::per(", stringify!($t), ")` (returns `u8`)")]
+            $(#[doc = concat!("  - `", stringify!($t), "::per(", stringify!($larger), ")` (returns `", stringify!($output), "`)")])*
+            pub const fn per<T>(_larger: T) -> <Self as Per<T>>::Output
+            where
+                Self: Per<T>,
+                T: Copy,
+            {
+                Self::VALUE
+            }
+        }
+
+        impl Per<$t> for $t {
+            type Output = u8;
+
+            const VALUE: u8 = 1;
+        }
+
+        $(impl Per<$larger> for $t {
+            type Output = $output;
+
+            const VALUE: $output = $value;
+        })*
+    )*};
+}
+
+impl_per! {
+    Nanosecond ("nanosecond") per {
+        Microsecond: u16 = 1_000
+        Millisecond: u32 = 1_000_000
+        Second: u32 = 1_000_000_000
+        Minute: u64 = 60_000_000_000
+        Hour: u64 = 3_600_000_000_000
+        Day: u64 = 86_400_000_000_000
+        Week: u64 = 604_800_000_000_000
+    }
+    Microsecond ("microsecond") per {
+        Millisecond: u16 = 1_000
+        Second: u32 = 1_000_000
+        Minute: u32 = 60_000_000
+        Hour: u32 = 3_600_000_000
+        Day: u64 = 86_400_000_000
+        Week: u64 = 604_800_000_000
+    }
+    Millisecond ("millisecond") per {
+        Second: u16 = 1_000
+        Minute: u16 = 60_000
+        Hour: u32 = 3_600_000
+        Day: u32 = 86_400_000
+        Week: u32 = 604_800_000
+    }
+    Second ("second") per {
+        Minute: u8 = 60
+        Hour: u16 = 3_600
+        Day: u32 = 86_400
+        Week: u32 = 604_800
+    }
+    Minute ("minute") per {
+        Hour: u8 = 60
+        Day: u16 = 1_440
+        Week: u16 = 10_080
+    }
+    Hour ("hour") per {
+        Day: u8 = 24
+        Week: u8 = 168
+    }
+    Day ("day") per {
+        Week: u8 = 7
+    }
+    Week ("week") per {}
+}
diff --git a/time-core/src/lib.rs b/time-core/src/lib.rs
new file mode 100644
index 000000000..41c354786
--- /dev/null
+++ b/time-core/src/lib.rs
@@ -0,0 +1,11 @@
+//! Core items for `time`.
+//!
+//! This crate is an implementation detail of `time` and should not be relied upon directly.
+
+#![no_std]
+#![doc(html_favicon_url = "https://avatars0.githubusercontent.com/u/55999857")]
+#![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/55999857")]
+#![doc(test(attr(deny(warnings))))]
+
+pub mod convert;
+pub mod util;
diff --git a/time-core/src/util.rs b/time-core/src/util.rs
new file mode 100644
index 000000000..26ced0638
--- /dev/null
+++ b/time-core/src/util.rs
@@ -0,0 +1,52 @@
+//! Utility functions.
+
+/// Returns if the provided year is a leap year in the proleptic Gregorian calendar. Uses
+/// [astronomical year numbering](https://en.wikipedia.org/wiki/Astronomical_year_numbering).
+///
+/// ```rust
+/// # use time::util::is_leap_year;
+/// assert!(!is_leap_year(1900));
+/// assert!(is_leap_year(2000));
+/// assert!(is_leap_year(2004));
+/// assert!(!is_leap_year(2005));
+/// assert!(!is_leap_year(2100));
+/// ```
+pub const fn is_leap_year(year: i32) -> bool {
+    year % 4 == 0 && (year % 25 != 0 || year % 16 == 0)
+}
+
+/// Get the number of calendar days in a given year.
+///
+/// The returned value will always be either 365 or 366.
+///
+/// ```rust
+/// # use time::util::days_in_year;
+/// assert_eq!(days_in_year(1900), 365);
+/// assert_eq!(days_in_year(2000), 366);
+/// assert_eq!(days_in_year(2004), 366);
+/// assert_eq!(days_in_year(2005), 365);
+/// assert_eq!(days_in_year(2100), 365);
+/// ```
+pub const fn days_in_year(year: i32) -> u16 {
+    if is_leap_year(year) { 366 } else { 365 }
+}
+
+/// Get the number of weeks in the ISO year.
+///
+/// The returned value will always be either 52 or 53.
+///
+/// ```rust
+/// # use time::util::weeks_in_year;
+/// assert_eq!(weeks_in_year(2019), 52);
+/// assert_eq!(weeks_in_year(2020), 53);
+/// ```
+pub const fn weeks_in_year(year: i32) -> u8 {
+    match year.rem_euclid(400) {
+        4 | 9 | 15 | 20 | 26 | 32 | 37 | 43 | 48 | 54 | 60 | 65 | 71 | 76 | 82 | 88 | 93 | 99
+        | 105 | 111 | 116 | 122 | 128 | 133 | 139 | 144 | 150 | 156 | 161 | 167 | 172 | 178
+        | 184 | 189 | 195 | 201 | 207 | 212 | 218 | 224 | 229 | 235 | 240 | 246 | 252 | 257
+        | 263 | 268 | 274 | 280 | 285 | 291 | 296 | 303 | 308 | 314 | 320 | 325 | 331 | 336
+        | 342 | 348 | 353 | 359 | 364 | 370 | 376 | 381 | 387 | 392 | 398 => 53,
+        _ => 52,
+    }
+}
diff --git a/time-macros/Cargo.toml b/time-macros/Cargo.toml
new file mode 100644
index 000000000..3451de834
--- /dev/null
+++ b/time-macros/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "time-macros"
+version = "0.2.18"
+authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
+edition = "2021"
+rust-version = "1.67.0"
+repository = "https://github.com/time-rs/time"
+keywords = ["date", "time", "calendar", "duration"]
+categories = ["date-and-time"]
+license = "MIT OR Apache-2.0"
+description = """
+    Procedural macros for the time crate.
+    This crate is an implementation detail and should not be relied upon directly.
+"""
+
+[features]
+formatting = []
+large-dates = []
+parsing = []
+serde = []
+
+[lib]
+proc-macro = true
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--generate-link-to-definition"]
+
+[lints]
+workspace = true
+
+[dependencies]
+time-core = { workspace = true }
+num-conv = { workspace = true }
diff --git a/time-macros/LICENSE-Apache b/time-macros/LICENSE-Apache
new file mode 120000
index 000000000..0cd69a3e2
--- /dev/null
+++ b/time-macros/LICENSE-Apache
@@ -0,0 +1 @@
+../LICENSE-Apache
\ No newline at end of file
diff --git a/time-macros/LICENSE-MIT b/time-macros/LICENSE-MIT
new file mode 120000
index 000000000..76219eb72
--- /dev/null
+++ b/time-macros/LICENSE-MIT
@@ -0,0 +1 @@
+../LICENSE-MIT
\ No newline at end of file
diff --git a/time-macros/src/date.rs b/time-macros/src/date.rs
new file mode 100644
index 000000000..03cbf11ae
--- /dev/null
+++ b/time-macros/src/date.rs
@@ -0,0 +1,140 @@
+use std::iter::Peekable;
+
+use num_conv::Truncate;
+use proc_macro::{token_stream, TokenTree};
+use time_core::util::{days_in_year, weeks_in_year};
+
+use crate::helpers::{
+    consume_any_ident, consume_number, consume_punct, days_in_year_month, ymd_to_yo, ywd_to_yo,
+};
+use crate::to_tokens::ToTokenTree;
+use crate::Error;
+
+#[cfg(feature = "large-dates")]
+const MAX_YEAR: i32 = 999_999;
+#[cfg(not(feature = "large-dates"))]
+const MAX_YEAR: i32 = 9_999;
+
+pub(crate) struct Date {
+    pub(crate) year: i32,
+    pub(crate) ordinal: u16,
+}
+
+pub(crate) fn parse(chars: &mut Peekable<token_stream::IntoIter>) -> Result<Date, Error> {
+    let (year_sign_span, year_sign, explicit_sign) = if let Ok(span) = consume_punct('-', chars) {
+        (Some(span), -1, true)
+    } else if let Ok(span) = consume_punct('+', chars) {
+        (Some(span), 1, true)
+    } else {
+        (None, 1, false)
+    };
+    let (year_span, mut year) = consume_number::<i32>("year", chars)?;
+    year *= year_sign;
+    if year.abs() > MAX_YEAR {
+        return Err(Error::InvalidComponent {
+            name: "year",
+            value: year.to_string(),
+            span_start: Some(year_sign_span.unwrap_or(year_span)),
+            span_end: Some(year_span),
+        });
+    }
+    if !explicit_sign && year.abs() >= 10_000 {
+        return Err(Error::Custom {
+            message: "years with more than four digits must have an explicit sign".into(),
+            span_start: Some(year_sign_span.unwrap_or(year_span)),
+            span_end: Some(year_span),
+        });
+    }
+
+    consume_punct('-', chars)?;
+
+    // year-week-day
+    if let Ok(w_span) = consume_any_ident(&["W"], chars) {
+        let (week_span, week) = consume_number::<u8>("week", chars)?;
+        consume_punct('-', chars)?;
+        let (day_span, day) = consume_number::<u8>("day", chars)?;
+
+        if week > weeks_in_year(year) {
+            return Err(Error::InvalidComponent {
+                name: "week",
+                value: week.to_string(),
+                span_start: Some(w_span),
+                span_end: Some(week_span),
+            });
+        }
+        if day == 0 || day > 7 {
+            return Err(Error::InvalidComponent {
+                name: "day",
+                value: day.to_string(),
+                span_start: Some(day_span),
+                span_end: Some(day_span),
+            });
+        }
+
+        let (year, ordinal) = ywd_to_yo(year, week, day);
+
+        return Ok(Date { year, ordinal });
+    }
+
+    // We don't yet know whether it's year-month-day or year-ordinal.
+    let (month_or_ordinal_span, month_or_ordinal) =
+        consume_number::<u16>("month or ordinal", chars)?;
+
+    // year-month-day
+    #[allow(clippy::branches_sharing_code)] // clarity
+    if consume_punct('-', chars).is_ok() {
+        let (month_span, month) = (month_or_ordinal_span, month_or_ordinal);
+        let (day_span, day) = consume_number::<u8>("day", chars)?;
+
+        if month == 0 || month > 12 {
+            return Err(Error::InvalidComponent {
+                name: "month",
+                value: month.to_string(),
+                span_start: Some(month_span),
+                span_end: Some(month_span),
+            });
+        }
+        let month = month.truncate();
+        if day == 0 || day > days_in_year_month(year, month) {
+            return Err(Error::InvalidComponent {
+                name: "day",
+                value: day.to_string(),
+                span_start: Some(day_span),
+                span_end: Some(day_span),
+            });
+        }
+
+        let (year, ordinal) = ymd_to_yo(year, month, day);
+
+        Ok(Date { year, ordinal })
+    }
+    // year-ordinal
+    else {
+        let (ordinal_span, ordinal) = (month_or_ordinal_span, month_or_ordinal);
+
+        if ordinal == 0 || ordinal > days_in_year(year) {
+            return Err(Error::InvalidComponent {
+                name: "ordinal",
+                value: ordinal.to_string(),
+                span_start: Some(ordinal_span),
+                span_end: Some(ordinal_span),
+            });
+        }
+
+        Ok(Date { year, ordinal })
+    }
+}
+
+impl ToTokenTree for Date {
+    fn into_token_tree(self) -> TokenTree {
+        quote_group! {{
+            const DATE: ::time::Date = unsafe {
+                ::time::Date::__from_ordinal_date_unchecked(
+                    #(self.year),
+                    #(self.ordinal),
+                )
+            };
+            DATE
+        }}
+    }
+}
diff --git a/time-macros/src/datetime.rs b/time-macros/src/datetime.rs
new file mode 100644
index 000000000..2d41e9a53
--- /dev/null
+++ b/time-macros/src/datetime.rs
@@ -0,0 +1,57 @@
+use std::iter::Peekable;
+
+use proc_macro::{token_stream, Ident, Span, TokenTree};
+
+use crate::date::Date;
+use crate::error::Error;
+use crate::offset::Offset;
+use crate::time::Time;
+use crate::to_tokens::ToTokenTree;
+use crate::{date, offset, time};
+
+pub(crate) struct DateTime {
+    date: Date,
+    time: Time,
+    offset: Option<Offset>,
+}
+
+pub(crate) fn parse(chars: &mut Peekable<token_stream::IntoIter>) -> Result<DateTime, Error> {
+    let date = date::parse(chars)?;
+    let time = time::parse(chars)?;
+    let offset = match offset::parse(chars) {
+        Ok(offset) => Some(offset),
+        Err(Error::UnexpectedEndOfInput | Error::MissingComponent { name: "sign", .. }) => None,
+        Err(err) => return Err(err),
+    };
+
+    if let Some(token) = chars.peek() {
+        return Err(Error::UnexpectedToken {
+            tree: token.clone(),
+        });
+    }
+
+    Ok(DateTime { date, time, offset })
+}
+
+impl ToTokenTree for DateTime {
+    fn into_token_tree(self) -> TokenTree {
+        let (type_name, maybe_offset) = match self.offset {
+            Some(offset) => (
+                Ident::new("OffsetDateTime", Span::mixed_site()),
+                quote!(.assume_offset(#(offset))),
+            ),
+            None => (
+                Ident::new("PrimitiveDateTime", Span::mixed_site()),
+                quote!(),
+            ),
+        };
+
+        quote_group! {{
+            const DATE_TIME: ::time::#(type_name) = ::time::PrimitiveDateTime::new(
+                #(self.date),
+                #(self.time),
+            ) #S(maybe_offset);
+            DATE_TIME
+        }}
+    }
+}
diff --git a/time-macros/src/error.rs b/time-macros/src/error.rs
new file mode 100644
index 000000000..849317f15
--- /dev/null
+++ b/time-macros/src/error.rs
@@ -0,0 +1,123 @@
+use std::borrow::Cow;
+use std::fmt;
+
+use proc_macro::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
+
+trait WithSpan {
+    fn with_span(self, span: Span) -> Self;
+}
+
+impl WithSpan for TokenTree {
+    fn with_span(mut self, span: Span) -> Self {
+        self.set_span(span);
+        self
+    }
+}
+
+pub(crate) enum Error {
+    MissingComponent {
+        name: &'static str,
+        span_start: Option<Span>,
+        span_end: Option<Span>,
+    },
+    InvalidComponent {
+        name: &'static str,
+        value: String,
+        span_start: Option<Span>,
+        span_end: Option<Span>,
+    },
+    #[cfg(any(feature = "formatting", feature = "parsing"))]
+    ExpectedString {
+        span_start: Option<Span>,
+        span_end: Option<Span>,
+    },
+    UnexpectedToken {
+        tree: TokenTree,
+    },
+    UnexpectedEndOfInput,
+    Custom {
+        message: Cow<'static, str>,
+        span_start: Option<Span>,
+        span_end: Option<Span>,
+    },
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::MissingComponent { name, .. } => write!(f, "missing component: {name}"),
+            Self::InvalidComponent { name, value, .. } => {
+                write!(f, "invalid component: {name} was {value}")
+            }
+            #[cfg(any(feature = "formatting", feature = "parsing"))]
+            Self::ExpectedString { .. } => f.write_str("expected string literal"),
+            Self::UnexpectedToken { tree } => write!(f, "unexpected token: {tree}"),
+            Self::UnexpectedEndOfInput => f.write_str("unexpected end of input"),
+            Self::Custom { message, .. } => f.write_str(message),
+        }
+    }
+}
+
+impl Error {
+    fn span_start(&self) -> Span {
+        match self {
+            Self::MissingComponent { span_start, .. }
+            | Self::InvalidComponent { span_start, .. }
+            | Self::Custom { span_start, .. } => *span_start,
+            #[cfg(any(feature = "formatting", feature = "parsing"))]
+            Self::ExpectedString { span_start, .. } => *span_start,
+            Self::UnexpectedToken { tree } => Some(tree.span()),
+            Self::UnexpectedEndOfInput => Some(Span::mixed_site()),
+        }
+        .unwrap_or_else(Span::mixed_site)
+    }
+
+    fn span_end(&self) -> Span {
+        match self {
+            Self::MissingComponent { span_end, .. }
+            | Self::InvalidComponent { span_end, .. }
+            | Self::Custom { span_end, .. } => *span_end,
+            #[cfg(any(feature = "formatting", feature = "parsing"))]
+            Self::ExpectedString { span_end, .. } => *span_end,
+            Self::UnexpectedToken { tree, .. } => Some(tree.span()),
+            Self::UnexpectedEndOfInput => Some(Span::mixed_site()),
+        }
+        .unwrap_or_else(|| self.span_start())
+    }
+
+    pub(crate) fn to_compile_error(&self) -> TokenStream {
+        let (start, end) = (self.span_start(), self.span_end());
+
+        [
+            TokenTree::from(Punct::new(':', Spacing::Joint)).with_span(start),
+            TokenTree::from(Punct::new(':', Spacing::Alone)).with_span(start),
+            TokenTree::from(Ident::new("core", start)),
+            TokenTree::from(Punct::new(':', Spacing::Joint)).with_span(start),
+            TokenTree::from(Punct::new(':', Spacing::Alone)).with_span(start),
+            TokenTree::from(Ident::new("compile_error", start)),
+            TokenTree::from(Punct::new('!', Spacing::Alone)).with_span(start),
+            TokenTree::from(Group::new(
+                Delimiter::Parenthesis,
+                TokenStream::from(
+                    TokenTree::from(Literal::string(&self.to_string())).with_span(end),
+                ),
+            ))
+            .with_span(end),
+        ]
+        .iter()
+        .cloned()
+        .collect()
+    }
+
+    /// Like `to_compile_error`, but for use in macros that produce items.
+    #[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
+    pub(crate) fn to_compile_error_standalone(&self) -> TokenStream {
+        let end = self.span_end();
+        self.to_compile_error()
+            .into_iter()
+            .chain(std::iter::once(
+                TokenTree::from(Punct::new(';', Spacing::Alone)).with_span(end),
+            ))
+            .collect()
+    }
+}
diff --git a/time-macros/src/format_description/ast.rs b/time-macros/src/format_description/ast.rs
new file mode 100644
index 000000000..4c3a19e5a
--- /dev/null
+++ b/time-macros/src/format_description/ast.rs
@@ -0,0 +1,252 @@
+use std::iter;
+
+use super::{lexer, unused, Error, Location, Spanned, SpannedValue, Unused};
+
+pub(super) enum Item<'a> {
+    Literal(Spanned<&'a [u8]>),
+    EscapedBracket {
+        _first: Unused<Location>,
+        _second: Unused<Location>,
+    },
+    Component {
+        _opening_bracket: Unused<Location>,
+        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        name: Spanned<&'a [u8]>,
+        modifiers: Box<[Modifier<'a>]>,
+        _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        _closing_bracket: Unused<Location>,
+    },
+    Optional {
+        opening_bracket: Location,
+        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        _optional_kw: Unused<Spanned<&'a [u8]>>,
+        _whitespace: Unused<Spanned<&'a [u8]>>,
+        nested_format_description: NestedFormatDescription<'a>,
+        closing_bracket: Location,
+    },
+    First {
+        opening_bracket: Location,
+        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        _first_kw: Unused<Spanned<&'a [u8]>>,
+        _whitespace: Unused<Spanned<&'a [u8]>>,
+        nested_format_descriptions: Box<[NestedFormatDescription<'a>]>,
+        closing_bracket: Location,
+    },
+}
+
+pub(super) struct NestedFormatDescription<'a> {
+    pub(super) _opening_bracket: Unused<Location>,
+    pub(super) items: Box<[Item<'a>]>,
+    pub(super) _closing_bracket: Unused<Location>,
+    pub(super) _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+}
+
+pub(super) struct Modifier<'a> {
+    pub(super) _leading_whitespace: Unused<Spanned<&'a [u8]>>,
+    pub(super) key: Spanned<&'a [u8]>,
+    pub(super) _colon: Unused<Location>,
+    pub(super) value: Spanned<&'a [u8]>,
+}
+
+pub(super) fn parse<
+    'item: 'iter,
+    'iter,
+    I: Iterator<Item = Result<lexer::Token<'item>, Error>>,
+    const VERSION: u8,
+>(
+    tokens: &'iter mut lexer::Lexed<I>,
+) -> impl Iterator<Item = Result<Item<'item>, Error>> + 'iter {
+    assert!(version!(1..=2));
+    parse_inner::<_, false, VERSION>(tokens)
+}
+
+fn parse_inner<
+    'item,
+    I: Iterator<Item = Result<lexer::Token<'item>, Error>>,
+    const NESTED: bool,
+    const VERSION: u8,
+>(
+    tokens: &mut lexer::Lexed<I>,
+) -> impl Iterator<Item = Result<Item<'item>, Error>> + '_ {
+    iter::from_fn(move || {
+        if NESTED && tokens.peek_closing_bracket().is_some() {
+            return None;
+        }
+
+        let next = match tokens.next()? {
+            Ok(token) => token,
+            Err(err) => return Some(Err(err)),
+        };
+
+        Some(match next {
+            lexer::Token::Literal(Spanned { value: _, span: _ }) if NESTED => {
+                bug!("literal should not be present in nested description")
+            }
+            lexer::Token::Literal(value) => Ok(Item::Literal(value)),
+            lexer::Token::Bracket {
+                kind: lexer::BracketKind::Opening,
+                location,
+            } => {
+                if version!(..=1) {
+                    if let Some(second_location) = tokens.next_if_opening_bracket() {
+                        Ok(Item::EscapedBracket {
+                            _first: unused(location),
+                            _second: unused(second_location),
+                        })
+                    } else {
+                        parse_component::<_, VERSION>(location, tokens)
+                    }
+                } else {
+                    parse_component::<_, VERSION>(location, tokens)
+                }
+            }
+            lexer::Token::Bracket {
+                kind: lexer::BracketKind::Closing,
+                location: _,
+            } if NESTED => {
+                bug!("closing bracket should be caught by the `if` statement")
+            }
+            lexer::Token::Bracket {
+                kind: lexer::BracketKind::Closing,
+                location: _,
+            } => {
+                bug!("closing bracket should have been consumed by `parse_component`")
+            }
+            lexer::Token::ComponentPart { kind: _, value } if NESTED => Ok(Item::Literal(value)),
+            lexer::Token::ComponentPart { kind: _, value: _ } => {
+                bug!("component part should have been consumed by `parse_component`")
+            }
+        })
+    })
+}
+
+fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const VERSION: u8>(
+    opening_bracket: Location,
+    tokens: &mut lexer::Lexed<I>,
+) -> Result<Item<'a>, Error> {
+    let leading_whitespace = tokens.next_if_whitespace();
+
+    let Some(name) = tokens.next_if_not_whitespace() else {
+        let span = match leading_whitespace {
+            Some(Spanned { value: _, span }) => span,
+            None => opening_bracket.to(opening_bracket),
+        };
+        return Err(span.error("expected component name"));
+    };
+
+    if *name == b"optional" {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
+            return Err(name.span.error("expected whitespace after `optional`"));
+        };
+
+        let nested = parse_nested::<_, VERSION>(whitespace.span.end, tokens)?;
+
+        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+            return Err(opening_bracket.error("unclosed bracket"));
+        };
+
+        return Ok(Item::Optional {
+            opening_bracket,
+            _leading_whitespace: unused(leading_whitespace),
+            _optional_kw: unused(name),
+            _whitespace: unused(whitespace),
+            nested_format_description: nested,
+            closing_bracket,
+        });
+    }
+
+    if *name == b"first" {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
+            return Err(name.span.error("expected whitespace after `first`"));
+        };
+
+        let mut nested_format_descriptions = Vec::new();
+        while let Ok(description) = parse_nested::<_, VERSION>(whitespace.span.end, tokens) {
+            nested_format_descriptions.push(description);
+        }
+
+        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+            return Err(opening_bracket.error("unclosed bracket"));
+        };
+
+        return Ok(Item::First {
+            opening_bracket,
+            _leading_whitespace: unused(leading_whitespace),
+            _first_kw: unused(name),
+            _whitespace: unused(whitespace),
+            nested_format_descriptions: nested_format_descriptions.into_boxed_slice(),
+            closing_bracket,
+        });
+    }
+
+    let mut modifiers = Vec::new();
+    let trailing_whitespace = loop {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
+            break None;
+        };
+
+        if let Some(location) = tokens.next_if_opening_bracket() {
+            return Err(location
+                .to(location)
+                .error("modifier must be of the form `key:value`"));
+        }
+
+        let Some(Spanned { value, span }) = tokens.next_if_not_whitespace() else {
+            break Some(whitespace);
+        };
+
+        let Some(colon_index) = value.iter().position(|&b| b == b':') else {
+            return Err(span.error("modifier must be of the form `key:value`"));
+        };
+        let key = &value[..colon_index];
+        let value = &value[colon_index + 1..];
+
+        if key.is_empty() {
+            return Err(span.shrink_to_start().error("expected modifier key"));
+        }
+        if value.is_empty() {
+            return Err(span.shrink_to_end().error("expected modifier value"));
+        }
+
+        modifiers.push(Modifier {
+            _leading_whitespace: unused(whitespace),
+            key: key.spanned(span.shrink_to_before(colon_index as _)),
+            _colon: unused(span.start.offset(colon_index as _)),
+            value: value.spanned(span.shrink_to_after(colon_index as _)),
+        });
+    };
+
+    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+        return Err(opening_bracket.error("unclosed bracket"));
+    };
+
+    Ok(Item::Component {
+        _opening_bracket: unused(opening_bracket),
+        _leading_whitespace: unused(leading_whitespace),
+        name,
+        modifiers: modifiers.into_boxed_slice(),
+        _trailing_whitespace: unused(trailing_whitespace),
+        _closing_bracket: unused(closing_bracket),
+    })
+}
+
+fn parse_nested<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const VERSION: u8>(
+    last_location: Location,
+    tokens: &mut lexer::Lexed<I>,
+) -> Result<NestedFormatDescription<'a>, Error> {
+    let Some(opening_bracket) = tokens.next_if_opening_bracket() else {
+        return Err(last_location.error("expected opening bracket"));
+    };
+    let items = parse_inner::<_, true, VERSION>(tokens).collect::<Result<_, _>>()?;
+    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+        return Err(opening_bracket.error("unclosed bracket"));
+    };
+    let trailing_whitespace = tokens.next_if_whitespace();
+
+    Ok(NestedFormatDescription {
+        _opening_bracket: unused(opening_bracket),
+        items,
+        _closing_bracket: unused(closing_bracket),
+        _trailing_whitespace: unused(trailing_whitespace),
+    })
+}
diff --git a/time-macros/src/format_description/format_item.rs b/time-macros/src/format_description/format_item.rs
new file mode 100644
index 000000000..ea36caee0
--- /dev/null
+++ b/time-macros/src/format_description/format_item.rs
@@ -0,0 +1,438 @@
+use std::num::NonZeroU16;
+use std::str::{self, FromStr};
+
+use super::{ast, unused, Error, Span, Spanned, Unused};
+
+pub(super) fn parse<'a>(
+    ast_items: impl Iterator<Item = Result<ast::Item<'a>, Error>>,
+) -> impl Iterator<Item = Result<Item<'a>, Error>> {
+    ast_items.map(|ast_item| ast_item.and_then(Item::from_ast))
+}
+
+pub(super) enum Item<'a> {
+    Literal(&'a [u8]),
+    Component(Component),
+    Optional {
+        value: Box<[Self]>,
+        _span: Unused<Span>,
+    },
+    First {
+        value: Box<[Box<[Self]>]>,
+        _span: Unused<Span>,
+    },
+}
+
+impl Item<'_> {
+    pub(super) fn from_ast(ast_item: ast::Item<'_>) -> Result<Item<'_>, Error> {
+        Ok(match ast_item {
+            ast::Item::Component {
+                _opening_bracket: _,
+                _leading_whitespace: _,
+                name,
+                modifiers,
+                _trailing_whitespace: _,
+                _closing_bracket: _,
+            } => Item::Component(component_from_ast(&name, &modifiers)?),
+            ast::Item::Literal(Spanned { value, span: _ }) => Item::Literal(value),
+            ast::Item::EscapedBracket {
+                _first: _,
+                _second: _,
+            } => Item::Literal(b"["),
+            ast::Item::Optional {
+                opening_bracket,
+                _leading_whitespace: _,
+                _optional_kw: _,
+                _whitespace: _,
+                nested_format_description,
+                closing_bracket,
+            } => {
+                let items = nested_format_description
+                    .items
+                    .into_vec()
+                    .into_iter()
+                    .map(Item::from_ast)
+                    .collect::<Result<_, _>>()?;
+                Item::Optional {
+                    value: items,
+                    _span: unused(opening_bracket.to(closing_bracket)),
+                }
+            }
+            ast::Item::First {
+                opening_bracket,
+                _leading_whitespace: _,
+                _first_kw: _,
+                _whitespace: _,
+                nested_format_descriptions,
+                closing_bracket,
+            } => {
+                let items = nested_format_descriptions
+                    .into_vec()
+                    .into_iter()
+                    .map(|nested_format_description| {
+                        nested_format_description
+                            .items
+                            .into_vec()
+                            .into_iter()
+                            .map(Item::from_ast)
+                            .collect()
+                    })
+                    .collect::<Result<_, _>>()?;
+                Item::First {
+                    value: items,
+                    _span: unused(opening_bracket.to(closing_bracket)),
+                }
+            }
+        })
+    }
+}
+
+impl From<Item<'_>> for crate::format_description::public::OwnedFormatItem {
+    fn from(item: Item<'_>) -> Self {
+        match item {
+            Item::Literal(literal) => Self::Literal(literal.to_vec().into_boxed_slice()),
+            Item::Component(component) => Self::Component(component.into()),
+            Item::Optional { value, _span: _ } => Self::Optional(Box::new(value.into())),
+            Item::First { value, _span: _ } => {
+                Self::First(value.into_vec().into_iter().map(Into::into).collect())
+            }
+        }
+    }
+}
+
+impl<'a> From<Box<[Item<'a>]>> for crate::format_description::public::OwnedFormatItem {
+    fn from(items: Box<[Item<'a>]>) -> Self {
+        let items = items.into_vec();
+        match <[_; 1]>::try_from(items) {
+            Ok([item]) => item.into(),
+            Err(vec) => Self::Compound(vec.into_iter().map(Into::into).collect()),
+        }
+    }
+}
+
+macro_rules! component_definition {
+    (@if_required required then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($then)* };
+    (@if_required then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($($else)*)? };
+    (@if_from_str from_str then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($then)* };
+    (@if_from_str then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($($else)*)? };
+
+    ($vis:vis enum $name:ident {
+        $($variant:ident = $parse_variant:literal {$(
+            $(#[$required:tt])?
+            $field:ident = $parse_field:literal:
+            Option<$(#[$from_str:tt])? $field_type:ty>
+            => $target_field:ident
+        ),* $(,)?}),* $(,)?
+    }) => {
+        $vis enum $name {
+            $($variant($variant),)*
+        }
+
+        $($vis struct $variant {
+            $($field: Option<$field_type>),*
+        })*
+
+        $(impl $variant {
+            fn with_modifiers(
+                modifiers: &[ast::Modifier<'_>],
+                _component_span: Span,
+            ) -> Result<Self, Error>
+            {
+                #[allow(unused_mut)]
+                let mut this = Self {
+                    $($field: None),*
+                };
+
+                for modifier in modifiers {
+                    $(#[allow(clippy::string_lit_as_bytes)]
+                    if modifier.key.eq_ignore_ascii_case($parse_field.as_bytes()) {
+                        this.$field = component_definition!(@if_from_str $($from_str)?
+                            then {
+                                parse_from_modifier_value::<$field_type>(&modifier.value)?
+                            } else {
+                                <$field_type>::from_modifier_value(&modifier.value)?
+                            });
+                        continue;
+                    })*
+                    return Err(modifier.key.span.error("invalid modifier key"));
+                }
+
+                $(component_definition! { @if_required $($required)? then {
+                    if this.$field.is_none() {
+                        return Err(_component_span.error("missing required modifier"));
+                    }
+                }})*
+
+                Ok(this)
+            }
+        })*
+
+        impl From<$name> for crate::format_description::public::Component {
+            fn from(component: $name) -> Self {
+                match component {$(
+                    $name::$variant($variant { $($field),* }) => {
+                        $crate::format_description::public::Component::$variant(
+                            super::public::modifier::$variant {$(
+                                $target_field: component_definition! { @if_required $($required)?
+                                    then {
+                                        match $field {
+                                            Some(value) => value.into(),
+                                            None => bug!("required modifier was not set"),
+                                        }
+                                    } else {
+                                        $field.unwrap_or_default().into()
+                                    }
+                                }
+                            ),*}
+                        )
+                    }
+                )*}
+            }
+        }
+
+        fn component_from_ast(
+            name: &Spanned<&[u8]>,
+            modifiers: &[ast::Modifier<'_>],
+        ) -> Result<Component, Error> {
+            $(#[allow(clippy::string_lit_as_bytes)]
+            if name.eq_ignore_ascii_case($parse_variant.as_bytes()) {
+                return Ok(Component::$variant($variant::with_modifiers(&modifiers, name.span)?));
+            })*
+            Err(name.span.error("invalid component"))
+        }
+    }
+}
+
+component_definition! {
+    pub(super) enum Component {
+        Day = "day" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        End = "end" {},
+        Hour = "hour" {
+            padding = "padding": Option<Padding> => padding,
+            base = "repr": Option<HourBase> => is_12_hour_clock,
+        },
+        Ignore = "ignore" {
+            #[required]
+            count = "count": Option<#[from_str] NonZeroU16> => count,
+        },
+        Minute = "minute" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Month = "month" {
+            padding = "padding": Option<Padding> => padding,
+            repr = "repr": Option<MonthRepr> => repr,
+            case_sensitive = "case_sensitive": Option<MonthCaseSensitive> => case_sensitive,
+        },
+        OffsetHour = "offset_hour" {
+            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
+            padding = "padding": Option<Padding> => padding,
+        },
+        OffsetMinute = "offset_minute" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        OffsetSecond = "offset_second" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Ordinal = "ordinal" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Period = "period" {
+            case = "case": Option<PeriodCase> => is_uppercase,
+            case_sensitive = "case_sensitive": Option<PeriodCaseSensitive> => case_sensitive,
+        },
+        Second = "second" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Subsecond = "subsecond" {
+            digits = "digits": Option<SubsecondDigits> => digits,
+        },
+        UnixTimestamp = "unix_timestamp" {
+            precision = "precision": Option<UnixTimestampPrecision> => precision,
+            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
+        },
+        Weekday = "weekday" {
+            repr = "repr": Option<WeekdayRepr> => repr,
+            one_indexed = "one_indexed": Option<WeekdayOneIndexed> => one_indexed,
+            case_sensitive = "case_sensitive": Option<WeekdayCaseSensitive> => case_sensitive,
+        },
+        WeekNumber = "week_number" {
+            padding = "padding": Option<Padding> => padding,
+            repr = "repr": Option<WeekNumberRepr> => repr,
+        },
+        Year = "year" {
+            padding = "padding": Option<Padding> => padding,
+            repr = "repr": Option<YearRepr> => repr,
+            base = "base": Option<YearBase> => iso_week_based,
+            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
+        },
+    }
+}
+
+macro_rules! target_ty {
+    ($name:ident $type:ty) => {
+        $type
+    };
+    ($name:ident) => {
+        super::public::modifier::$name
+    };
+}
+
+/// Get the target value for a given enum.
+macro_rules! target_value {
+    ($name:ident $variant:ident $value:expr) => {
+        $value
+    };
+    ($name:ident $variant:ident) => {
+        super::public::modifier::$name::$variant
+    };
+}
+
+macro_rules! modifier {
+    ($(
+        enum $name:ident $(($target_ty:ty))? {
+            $(
+                $(#[$attr:meta])?
+                $variant:ident $(($target_value:expr))? = $parse_variant:literal
+            ),* $(,)?
+        }
+    )+) => {$(
+        #[derive(Default)]
+        enum $name {
+            $($(#[$attr])? $variant),*
+        }
+
+        impl $name {
+            /// Parse the modifier from its string representation.
+            fn from_modifier_value(value: &Spanned<&[u8]>) -> Result<Option<Self>, Error> {
+                $(if value.eq_ignore_ascii_case($parse_variant) {
+                    return Ok(Some(Self::$variant));
+                })*
+                Err(value.span.error("invalid modifier value"))
+            }
+        }
+
+        impl From<$name> for target_ty!($name $($target_ty)?) {
+            fn from(modifier: $name) -> Self {
+                match modifier {
+                    $($name::$variant => target_value!($name $variant $($target_value)?)),*
+                }
+            }
+        }
+    )+};
+}
+
+modifier! {
+    enum HourBase(bool) {
+        Twelve(true) = b"12",
+        #[default]
+        TwentyFour(false) = b"24",
+    }
+
+    enum MonthCaseSensitive(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum MonthRepr {
+        #[default]
+        Numerical = b"numerical",
+        Long = b"long",
+        Short = b"short",
+    }
+
+    enum Padding {
+        Space = b"space",
+        #[default]
+        Zero = b"zero",
+        None = b"none",
+    }
+
+    enum PeriodCase(bool) {
+        Lower(false) = b"lower",
+        #[default]
+        Upper(true) = b"upper",
+    }
+
+    enum PeriodCaseSensitive(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum SignBehavior(bool) {
+        #[default]
+        Automatic(false) = b"automatic",
+        Mandatory(true) = b"mandatory",
+    }
+
+    enum SubsecondDigits {
+        One = b"1",
+        Two = b"2",
+        Three = b"3",
+        Four = b"4",
+        Five = b"5",
+        Six = b"6",
+        Seven = b"7",
+        Eight = b"8",
+        Nine = b"9",
+        #[default]
+        OneOrMore = b"1+",
+    }
+
+    enum UnixTimestampPrecision {
+        #[default]
+        Second = b"second",
+        Millisecond = b"millisecond",
+        Microsecond = b"microsecond",
+        Nanosecond = b"nanosecond",
+    }
+
+    enum WeekNumberRepr {
+        #[default]
+        Iso = b"iso",
+        Sunday = b"sunday",
+        Monday = b"monday",
+    }
+
+    enum WeekdayCaseSensitive(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum WeekdayOneIndexed(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum WeekdayRepr {
+        Short = b"short",
+        #[default]
+        Long = b"long",
+        Sunday = b"sunday",
+        Monday = b"monday",
+    }
+
+    enum YearBase(bool) {
+        #[default]
+        Calendar(false) = b"calendar",
+        IsoWeek(true) = b"iso_week",
+    }
+
+    enum YearRepr {
+        #[default]
+        Full = b"full",
+        LastTwo = b"last_two",
+    }
+}
+
+fn parse_from_modifier_value<T: FromStr>(value: &Spanned<&[u8]>) -> Result<Option<T>, Error> {
+    str::from_utf8(value)
+        .ok()
+        .and_then(|val| val.parse::<T>().ok())
+        .map(|val| Some(val))
+        .ok_or_else(|| value.span.error("invalid modifier value"))
+}
diff --git a/time-macros/src/format_description/lexer.rs b/time-macros/src/format_description/lexer.rs
new file mode 100644
index 000000000..2ea53af57
--- /dev/null
+++ b/time-macros/src/format_description/lexer.rs
@@ -0,0 +1,248 @@
+use core::iter;
+
+use super::{Error, Location, Spanned, SpannedValue};
+
+pub(super) struct Lexed<I: Iterator> {
+    iter: iter::Peekable<I>,
+}
+
+impl<I: Iterator> Iterator for Lexed<I> {
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+}
+
+impl<'iter, 'token: 'iter, I: Iterator<Item = Result<Token<'token>, Error>> + 'iter> Lexed<I> {
+    pub(super) fn peek(&mut self) -> Option<&I::Item> {
+        self.iter.peek()
+    }
+
+    pub(super) fn next_if_whitespace(&mut self) -> Option<Spanned<&'token [u8]>> {
+        if let Some(&Ok(Token::ComponentPart {
+            kind: ComponentKind::Whitespace,
+            value,
+        })) = self.peek()
+        {
+            self.next(); // consume
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn next_if_not_whitespace(&mut self) -> Option<Spanned<&'token [u8]>> {
+        if let Some(&Ok(Token::ComponentPart {
+            kind: ComponentKind::NotWhitespace,
+            value,
+        })) = self.peek()
+        {
+            self.next();
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn next_if_opening_bracket(&mut self) -> Option<Location> {
+        if let Some(&Ok(Token::Bracket {
+            kind: BracketKind::Opening,
+            location,
+        })) = self.peek()
+        {
+            self.next();
+            Some(location)
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn peek_closing_bracket(&'iter mut self) -> Option<&'iter Location> {
+        if let Some(Ok(Token::Bracket {
+            kind: BracketKind::Closing,
+            location,
+        })) = self.peek()
+        {
+            Some(location)
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn next_if_closing_bracket(&mut self) -> Option<Location> {
+        if let Some(&Ok(Token::Bracket {
+            kind: BracketKind::Closing,
+            location,
+        })) = self.peek()
+        {
+            self.next();
+            Some(location)
+        } else {
+            None
+        }
+    }
+}
+
+pub(super) enum Token<'a> {
+    Literal(Spanned<&'a [u8]>),
+    Bracket {
+        kind: BracketKind,
+        location: Location,
+    },
+    ComponentPart {
+        kind: ComponentKind,
+        value: Spanned<&'a [u8]>,
+    },
+}
+
+pub(super) enum BracketKind {
+    Opening,
+    Closing,
+}
+
+pub(super) enum ComponentKind {
+    #[allow(clippy::missing_docs_in_private_items)]
+    Whitespace,
+    #[allow(clippy::missing_docs_in_private_items)]
+    NotWhitespace,
+}
+
+fn attach_location<'item>(
+    iter: impl Iterator<Item = &'item u8>,
+    proc_span: proc_macro::Span,
+) -> impl Iterator<Item = (&'item u8, Location)> {
+    let mut byte_pos = 0;
+
+    iter.map(move |byte| {
+        let location = Location {
+            byte: byte_pos,
+            proc_span,
+        };
+        byte_pos += 1;
+        (byte, location)
+    })
+}
+
+#[allow(clippy::unused_peekable)] // false positive
+pub(super) fn lex<const VERSION: u8>(
+    mut input: &[u8],
+    proc_span: proc_macro::Span,
+) -> Lexed<impl Iterator<Item = Result<Token<'_>, Error>>> {
+    assert!(version!(1..=2));
+
+    let mut depth: u8 = 0;
+    let mut iter = attach_location(input.iter(), proc_span).peekable();
+    let mut second_bracket_location = None;
+
+    let iter = iter::from_fn(move || {
+        if version!(..=1) {
+            if let Some(location) = second_bracket_location.take() {
+                return Some(Ok(Token::Bracket {
+                    kind: BracketKind::Opening,
+                    location,
+                }));
+            }
+        }
+
+        Some(Ok(match iter.next()? {
+            (b'\\', backslash_loc) if version!(2..) => match iter.next() {
+                Some((b'\\' | b'[' | b']', char_loc)) => {
+                    let char = &input[1..2];
+                    input = &input[2..];
+                    if depth == 0 {
+                        Token::Literal(char.spanned(backslash_loc.to(char_loc)))
+                    } else {
+                        Token::ComponentPart {
+                            kind: ComponentKind::NotWhitespace,
+                            value: char.spanned(backslash_loc.to(char_loc)),
+                        }
+                    }
+                }
+                Some((_, loc)) => {
+                    return Some(Err(loc.error("invalid escape sequence")));
+                }
+                None => {
+                    return Some(Err(backslash_loc.error("unexpected end of input")));
+                }
+            },
+            (b'[', location) if version!(..=1) => {
+                if let Some((_, second_location)) = iter.next_if(|&(&byte, _)| byte == b'[') {
+                    second_bracket_location = Some(second_location);
+                    input = &input[2..];
+                } else {
+                    depth += 1;
+                    input = &input[1..];
+                }
+
+                Token::Bracket {
+                    kind: BracketKind::Opening,
+                    location,
+                }
+            }
+            (b'[', location) => {
+                depth += 1;
+                input = &input[1..];
+
+                Token::Bracket {
+                    kind: BracketKind::Opening,
+                    location,
+                }
+            }
+            (b']', location) if depth > 0 => {
+                depth -= 1;
+                input = &input[1..];
+
+                Token::Bracket {
+                    kind: BracketKind::Closing,
+                    location,
+                }
+            }
+            (_, start_location) if depth == 0 => {
+                let mut bytes = 1;
+                let mut end_location = start_location;
+
+                while let Some((_, location)) =
+                    iter.next_if(|&(&byte, _)| !((version!(2..) && byte == b'\\') || byte == b'['))
+                {
+                    end_location = location;
+                    bytes += 1;
+                }
+
+                let value = &input[..bytes];
+                input = &input[bytes..];
+
+                Token::Literal(value.spanned(start_location.to(end_location)))
+            }
+            (byte, start_location) => {
+                let mut bytes = 1;
+                let mut end_location = start_location;
+                let is_whitespace = byte.is_ascii_whitespace();
+
+                while let Some((_, location)) = iter.next_if(|&(byte, _)| {
+                    !matches!(byte, b'\\' | b'[' | b']')
+                        && is_whitespace == byte.is_ascii_whitespace()
+                }) {
+                    end_location = location;
+                    bytes += 1;
+                }
+
+                let value = &input[..bytes];
+                input = &input[bytes..];
+
+                Token::ComponentPart {
+                    kind: if is_whitespace {
+                        ComponentKind::Whitespace
+                    } else {
+                        ComponentKind::NotWhitespace
+                    },
+                    value: value.spanned(start_location.to(end_location)),
+                }
+            }
+        }))
+    });
+
+    Lexed {
+        iter: iter.peekable(),
+    }
+}
diff --git a/time-macros/src/format_description/mod.rs b/time-macros/src/format_description/mod.rs
new file mode 100644
index 000000000..676028dec
--- /dev/null
+++ b/time-macros/src/format_description/mod.rs
@@ -0,0 +1,169 @@
+//! Parser for format descriptions.
+
+macro_rules! version {
+    ($range:expr) => {
+        $range.contains(&VERSION)
+    };
+}
+
+mod ast;
+mod format_item;
+mod lexer;
+mod public;
+
+pub(crate) fn parse_with_version(
+    version: Option<crate::FormatDescriptionVersion>,
+    s: &[u8],
+    proc_span: proc_macro::Span,
+) -> Result<Vec<public::OwnedFormatItem>, crate::Error> {
+    match version {
+        Some(crate::FormatDescriptionVersion::V1) | None => parse::<1>(s, proc_span),
+        Some(crate::FormatDescriptionVersion::V2) => parse::<2>(s, proc_span),
+    }
+}
+
+fn parse<const VERSION: u8>(
+    s: &[u8],
+    proc_span: proc_macro::Span,
+) -> Result<Vec<public::OwnedFormatItem>, crate::Error> {
+    let mut lexed = lexer::lex::<VERSION>(s, proc_span);
+    let ast = ast::parse::<_, VERSION>(&mut lexed);
+    let format_items = format_item::parse(ast);
+    Ok(format_items
+        .map(|res| res.map(Into::into))
+        .collect::<Result<_, _>>()?)
+}
+
+#[derive(Clone, Copy)]
+struct Location {
+    byte: u32,
+    proc_span: proc_macro::Span,
+}
+
+impl Location {
+    fn to(self, end: Self) -> Span {
+        Span { start: self, end }
+    }
+
+    #[must_use = "this does not modify the original value"]
+    fn offset(&self, offset: u32) -> Self {
+        Self {
+            byte: self.byte + offset,
+            proc_span: self.proc_span,
+        }
+    }
+
+    fn error(self, message: &'static str) -> Error {
+        Error {
+            message,
+            _span: unused(Span {
+                start: self,
+                end: self,
+            }),
+            proc_span: self.proc_span,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct Span {
+    #[allow(clippy::missing_docs_in_private_items)]
+    start: Location,
+    #[allow(clippy::missing_docs_in_private_items)]
+    end: Location,
+}
+
+impl Span {
+    #[must_use = "this does not modify the original value"]
+    const fn shrink_to_start(&self) -> Self {
+        Self {
+            start: self.start,
+            end: self.start,
+        }
+    }
+
+    #[must_use = "this does not modify the original value"]
+    const fn shrink_to_end(&self) -> Self {
+        Self {
+            start: self.end,
+            end: self.end,
+        }
+    }
+
+    #[must_use = "this does not modify the original value"]
+    const fn shrink_to_before(&self, pos: u32) -> Self {
+        Self {
+            start: self.start,
+            end: Location {
+                byte: self.start.byte + pos - 1,
+                proc_span: self.start.proc_span,
+            },
+        }
+    }
+
+    #[must_use = "this does not modify the original value"]
+    fn shrink_to_after(&self, pos: u32) -> Self {
+        Self {
+            start: Location {
+                byte: self.start.byte + pos + 1,
+                proc_span: self.start.proc_span,
+            },
+            end: self.end,
+        }
+    }
+
+    fn error(self, message: &'static str) -> Error {
+        Error {
+            message,
+            _span: unused(self),
+            proc_span: self.start.proc_span,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct Spanned<T> {
+    value: T,
+    span: Span,
+}
+
+impl<T> core::ops::Deref for Spanned<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+trait SpannedValue: Sized {
+    fn spanned(self, span: Span) -> Spanned<Self>;
+}
+
+impl<T> SpannedValue for T {
+    fn spanned(self, span: Span) -> Spanned<Self> {
+        Spanned { value: self, span }
+    }
+}
+
+struct Error {
+    message: &'static str,
+    _span: Unused<Span>,
+    proc_span: proc_macro::Span,
+}
+
+impl From<Error> for crate::Error {
+    fn from(error: Error) -> Self {
+        Self::Custom {
+            message: error.message.into(),
+            span_start: Some(error.proc_span),
+            span_end: Some(error.proc_span),
+        }
+    }
+}
+
+struct Unused<T>(core::marker::PhantomData<T>);
+
+#[allow(clippy::missing_const_for_fn)] // false positive
+fn unused<T>(_: T) -> Unused<T> {
+    Unused(core::marker::PhantomData)
+}
diff --git a/time-macros/src/format_description/public/component.rs b/time-macros/src/format_description/public/component.rs
new file mode 100644
index 000000000..94c73f0fb
--- /dev/null
+++ b/time-macros/src/format_description/public/component.rs
@@ -0,0 +1,50 @@
+use proc_macro::{Ident, Span, TokenStream};
+
+use super::modifier;
+use crate::to_tokens::ToTokenStream;
+
+macro_rules! declare_component {
+    ($($name:ident)*) => {
+        pub(crate) enum Component {$(
+            $name(modifier::$name),
+        )*}
+
+        impl ToTokenStream for Component {
+            fn append_to(self, ts: &mut TokenStream) {
+                let mut mts = TokenStream::new();
+
+                let component = match self {$(
+                    Self::$name(modifier) => {
+                        modifier.append_to(&mut mts);
+                        stringify!($name)
+                    }
+                )*};
+                let component = Ident::new(component, Span::mixed_site());
+
+                quote_append! { ts
+                    ::time::format_description::Component::#(component)(#S(mts))
+                }
+            }
+        }
+    };
+}
+
+declare_component! {
+    Day
+    Month
+    Ordinal
+    Weekday
+    WeekNumber
+    Year
+    Hour
+    Minute
+    Period
+    Second
+    Subsecond
+    OffsetHour
+    OffsetMinute
+    OffsetSecond
+    Ignore
+    UnixTimestamp
+    End
+}
diff --git a/time-macros/src/format_description/public/mod.rs b/time-macros/src/format_description/public/mod.rs
new file mode 100644
index 000000000..9fd8b5ece
--- /dev/null
+++ b/time-macros/src/format_description/public/mod.rs
@@ -0,0 +1,54 @@
+mod component;
+pub(super) mod modifier;
+
+use proc_macro::{Literal, TokenStream};
+
+pub(crate) use self::component::Component;
+use crate::to_tokens::ToTokenStream;
+
+#[allow(variant_size_differences)]
+pub(crate) enum OwnedFormatItem {
+    Literal(Box<[u8]>),
+    Component(Component),
+    Compound(Box<[Self]>),
+    Optional(Box<Self>),
+    First(Box<[Self]>),
+}
+
+impl ToTokenStream for OwnedFormatItem {
+    fn append_to(self, ts: &mut TokenStream) {
+        match self {
+            Self::Literal(bytes) => quote_append! { ts
+                ::time::format_description::BorrowedFormatItem::Literal {
+                    0: #(Literal::byte_string(bytes.as_ref()))
+                }
+            },
+            Self::Component(component) => quote_append! { ts
+                ::time::format_description::BorrowedFormatItem::Component { 0: #S(component) }
+            },
+            Self::Compound(items) => {
+                let items = items
+                    .into_vec()
+                    .into_iter()
+                    .map(|item| quote! { #S(item), })
+                    .collect::<TokenStream>();
+                quote_append! { ts
+                    ::time::format_description::BorrowedFormatItem::Compound { 0: &[#S(items)] }
+                }
+            }
+            Self::Optional(item) => quote_append! {ts
+                ::time::format_description::BorrowedFormatItem::Optional { 0: &#S(*item) }
+            },
+            Self::First(items) => {
+                let items = items
+                    .into_vec()
+                    .into_iter()
+                    .map(|item| quote! { #S(item), })
+                    .collect::<TokenStream>();
+                quote_append! { ts
+                    ::time::format_description::BorrowedFormatItem::First { 0: &[#S(items)] }
+                }
+            }
+        }
+    }
+}
diff --git a/time-macros/src/format_description/public/modifier.rs b/time-macros/src/format_description/public/modifier.rs
new file mode 100644
index 000000000..63bfaa706
--- /dev/null
+++ b/time-macros/src/format_description/public/modifier.rs
@@ -0,0 +1,251 @@
+use std::num::NonZeroU16;
+
+use proc_macro::{Ident, Span, TokenStream, TokenTree};
+
+use crate::to_tokens::{ToTokenStream, ToTokenTree};
+
+macro_rules! to_tokens {
+    (
+        $(#[$struct_attr:meta])*
+        $struct_vis:vis struct $struct_name:ident {$(
+            $(#[$field_attr:meta])*
+            $field_vis:vis $field_name:ident : $field_ty:ty
+        ),* $(,)?}
+    ) => {
+        $(#[$struct_attr])*
+        $struct_vis struct $struct_name {$(
+            $(#[$field_attr])*
+            $field_vis $field_name: $field_ty
+        ),*}
+
+        impl ToTokenTree for $struct_name {
+            fn into_token_tree(self) -> TokenTree {
+                let mut tokens = TokenStream::new();
+                let Self {$($field_name),*} = self;
+
+                quote_append! { tokens
+                    let mut value = ::time::format_description::modifier::$struct_name::default();
+                };
+                $(
+                    quote_append!(tokens value.$field_name =);
+                    $field_name.append_to(&mut tokens);
+                    quote_append!(tokens ;);
+                )*
+                quote_append!(tokens value);
+
+                proc_macro::TokenTree::Group(proc_macro::Group::new(
+                    proc_macro::Delimiter::Brace,
+                    tokens,
+                ))
+            }
+        }
+    };
+
+    (
+        $(#[$enum_attr:meta])*
+        $enum_vis:vis enum $enum_name:ident {$(
+            $(#[$variant_attr:meta])*
+            $variant_name:ident
+        ),+ $(,)?}
+    ) => {
+        $(#[$enum_attr])*
+        $enum_vis enum $enum_name {$(
+            $(#[$variant_attr])*
+            $variant_name
+        ),+}
+
+        impl ToTokenStream for $enum_name {
+            fn append_to(self, ts: &mut TokenStream) {
+                quote_append! { ts
+                    ::time::format_description::modifier::$enum_name::
+                };
+                let name = match self {
+                    $(Self::$variant_name => stringify!($variant_name)),+
+                };
+                ts.extend([TokenTree::Ident(Ident::new(name, Span::mixed_site()))]);
+            }
+        }
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Day {
+        pub(crate) padding: Padding,
+    }
+}
+
+to_tokens! {
+    pub(crate) enum MonthRepr {
+        Numerical,
+        Long,
+        Short,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Month {
+        pub(crate) padding: Padding,
+        pub(crate) repr: MonthRepr,
+        pub(crate) case_sensitive: bool,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Ordinal {
+        pub(crate) padding: Padding,
+    }
+}
+
+to_tokens! {
+    pub(crate) enum WeekdayRepr {
+        Short,
+        Long,
+        Sunday,
+        Monday,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Weekday {
+        pub(crate) repr: WeekdayRepr,
+        pub(crate) one_indexed: bool,
+        pub(crate) case_sensitive: bool,
+    }
+}
+
+to_tokens! {
+    pub(crate) enum WeekNumberRepr {
+        Iso,
+        Sunday,
+        Monday,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct WeekNumber {
+        pub(crate) padding: Padding,
+        pub(crate) repr: WeekNumberRepr,
+    }
+}
+
+to_tokens! {
+    pub(crate) enum YearRepr {
+        Full,
+        LastTwo,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Year {
+        pub(crate) padding: Padding,
+        pub(crate) repr: YearRepr,
+        pub(crate) iso_week_based: bool,
+        pub(crate) sign_is_mandatory: bool,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Hour {
+        pub(crate) padding: Padding,
+        pub(crate) is_12_hour_clock: bool,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Minute {
+        pub(crate) padding: Padding,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Period {
+        pub(crate) is_uppercase: bool,
+        pub(crate) case_sensitive: bool,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Second {
+        pub(crate) padding: Padding,
+    }
+}
+
+to_tokens! {
+    pub(crate) enum SubsecondDigits {
+        One,
+        Two,
+        Three,
+        Four,
+        Five,
+        Six,
+        Seven,
+        Eight,
+        Nine,
+        OneOrMore,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct Subsecond {
+        pub(crate) digits: SubsecondDigits,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct OffsetHour {
+        pub(crate) sign_is_mandatory: bool,
+        pub(crate) padding: Padding,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct OffsetMinute {
+        pub(crate) padding: Padding,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct OffsetSecond {
+        pub(crate) padding: Padding,
+    }
+}
+
+to_tokens! {
+    pub(crate) enum Padding {
+        Space,
+        Zero,
+        None,
+    }
+}
+
+pub(crate) struct Ignore {
+    pub(crate) count: NonZeroU16,
+}
+
+impl ToTokenTree for Ignore {
+    fn into_token_tree(self) -> TokenTree {
+        quote_group! {{
+            ::time::format_description::modifier::Ignore::count(#(self.count))
+        }}
+    }
+}
+
+to_tokens! {
+    pub(crate) enum UnixTimestampPrecision {
+        Second,
+        Millisecond,
+        Microsecond,
+        Nanosecond,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct UnixTimestamp {
+        pub(crate) precision: UnixTimestampPrecision,
+        pub(crate) sign_is_mandatory: bool,
+    }
+}
+
+to_tokens! {
+    pub(crate) struct End {}
+}
diff --git a/time-macros/src/helpers/mod.rs b/time-macros/src/helpers/mod.rs
new file mode 100644
index 000000000..0cca2002d
--- /dev/null
+++ b/time-macros/src/helpers/mod.rs
@@ -0,0 +1,131 @@
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+mod string;
+
+use std::iter::Peekable;
+use std::str::FromStr;
+
+use num_conv::prelude::*;
+use proc_macro::{token_stream, Span, TokenTree};
+use time_core::util::{days_in_year, is_leap_year};
+
+use crate::Error;
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+pub(crate) fn get_string_literal(
+    mut tokens: impl Iterator<Item = TokenTree>,
+) -> Result<(Span, Vec<u8>), Error> {
+    match (tokens.next(), tokens.next()) {
+        (Some(TokenTree::Literal(literal)), None) => string::parse(&literal),
+        (Some(tree), None) => Err(Error::ExpectedString {
+            span_start: Some(tree.span()),
+            span_end: Some(tree.span()),
+        }),
+        (_, Some(tree)) => Err(Error::UnexpectedToken { tree }),
+        (None, None) => Err(Error::ExpectedString {
+            span_start: None,
+            span_end: None,
+        }),
+    }
+}
+
+pub(crate) fn consume_number<T: FromStr>(
+    component_name: &'static str,
+    chars: &mut Peekable<token_stream::IntoIter>,
+) -> Result<(Span, T), Error> {
+    let (span, digits) = match chars.next() {
+        Some(TokenTree::Literal(literal)) => (literal.span(), literal.to_string()),
+        Some(tree) => return Err(Error::UnexpectedToken { tree }),
+        None => return Err(Error::UnexpectedEndOfInput),
+    };
+
+    if let Ok(value) = digits.replace('_', "").parse() {
+        Ok((span, value))
+    } else {
+        Err(Error::InvalidComponent {
+            name: component_name,
+            value: digits,
+            span_start: Some(span),
+            span_end: Some(span),
+        })
+    }
+}
+
+pub(crate) fn consume_any_ident(
+    idents: &[&str],
+    chars: &mut Peekable<token_stream::IntoIter>,
+) -> Result<Span, Error> {
+    match chars.peek() {
+        Some(TokenTree::Ident(char)) if idents.contains(&char.to_string().as_str()) => {
+            let ret = Ok(char.span());
+            drop(chars.next());
+            ret
+        }
+        Some(tree) => Err(Error::UnexpectedToken { tree: tree.clone() }),
+        None => Err(Error::UnexpectedEndOfInput),
+    }
+}
+
+pub(crate) fn consume_punct(
+    c: char,
+    chars: &mut Peekable<token_stream::IntoIter>,
+) -> Result<Span, Error> {
+    match chars.peek() {
+        Some(TokenTree::Punct(punct)) if *punct == c => {
+            let ret = Ok(punct.span());
+            drop(chars.next());
+            ret
+        }
+        Some(tree) => Err(Error::UnexpectedToken { tree: tree.clone() }),
+        None => Err(Error::UnexpectedEndOfInput),
+    }
+}
+
+fn jan_weekday(year: i32, ordinal: i32) -> u8 {
+    macro_rules! div_floor {
+        ($a:expr, $b:expr) => {{
+            let (_quotient, _remainder) = ($a / $b, $a % $b);
+            if (_remainder > 0 && $b < 0) || (_remainder < 0 && $b > 0) {
+                _quotient - 1
+            } else {
+                _quotient
+            }
+        }};
+    }
+
+    let adj_year = year - 1;
+    (ordinal + adj_year + div_floor!(adj_year, 4) - div_floor!(adj_year, 100)
+        + div_floor!(adj_year, 400)
+        + 6)
+    .rem_euclid(7)
+    .cast_unsigned()
+    .truncate()
+}
+
+pub(crate) fn days_in_year_month(year: i32, month: u8) -> u8 {
+    [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month.extend::<usize>() - 1]
+        + u8::from(month == 2 && is_leap_year(year))
+}
+
+pub(crate) fn ywd_to_yo(year: i32, week: u8, iso_weekday_number: u8) -> (i32, u16) {
+    let (ordinal, overflow) = (u16::from(week) * 7 + u16::from(iso_weekday_number))
+        .overflowing_sub(u16::from(jan_weekday(year, 4)) + 4);
+
+    if overflow || ordinal == 0 {
+        return (year - 1, (ordinal.wrapping_add(days_in_year(year - 1))));
+    }
+
+    let days_in_cur_year = days_in_year(year);
+    if ordinal > days_in_cur_year {
+        (year + 1, ordinal - days_in_cur_year)
+    } else {
+        (year, ordinal)
+    }
+}
+
+pub(crate) fn ymd_to_yo(year: i32, month: u8, day: u8) -> (i32, u16) {
+    let ordinal = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
+        [month.extend::<usize>() - 1]
+        + u16::from(month > 2 && is_leap_year(year));
+
+    (year, ordinal + u16::from(day))
+}
diff --git a/time-macros/src/helpers/string.rs b/time-macros/src/helpers/string.rs
new file mode 100644
index 000000000..6b478f60d
--- /dev/null
+++ b/time-macros/src/helpers/string.rs
@@ -0,0 +1,188 @@
+use std::ops::{Index, RangeFrom};
+
+use proc_macro::Span;
+
+use crate::Error;
+
+pub(crate) fn parse(token: &proc_macro::Literal) -> Result<(Span, Vec<u8>), Error> {
+    let span = token.span();
+    let repr = token.to_string();
+
+    match repr.as_bytes() {
+        [b'"', ..] => Ok((span, parse_lit_str_cooked(&repr[1..]))),
+        [b'b', b'"', rest @ ..] => Ok((span, parse_lit_byte_str_cooked(rest))),
+        [b'r', rest @ ..] | [b'b', b'r', rest @ ..] => Ok((span, parse_lit_str_raw(rest))),
+        _ => Err(Error::ExpectedString {
+            span_start: Some(span),
+            span_end: Some(span),
+        }),
+    }
+}
+
+fn byte(s: impl AsRef<[u8]>, idx: usize) -> u8 {
+    s.as_ref().get(idx).copied().unwrap_or_default()
+}
+
+fn parse_lit_str_cooked(mut s: &str) -> Vec<u8> {
+    let mut content = String::new();
+    'outer: loop {
+        let ch = match byte(s, 0) {
+            b'"' => break,
+            b'\\' => {
+                let b = byte(s, 1);
+                s = &s[2..];
+                match b {
+                    b'x' => {
+                        let (byte, rest) = backslash_x(s);
+                        s = rest;
+                        char::from_u32(u32::from(byte)).expect("byte was just validated")
+                    }
+                    b'u' => {
+                        let (chr, rest) = backslash_u(s);
+                        s = rest;
+                        chr
+                    }
+                    b'n' => '\n',
+                    b'r' => '\r',
+                    b't' => '\t',
+                    b'\\' => '\\',
+                    b'0' => '\0',
+                    b'\'' => '\'',
+                    b'"' => '"',
+                    b'\r' | b'\n' => loop {
+                        let ch = s.chars().next().unwrap_or_default();
+                        if ch.is_whitespace() {
+                            s = &s[ch.len_utf8()..];
+                        } else {
+                            continue 'outer;
+                        }
+                    },
+                    _ => bug!("invalid escape"),
+                }
+            }
+            b'\r' => {
+                // bare CR not permitted
+                s = &s[2..];
+                '\n'
+            }
+            _ => {
+                let ch = s.chars().next().unwrap_or_default();
+                s = &s[ch.len_utf8()..];
+                ch
+            }
+        };
+        content.push(ch);
+    }
+
+    content.into_bytes()
+}
+
+fn parse_lit_str_raw(s: &[u8]) -> Vec<u8> {
+    let mut pounds = 0;
+    while byte(s, pounds) == b'#' {
+        pounds += 1;
+    }
+    let close = s
+        .iter()
+        .rposition(|&b| b == b'"')
+        .expect("had a string without trailing \"");
+
+    s[pounds + 1..close].to_owned()
+}
+
+fn parse_lit_byte_str_cooked(mut v: &[u8]) -> Vec<u8> {
+    let mut out = Vec::new();
+    'outer: loop {
+        let byte = match byte(v, 0) {
+            b'"' => break,
+            b'\\' => {
+                let b = byte(v, 1);
+                v = &v[2..];
+                match b {
+                    b'x' => {
+                        let (byte, rest) = backslash_x(v);
+                        v = rest;
+                        byte
+                    }
+                    b'n' => b'\n',
+                    b'r' => b'\r',
+                    b't' => b'\t',
+                    b'\\' => b'\\',
+                    b'0' => b'\0',
+                    b'\'' => b'\'',
+                    b'"' => b'"',
+                    b'\r' | b'\n' => loop {
+                        let byte = byte(v, 0);
+                        let ch = char::from_u32(u32::from(byte)).expect("invalid byte");
+                        if ch.is_whitespace() {
+                            v = &v[1..];
+                        } else {
+                            continue 'outer;
+                        }
+                    },
+                    _ => bug!("invalid escape"),
+                }
+            }
+            b'\r' => {
+                // bare CR not permitted
+                v = &v[2..];
+                b'\n'
+            }
+            b => {
+                v = &v[1..];
+                b
+            }
+        };
+        out.push(byte);
+    }
+
+    out
+}
+
+fn backslash_x<S>(s: &S) -> (u8, &S)
+where
+    S: Index<RangeFrom<usize>, Output = S> + AsRef<[u8]> + ?Sized,
+{
+    let mut ch = 0;
+    let b0 = byte(s, 0);
+    let b1 = byte(s, 1);
+    ch += 0x10 * (b0 - b'0');
+    ch += match b1 {
+        b'0'..=b'9' => b1 - b'0',
+        b'a'..=b'f' => 10 + (b1 - b'a'),
+        b'A'..=b'F' => 10 + (b1 - b'A'),
+        _ => bug!("invalid hex escape"),
+    };
+    (ch, &s[2..])
+}
+
+fn backslash_u(mut s: &str) -> (char, &str) {
+    s = &s[1..];
+
+    let mut ch = 0;
+    let mut digits = 0;
+    loop {
+        let b = byte(s, 0);
+        let digit = match b {
+            b'0'..=b'9' => b - b'0',
+            b'a'..=b'f' => 10 + b - b'a',
+            b'A'..=b'F' => 10 + b - b'A',
+            b'_' if digits > 0 => {
+                s = &s[1..];
+                continue;
+            }
+            b'}' if digits != 0 => break,
+            _ => bug!("invalid unicode escape"),
+        };
+        ch *= 0x10;
+        ch += u32::from(digit);
+        digits += 1;
+        s = &s[1..];
+    }
+    s = &s[1..];
+
+    (
+        char::from_u32(ch).expect("invalid unicode escape passed by compiler"),
+        s,
+    )
+}
diff --git a/time-macros/src/lib.rs b/time-macros/src/lib.rs
new file mode 100644
index 000000000..65e24d7d3
--- /dev/null
+++ b/time-macros/src/lib.rs
@@ -0,0 +1,254 @@
+#![allow(
+    clippy::missing_const_for_fn, // irrelevant for proc macros
+    clippy::missing_docs_in_private_items, // TODO remove
+    clippy::std_instead_of_core, // irrelevant for proc macros
+    clippy::std_instead_of_alloc, // irrelevant for proc macros
+    clippy::alloc_instead_of_core, // irrelevant for proc macros
+    missing_docs, // TODO remove
+)]
+
+#[allow(unused_macros)]
+macro_rules! bug {
+    () => { compile_error!("provide an error message to help fix a possible bug") };
+    ($descr:literal $($rest:tt)?) => {
+        unreachable!(concat!("internal error: ", $descr) $($rest)?)
+    }
+}
+
+#[macro_use]
+mod quote;
+
+mod date;
+mod datetime;
+mod error;
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+mod format_description;
+mod helpers;
+mod offset;
+#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
+mod serde_format_description;
+mod time;
+mod to_tokens;
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+use std::iter::Peekable;
+
+use proc_macro::TokenStream;
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+use proc_macro::{Ident, TokenTree};
+
+use self::error::Error;
+
+macro_rules! impl_macros {
+    ($($name:ident)*) => {$(
+        #[proc_macro]
+        pub fn $name(input: TokenStream) -> TokenStream {
+            use crate::to_tokens::ToTokenTree;
+
+            let mut iter = input.into_iter().peekable();
+            match $name::parse(&mut iter) {
+                Ok(value) => match iter.peek() {
+                    Some(tree) => Error::UnexpectedToken { tree: tree.clone() }.to_compile_error(),
+                    None => TokenStream::from(value.into_token_tree()),
+                },
+                Err(err) => err.to_compile_error(),
+            }
+        }
+    )*};
+}
+
+impl_macros![date datetime offset time];
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+enum FormatDescriptionVersion {
+    V1,
+    V2,
+}
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+enum VersionOrModuleName {
+    Version(FormatDescriptionVersion),
+    #[cfg_attr(not(feature = "serde"), allow(dead_code))]
+    ModuleName(Ident),
+}
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+fn parse_format_description_version<const NO_EQUALS_IS_MOD_NAME: bool>(
+    iter: &mut Peekable<proc_macro::token_stream::IntoIter>,
+) -> Result<Option<VersionOrModuleName>, Error> {
+    let version_ident = match iter.peek() {
+        Some(TokenTree::Ident(ident)) if ident.to_string() == "version" => match iter.next() {
+            Some(TokenTree::Ident(ident)) => ident,
+            _ => unreachable!(),
+        },
+        _ => return Ok(None),
+    };
+    match iter.peek() {
+        Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => iter.next(),
+        _ if NO_EQUALS_IS_MOD_NAME => {
+            return Ok(Some(VersionOrModuleName::ModuleName(version_ident)));
+        }
+        Some(token) => {
+            return Err(Error::Custom {
+                message: "expected `=`".into(),
+                span_start: Some(token.span()),
+                span_end: Some(token.span()),
+            });
+        }
+        None => {
+            return Err(Error::Custom {
+                message: "expected `=`".into(),
+                span_start: None,
+                span_end: None,
+            });
+        }
+    };
+    let version_literal = match iter.next() {
+        Some(TokenTree::Literal(literal)) => literal,
+        Some(token) => {
+            return Err(Error::Custom {
+                message: "expected 1 or 2".into(),
+                span_start: Some(token.span()),
+                span_end: Some(token.span()),
+            });
+        }
+        None => {
+            return Err(Error::Custom {
+                message: "expected 1 or 2".into(),
+                span_start: None,
+                span_end: None,
+            });
+        }
+    };
+    let version = match version_literal.to_string().as_str() {
+        "1" => FormatDescriptionVersion::V1,
+        "2" => FormatDescriptionVersion::V2,
+        _ => {
+            return Err(Error::Custom {
+                message: "invalid format description version".into(),
+                span_start: Some(version_literal.span()),
+                span_end: Some(version_literal.span()),
+            });
+        }
+    };
+    helpers::consume_punct(',', iter)?;
+
+    Ok(Some(VersionOrModuleName::Version(version)))
+}
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+#[proc_macro]
+pub fn format_description(input: TokenStream) -> TokenStream {
+    (|| {
+        let mut input = input.into_iter().peekable();
+        let version = match parse_format_description_version::<false>(&mut input)? {
+            Some(VersionOrModuleName::Version(version)) => Some(version),
+            None => None,
+            // This branch should never occur here, as `false` is the provided as a const parameter.
+            Some(VersionOrModuleName::ModuleName(_)) => bug!("branch should never occur"),
+        };
+        let (span, string) = helpers::get_string_literal(input)?;
+        let items = format_description::parse_with_version(version, &string, span)?;
+
+        Ok(quote! {{
+            const DESCRIPTION: &[::time::format_description::BorrowedFormatItem<'_>] = &[#S(
+                items
+                    .into_iter()
+                    .map(|item| quote! { #S(item), })
+                    .collect::<TokenStream>()
+            )];
+            DESCRIPTION
+        }})
+    })()
+    .unwrap_or_else(|err: Error| err.to_compile_error())
+}
+
+#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
+#[proc_macro]
+pub fn serde_format_description(input: TokenStream) -> TokenStream {
+    (|| {
+        let mut tokens = input.into_iter().peekable();
+
+        // First, the optional format description version.
+        let version = parse_format_description_version::<true>(&mut tokens)?;
+        let (version, mod_name) = match version {
+            Some(VersionOrModuleName::ModuleName(module_name)) => (None, Some(module_name)),
+            Some(VersionOrModuleName::Version(version)) => (Some(version), None),
+            None => (None, None),
+        };
+
+        // Next, an identifier (the desired module name)
+        // Only parse this if it wasn't parsed when attempting to get the version.
+        let mod_name = match mod_name {
+            Some(mod_name) => mod_name,
+            None => match tokens.next() {
+                Some(TokenTree::Ident(ident)) => Ok(ident),
+                Some(tree) => Err(Error::UnexpectedToken { tree }),
+                None => Err(Error::UnexpectedEndOfInput),
+            }?,
+        };
+
+        // Followed by a comma
+        helpers::consume_punct(',', &mut tokens)?;
+
+        // Then, the type to create serde serializers for (e.g., `OffsetDateTime`).
+        let formattable = match tokens.next() {
+            Some(tree @ TokenTree::Ident(_)) => Ok(tree),
+            Some(tree) => Err(Error::UnexpectedToken { tree }),
+            None => Err(Error::UnexpectedEndOfInput),
+        }?;
+
+        // Another comma
+        helpers::consume_punct(',', &mut tokens)?;
+
+        // We now have two options. The user can either provide a format description as a string or
+        // they can provide a path to a format description. If the latter, all remaining tokens are
+        // assumed to be part of the path.
+        let (format, format_description_display) = match tokens.peek() {
+            // string literal
+            Some(TokenTree::Literal(_)) => {
+                let (span, format_string) = helpers::get_string_literal(tokens)?;
+                let items = format_description::parse_with_version(version, &format_string, span)?;
+                let items: TokenStream =
+                    items.into_iter().map(|item| quote! { #S(item), }).collect();
+                let items = quote! {
+                    const ITEMS: &[::time::format_description::BorrowedFormatItem<'_>]
+                        = &[#S(items)];
+                    ITEMS
+                };
+
+                (items, String::from_utf8_lossy(&format_string).into_owned())
+            }
+            // path
+            Some(_) => {
+                let tokens = tokens.collect::<TokenStream>();
+                let tokens_string = tokens.to_string();
+                (
+                    quote! {{
+                        // We can't just do `super::path` because the path could be an absolute
+                        // path. In that case, we'd be generating `super::::path`, which is invalid.
+                        // Even if we took that into account, it's not possible to know if it's an
+                        // external crate, which would just require emitting `path` directly. By
+                        // taking this approach, we can leave it to the compiler to do the actual
+                        // resolution.
+                        mod __path_hack {
+                            pub(super) use super::super::*;
+                            pub(super) use #S(tokens) as FORMAT;
+                        }
+                        __path_hack::FORMAT
+                    }},
+                    tokens_string,
+                )
+            }
+            None => return Err(Error::UnexpectedEndOfInput),
+        };
+
+        Ok(serde_format_description::build(
+            mod_name,
+            formattable,
+            format,
+            format_description_display,
+        ))
+    })()
+    .unwrap_or_else(|err: Error| err.to_compile_error_standalone())
+}
diff --git a/time-macros/src/offset.rs b/time-macros/src/offset.rs
new file mode 100644
index 000000000..04dd37f13
--- /dev/null
+++ b/time-macros/src/offset.rs
@@ -0,0 +1,99 @@
+use std::iter::Peekable;
+
+use num_conv::prelude::*;
+use proc_macro::{token_stream, Span, TokenTree};
+use time_core::convert::*;
+
+use crate::helpers::{consume_any_ident, consume_number, consume_punct};
+use crate::to_tokens::ToTokenTree;
+use crate::Error;
+
+pub(crate) struct Offset {
+    pub(crate) hours: i8,
+    pub(crate) minutes: i8,
+    pub(crate) seconds: i8,
+}
+
+pub(crate) fn parse(chars: &mut Peekable<token_stream::IntoIter>) -> Result<Offset, Error> {
+    if consume_any_ident(&["utc", "UTC"], chars).is_ok() {
+        return Ok(Offset {
+            hours: 0,
+            minutes: 0,
+            seconds: 0,
+        });
+    }
+
+    let sign = if consume_punct('+', chars).is_ok() {
+        1
+    } else if consume_punct('-', chars).is_ok() {
+        -1
+    } else if let Some(tree) = chars.next() {
+        return Err(Error::UnexpectedToken { tree });
+    } else {
+        return Err(Error::MissingComponent {
+            name: "sign",
+            span_start: None,
+            span_end: None,
+        });
+    };
+
+    let (hours_span, hours) = consume_number::<i8>("hour", chars)?;
+    let (mut minutes_span, mut minutes) = (Span::mixed_site(), 0);
+    let (mut seconds_span, mut seconds) = (Span::mixed_site(), 0);
+
+    if consume_punct(':', chars).is_ok() {
+        let min = consume_number::<i8>("minute", chars)?;
+        minutes_span = min.0;
+        minutes = min.1;
+
+        if consume_punct(':', chars).is_ok() {
+            let sec = consume_number::<i8>("second", chars)?;
+            seconds_span = sec.0;
+            seconds = sec.1;
+        }
+    }
+
+    if hours > 25 {
+        Err(Error::InvalidComponent {
+            name: "hour",
+            value: hours.to_string(),
+            span_start: Some(hours_span),
+            span_end: Some(hours_span),
+        })
+    } else if minutes >= Minute::per(Hour).cast_signed() {
+        Err(Error::InvalidComponent {
+            name: "minute",
+            value: minutes.to_string(),
+            span_start: Some(minutes_span),
+            span_end: Some(minutes_span),
+        })
+    } else if seconds >= Second::per(Minute).cast_signed() {
+        Err(Error::InvalidComponent {
+            name: "second",
+            value: seconds.to_string(),
+            span_start: Some(seconds_span),
+            span_end: Some(seconds_span),
+        })
+    } else {
+        Ok(Offset {
+            hours: sign * hours,
+            minutes: sign * minutes,
+            seconds: sign * seconds,
+        })
+    }
+}
+
+impl ToTokenTree for Offset {
+    fn into_token_tree(self) -> TokenTree {
+        quote_group! {{
+            const OFFSET: ::time::UtcOffset = unsafe {
+                ::time::UtcOffset::__from_hms_unchecked(
+                    #(self.hours),
+                    #(self.minutes),
+                    #(self.seconds),
+                )
+            };
+            OFFSET
+        }}
+    }
+}
diff --git a/time-macros/src/quote.rs b/time-macros/src/quote.rs
new file mode 100644
index 000000000..8603f4fa4
--- /dev/null
+++ b/time-macros/src/quote.rs
@@ -0,0 +1,138 @@
+macro_rules! quote {
+    () => (::proc_macro::TokenStream::new());
+    ($($x:tt)*) => {{
+        let mut ts = ::proc_macro::TokenStream::new();
+        let ts_mut = &mut ts;
+        quote_inner!(ts_mut $($x)*);
+        ts
+    }};
+}
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+macro_rules! quote_append {
+    ($ts:ident $($x:tt)*) => {{
+        quote_inner!($ts $($x)*);
+    }};
+}
+
+macro_rules! quote_group {
+    ({ $($x:tt)* }) => {
+        ::proc_macro::TokenTree::Group(::proc_macro::Group::new(
+            ::proc_macro::Delimiter::Brace,
+            quote!($($x)*)
+        ))
+    };
+}
+
+macro_rules! sym {
+    ($ts:ident $x:tt $y:tt) => {
+        $ts.extend([
+            ::proc_macro::TokenTree::from(::proc_macro::Punct::new(
+                $x,
+                ::proc_macro::Spacing::Joint,
+            )),
+            ::proc_macro::TokenTree::from(::proc_macro::Punct::new(
+                $y,
+                ::proc_macro::Spacing::Alone,
+            )),
+        ]);
+    };
+    ($ts:ident $x:tt) => {
+        $ts.extend([::proc_macro::TokenTree::from(::proc_macro::Punct::new(
+            $x,
+            ::proc_macro::Spacing::Alone,
+        ))]);
+    };
+}
+
+#[allow(unused_macro_rules)] // Varies by feature flag combination.
+macro_rules! quote_inner {
+    // Base case
+    ($ts:ident) => {};
+
+    // Single or double symbols
+    ($ts:ident :: $($tail:tt)*) => { sym!($ts ':' ':'); quote_inner!($ts $($tail)*); };
+    ($ts:ident : $($tail:tt)*) => { sym!($ts ':'); quote_inner!($ts $($tail)*); };
+    ($ts:ident = $($tail:tt)*) => { sym!($ts '='); quote_inner!($ts $($tail)*); };
+    ($ts:ident ; $($tail:tt)*) => { sym!($ts ';'); quote_inner!($ts $($tail)*); };
+    ($ts:ident , $($tail:tt)*) => { sym!($ts ','); quote_inner!($ts $($tail)*); };
+    ($ts:ident . $($tail:tt)*) => { sym!($ts '.'); quote_inner!($ts $($tail)*); };
+    ($ts:ident & $($tail:tt)*) => { sym!($ts '&'); quote_inner!($ts $($tail)*); };
+    ($ts:ident < $($tail:tt)*) => { sym!($ts '<'); quote_inner!($ts $($tail)*); };
+    ($ts:ident >> $($tail:tt)*) => { sym!($ts '>' '>'); quote_inner!($ts $($tail)*); };
+    ($ts:ident > $($tail:tt)*) => { sym!($ts '>'); quote_inner!($ts $($tail)*); };
+    ($ts:ident -> $($tail:tt)*) => { sym!($ts '-' '>'); quote_inner!($ts $($tail)*); };
+    ($ts:ident ? $($tail:tt)*) => { sym!($ts '?'); quote_inner!($ts $($tail)*); };
+    ($ts:ident ! $($tail:tt)*) => { sym!($ts '!'); quote_inner!($ts $($tail)*); };
+    ($ts:ident | $($tail:tt)*) => { sym!($ts '|'); quote_inner!($ts $($tail)*); };
+    ($ts:ident * $($tail:tt)*) => { sym!($ts '*'); quote_inner!($ts $($tail)*); };
+    ($ts:ident + $($tail:tt)*) => { sym!($ts '+'); quote_inner!($ts $($tail)*); };
+
+    // Identifier
+    ($ts:ident $i:ident $($tail:tt)*) => {
+        $ts.extend([::proc_macro::TokenTree::from(::proc_macro::Ident::new(
+            &stringify!($i),
+            ::proc_macro::Span::mixed_site(),
+        ))]);
+        quote_inner!($ts $($tail)*);
+    };
+
+    // Literal
+    ($ts:ident 0 $($tail:tt)*) => {
+        $ts.extend([::proc_macro::TokenTree::from(::proc_macro::Literal::usize_unsuffixed(0))]);
+        quote_inner!($ts $($tail)*);
+    };
+    ($ts:ident $l:literal $($tail:tt)*) => {
+        $ts.extend([::proc_macro::TokenTree::from(::proc_macro::Literal::string(&$l))]);
+        quote_inner!($ts $($tail)*);
+    };
+
+    // Lifetime
+    ($ts:ident $l:lifetime $($tail:tt)*) => {
+        $ts.extend([
+            ::proc_macro::TokenTree::from(
+                ::proc_macro::Punct::new('\'', ::proc_macro::Spacing::Joint)
+            ),
+            ::proc_macro::TokenTree::from(::proc_macro::Ident::new(
+                stringify!($l).trim_start_matches(|c| c == '\''),
+                ::proc_macro::Span::mixed_site(),
+            )),
+        ]);
+        quote_inner!($ts $($tail)*);
+    };
+
+    // Groups
+    ($ts:ident ($($inner:tt)*) $($tail:tt)*) => {
+        $ts.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new(
+            ::proc_macro::Delimiter::Parenthesis,
+            quote!($($inner)*)
+        ))]);
+        quote_inner!($ts $($tail)*);
+    };
+    ($ts:ident [$($inner:tt)*] $($tail:tt)*) => {
+        $ts.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new(
+            ::proc_macro::Delimiter::Bracket,
+            quote!($($inner)*)
+        ))]);
+        quote_inner!($ts $($tail)*);
+    };
+    ($ts:ident {$($inner:tt)*} $($tail:tt)*) => {
+        $ts.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new(
+            ::proc_macro::Delimiter::Brace,
+            quote!($($inner)*)
+        ))]);
+        quote_inner!($ts $($tail)*);
+    };
+
+    // Interpolated values
+    // TokenTree by default
+    ($ts:ident #($e:expr) $($tail:tt)*) => {
+        $ts.extend([$crate::to_tokens::ToTokenTree::into_token_tree($e)]);
+        quote_inner!($ts $($tail)*);
+    };
+    // Allow a TokenStream by request. It's more expensive, so avoid if possible.
+    ($ts:ident #S($e:expr) $($tail:tt)*) => {
+        $crate::to_tokens::ToTokenStream::append_to($e, $ts);
+        quote_inner!($ts $($tail)*);
+    };
+}
diff --git a/time-macros/src/serde_format_description.rs b/time-macros/src/serde_format_description.rs
new file mode 100644
index 000000000..34b99f679
--- /dev/null
+++ b/time-macros/src/serde_format_description.rs
@@ -0,0 +1,172 @@
+use proc_macro::{Ident, TokenStream, TokenTree};
+
+pub(crate) fn build(
+    mod_name: Ident,
+    ty: TokenTree,
+    format: TokenStream,
+    format_description_display: String,
+) -> TokenStream {
+    let ty_s = &*ty.to_string();
+
+    let visitor = if cfg!(feature = "parsing") {
+        quote! {
+            struct Visitor;
+            struct OptionVisitor;
+
+            impl<'a> ::serde::de::Visitor<'a> for Visitor {
+                type Value = __TimeSerdeType;
+
+                fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                    write!(
+                        f,
+                        concat!(
+                            "a(n) `",
+                            #(ty_s),
+                            "` in the format \"{}\"",
+                        ),
+                        #(format_description_display.as_str())
+                    )
+                }
+
+                fn visit_str<E: ::serde::de::Error>(
+                    self,
+                    value: &str
+                ) -> Result<__TimeSerdeType, E> {
+                    __TimeSerdeType::parse(value, &description()).map_err(E::custom)
+                }
+            }
+
+            impl<'a> ::serde::de::Visitor<'a> for OptionVisitor {
+                type Value = Option<__TimeSerdeType>;
+
+                fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                    write!(
+                        f,
+                        concat!(
+                            "an `Option<",
+                            #(ty_s),
+                            ">` in the format \"{}\"",
+                        ),
+                        #(format_description_display.as_str())
+                    )
+                }
+
+                fn visit_some<D: ::serde::de::Deserializer<'a>>(
+                    self,
+                    deserializer: D
+                ) -> Result<Option<__TimeSerdeType>, D::Error> {
+                    deserializer
+                        .deserialize_str(Visitor)
+                        .map(Some)
+                }
+
+                fn visit_none<E: ::serde::de::Error>(
+                    self
+                ) -> Result<Option<__TimeSerdeType>, E> {
+                    Ok(None)
+                }
+            }
+        }
+    } else {
+        quote!()
+    };
+
+    let serialize_primary = if cfg!(feature = "formatting") {
+        quote! {
+            pub fn serialize<S: ::serde::Serializer>(
+                datetime: &__TimeSerdeType,
+                serializer: S,
+            ) -> Result<S::Ok, S::Error> {
+                use ::serde::Serialize;
+                datetime
+                    .format(&description())
+                    .map_err(::time::error::Format::into_invalid_serde_value::<S>)?
+                    .serialize(serializer)
+            }
+        }
+    } else {
+        quote!()
+    };
+
+    let deserialize_primary = if cfg!(feature = "parsing") {
+        quote! {
+            pub fn deserialize<'a, D: ::serde::Deserializer<'a>>(
+                deserializer: D
+            ) -> Result<__TimeSerdeType, D::Error> {
+                use ::serde::Deserialize;
+                deserializer.deserialize_str(Visitor)
+            }
+        }
+    } else {
+        quote!()
+    };
+
+    let serialize_option = if cfg!(feature = "formatting") {
+        quote! {
+            pub fn serialize<S: ::serde::Serializer>(
+                option: &Option<__TimeSerdeType>,
+                serializer: S,
+            ) -> Result<S::Ok, S::Error> {
+                use ::serde::Serialize;
+                option.map(|datetime| datetime.format(&description()))
+                    .transpose()
+                    .map_err(::time::error::Format::into_invalid_serde_value::<S>)?
+                    .serialize(serializer)
+            }
+        }
+    } else {
+        quote!()
+    };
+
+    let deserialize_option = if cfg!(feature = "parsing") {
+        quote! {
+            pub fn deserialize<'a, D: ::serde::Deserializer<'a>>(
+                deserializer: D
+            ) -> Result<Option<__TimeSerdeType>, D::Error> {
+                use ::serde::Deserialize;
+                deserializer.deserialize_option(OptionVisitor)
+            }
+        }
+    } else {
+        quote!()
+    };
+
+    let deserialize_option_imports = if cfg!(feature = "parsing") {
+        quote! {
+            use super::{OptionVisitor, Visitor};
+        }
+    } else {
+        quote!()
+    };
+
+    let fd_traits = match (cfg!(feature = "formatting"), cfg!(feature = "parsing")) {
+        (false, false) => {
+            bug!("serde_format_description::build called without formatting or parsing enabled")
+        }
+        (false, true) => quote! { ::time::parsing::Parsable },
+        (true, false) => quote! { ::time::formatting::Formattable },
+        (true, true) => quote! { ::time::formatting::Formattable + ::time::parsing::Parsable },
+    };
+
+    quote! {
+        mod #(mod_name) {
+            use ::time::#(ty) as __TimeSerdeType;
+
+            const fn description() -> impl #S(fd_traits) {
+                #S(format)
+            }
+
+            #S(visitor)
+            #S(serialize_primary)
+            #S(deserialize_primary)
+
+            pub(super) mod option {
+                use super::{description, __TimeSerdeType};
+                #S(deserialize_option_imports)
+
+                #S(serialize_option)
+                #S(deserialize_option)
+            }
+        }
+    }
+}
diff --git a/time-macros/src/time.rs b/time-macros/src/time.rs
new file mode 100644
index 000000000..4e565c1de
--- /dev/null
+++ b/time-macros/src/time.rs
@@ -0,0 +1,121 @@
+use std::iter::Peekable;
+
+use proc_macro::{token_stream, Span, TokenTree};
+use time_core::convert::*;
+
+use crate::helpers::{consume_any_ident, consume_number, consume_punct};
+use crate::to_tokens::ToTokenTree;
+use crate::Error;
+
+enum Period {
+    Am,
+    Pm,
+    _24,
+}
+
+pub(crate) struct Time {
+    pub(crate) hour: u8,
+    pub(crate) minute: u8,
+    pub(crate) second: u8,
+    pub(crate) nanosecond: u32,
+}
+
+pub(crate) fn parse(chars: &mut Peekable<token_stream::IntoIter>) -> Result<Time, Error> {
+    fn consume_period(chars: &mut Peekable<token_stream::IntoIter>) -> (Option<Span>, Period) {
+        if let Ok(span) = consume_any_ident(&["am", "AM"], chars) {
+            (Some(span), Period::Am)
+        } else if let Ok(span) = consume_any_ident(&["pm", "PM"], chars) {
+            (Some(span), Period::Pm)
+        } else {
+            (None, Period::_24)
+        }
+    }
+
+    let (hour_span, hour) = consume_number("hour", chars)?;
+
+    let ((minute_span, minute), (second_span, second), (period_span, period)) =
+        match consume_period(chars) {
+            // Nothing but the 12-hour clock hour and AM/PM
+            (period_span @ Some(_), period) => (
+                (Span::mixed_site(), 0),
+                (Span::mixed_site(), 0.),
+                (period_span, period),
+            ),
+            (None, _) => {
+                consume_punct(':', chars)?;
+                let (minute_span, minute) = consume_number::<u8>("minute", chars)?;
+                let (second_span, second): (_, f64) = if consume_punct(':', chars).is_ok() {
+                    consume_number("second", chars)?
+                } else {
+                    (Span::mixed_site(), 0.)
+                };
+                let (period_span, period) = consume_period(chars);
+                (
+                    (minute_span, minute),
+                    (second_span, second),
+                    (period_span, period),
+                )
+            }
+        };
+
+    let hour = match (hour, period) {
+        (0, Period::Am | Period::Pm) => {
+            return Err(Error::InvalidComponent {
+                name: "hour",
+                value: hour.to_string(),
+                span_start: Some(hour_span),
+                span_end: Some(period_span.unwrap_or(hour_span)),
+            });
+        }
+        (12, Period::Am) => 0,
+        (12, Period::Pm) => 12,
+        (hour, Period::Am | Period::_24) => hour,
+        (hour, Period::Pm) => hour + 12,
+    };
+
+    if hour >= Hour::per(Day) {
+        Err(Error::InvalidComponent {
+            name: "hour",
+            value: hour.to_string(),
+            span_start: Some(hour_span),
+            span_end: Some(period_span.unwrap_or(hour_span)),
+        })
+    } else if minute >= Minute::per(Hour) {
+        Err(Error::InvalidComponent {
+            name: "minute",
+            value: minute.to_string(),
+            span_start: Some(minute_span),
+            span_end: Some(minute_span),
+        })
+    } else if second >= Second::per(Minute) as _ {
+        Err(Error::InvalidComponent {
+            name: "second",
+            value: second.to_string(),
+            span_start: Some(second_span),
+            span_end: Some(second_span),
+        })
+    } else {
+        Ok(Time {
+            hour,
+            minute,
+            second: second.trunc() as _,
+            nanosecond: (second.fract() * Nanosecond::per(Second) as f64).round() as _,
+        })
+    }
+}
+
+impl ToTokenTree for Time {
+    fn into_token_tree(self) -> TokenTree {
+        quote_group! {{
+            const TIME: ::time::Time = unsafe {
+                ::time::Time::__from_hms_nanos_unchecked(
+                    #(self.hour),
+                    #(self.minute),
+                    #(self.second),
+                    #(self.nanosecond),
+                )
+            };
+            TIME
+        }}
+    }
+}
diff --git a/time-macros/src/to_tokens.rs b/time-macros/src/to_tokens.rs
new file mode 100644
index 000000000..7802158ce
--- /dev/null
+++ b/time-macros/src/to_tokens.rs
@@ -0,0 +1,79 @@
+use std::num::NonZeroU16;
+
+use proc_macro::{Group, Ident, Literal, Punct, Span, TokenStream, TokenTree};
+
+/// Turn a type into a [`TokenStream`].
+pub(crate) trait ToTokenStream: Sized {
+    fn append_to(self, ts: &mut TokenStream);
+}
+
+pub(crate) trait ToTokenTree: Sized {
+    fn into_token_tree(self) -> TokenTree;
+}
+
+impl<T: ToTokenTree> ToTokenStream for T {
+    fn append_to(self, ts: &mut TokenStream) {
+        ts.extend([self.into_token_tree()])
+    }
+}
+
+impl ToTokenTree for bool {
+    fn into_token_tree(self) -> TokenTree {
+        let lit = if self { "true" } else { "false" };
+        TokenTree::Ident(Ident::new(lit, Span::mixed_site()))
+    }
+}
+
+impl ToTokenStream for TokenStream {
+    fn append_to(self, ts: &mut TokenStream) {
+        ts.extend(self)
+    }
+}
+
+impl ToTokenTree for TokenTree {
+    fn into_token_tree(self) -> TokenTree {
+        self
+    }
+}
+
+impl ToTokenTree for &str {
+    fn into_token_tree(self) -> TokenTree {
+        TokenTree::Literal(Literal::string(self))
+    }
+}
+
+impl ToTokenTree for NonZeroU16 {
+    fn into_token_tree(self) -> TokenTree {
+        quote_group! {{
+            unsafe { ::core::num::NonZeroU16::new_unchecked(#(self.get())) }
+        }}
+    }
+}
+
+macro_rules! impl_for_tree_types {
+    ($($type:ty)*) => {$(
+        impl ToTokenTree for $type {
+            fn into_token_tree(self) -> TokenTree {
+                TokenTree::from(self)
+            }
+        }
+    )*};
+}
+impl_for_tree_types![Ident Literal Group Punct];
+
+macro_rules! impl_for_int {
+    ($($type:ty => $method:ident)*) => {$(
+        impl ToTokenTree for $type {
+            fn into_token_tree(self) -> TokenTree {
+                TokenTree::from(Literal::$method(self))
+            }
+        }
+    )*};
+}
+impl_for_int! {
+    i8 => i8_unsuffixed
+    u8 => u8_unsuffixed
+    u16 => u16_unsuffixed
+    i32 => i32_unsuffixed
+    u32 => u32_unsuffixed
+}
diff --git a/time/Cargo.toml b/time/Cargo.toml
new file mode 100644
index 000000000..00f46f457
--- /dev/null
+++ b/time/Cargo.toml
@@ -0,0 +1,94 @@
+[package]
+name = "time"
+version = "0.3.36"
+authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
+edition = "2021"
+rust-version = "1.67.0"
+repository = "https://github.com/time-rs/time"
+homepage = "https://time-rs.github.io"
+keywords = ["date", "time", "calendar", "duration"]
+categories = [
+    "date-and-time",
+    "no-std",
+    "parser-implementations",
+    "value-formatting",
+]
+readme = "../README.md"
+license = "MIT OR Apache-2.0"
+description = "Date and time library. Fully interoperable with the standard library. Mostly compatible with #![no_std]."
+include = ["src/**/*", "LICENSE-*", "README.md"]
+
+[lib]
+bench = false
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+targets = ["x86_64-unknown-linux-gnu"]
+rustdoc-args = ["--generate-link-to-definition"]
+
+[features]
+default = ["std"]
+alloc = ["serde?/alloc"]
+formatting = ["dep:itoa", "std", "time-macros?/formatting"]
+large-dates = ["time-macros?/large-dates"]
+local-offset = ["std", "dep:libc", "dep:num_threads"]
+macros = ["dep:time-macros"]
+parsing = ["time-macros?/parsing"]
+quickcheck = ["dep:quickcheck", "alloc", "deranged/quickcheck"]
+rand = ["dep:rand", "deranged/rand"]
+serde = ["dep:serde", "time-macros?/serde", "deranged/serde"]
+serde-human-readable = ["serde", "formatting", "parsing"]
+# Deprecated in favor of using the relevant flags directly.
+serde-well-known = ["serde", "formatting", "parsing"]
+std = ["alloc", "deranged/std"]
+wasm-bindgen = ["dep:js-sys"]
+
+# If adding an optional dependency, be sure to use the `dep:` prefix above to avoid an implicit
+# feature gate.
+[dependencies]
+deranged = { workspace = true }
+itoa = { workspace = true, optional = true }
+num-conv = { workspace = true }
+powerfmt = { workspace = true }
+quickcheck = { workspace = true, optional = true }
+rand = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+time-core = { workspace = true }
+time-macros = { workspace = true, optional = true }
+
+[target.'cfg(target_family = "unix")'.dependencies]
+libc = { workspace = true, optional = true }
+num_threads = { workspace = true, optional = true }
+
+[target.'cfg(all(target_family = "wasm", not(any(target_os = "emscripten", target_os = "wasi"))))'.dependencies]
+js-sys = { workspace = true, optional = true }
+
+[dev-dependencies]
+num-conv = { workspace = true }
+rand = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+serde_test = { workspace = true }
+quickcheck_macros = { workspace = true }
+time-macros = { workspace = true }
+rstest = { workspace = true }
+rstest_reuse = { workspace = true }
+
+[target.'cfg(__ui_tests)'.dev-dependencies]
+trybuild = { workspace = true }
+
+[target.'cfg(bench)'.dev-dependencies]
+criterion = { workspace = true }
+
+# Significant contributions to the benchmarks provided by Emil Lundberg.
+[[bench]]
+name = "benchmarks"
+harness = false
+path = "../benchmarks/main.rs"
+
+[[test]]
+name = "tests"
+path = "../tests/main.rs"
diff --git a/time/LICENSE-Apache b/time/LICENSE-Apache
new file mode 120000
index 000000000..0cd69a3e2
--- /dev/null
+++ b/time/LICENSE-Apache
@@ -0,0 +1 @@
+../LICENSE-Apache
\ No newline at end of file
diff --git a/time/LICENSE-MIT b/time/LICENSE-MIT
new file mode 120000
index 000000000..76219eb72
--- /dev/null
+++ b/time/LICENSE-MIT
@@ -0,0 +1 @@
+../LICENSE-MIT
\ No newline at end of file
diff --git a/time/src/date.rs b/time/src/date.rs
new file mode 100644
index 000000000..ed443c5fd
--- /dev/null
+++ b/time/src/date.rs
@@ -0,0 +1,1493 @@
+//! The [`Date`] struct and its associated `impl`s.
+
+#[cfg(feature = "formatting")]
+use alloc::string::String;
+use core::num::NonZeroI32;
+use core::ops::{Add, Sub};
+use core::time::Duration as StdDuration;
+use core::{cmp, fmt};
+#[cfg(feature = "formatting")]
+use std::io;
+
+use deranged::RangedI32;
+use num_conv::prelude::*;
+use powerfmt::ext::FormatterExt;
+use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
+
+use crate::convert::*;
+use crate::ext::DigitCount;
+#[cfg(feature = "formatting")]
+use crate::formatting::Formattable;
+use crate::internal_macros::{
+    cascade, const_try, const_try_opt, div_floor, ensure_ranged, expect_opt, impl_add_assign,
+    impl_sub_assign,
+};
+#[cfg(feature = "parsing")]
+use crate::parsing::Parsable;
+use crate::util::{days_in_year, days_in_year_month, is_leap_year, weeks_in_year};
+use crate::{error, Duration, Month, PrimitiveDateTime, Time, Weekday};
+
+type Year = RangedI32<MIN_YEAR, MAX_YEAR>;
+
+/// The minimum valid year.
+pub(crate) const MIN_YEAR: i32 = if cfg!(feature = "large-dates") {
+    -999_999
+} else {
+    -9999
+};
+/// The maximum valid year.
+pub(crate) const MAX_YEAR: i32 = if cfg!(feature = "large-dates") {
+    999_999
+} else {
+    9999
+};
+
+/// Date in the proleptic Gregorian calendar.
+///
+/// By default, years between ±9999 inclusive are representable. This can be expanded to ±999,999
+/// inclusive by enabling the `large-dates` crate feature. Doing so has performance implications
+/// and introduces some ambiguities when parsing.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Date {
+    /// Bitpacked field containing both the year and ordinal.
+    // |     xx     | xxxxxxxxxxxxxxxxxxxxx | xxxxxxxxx |
+    // |   2 bits   |        21 bits        |  9 bits   |
+    // | unassigned |         year          |  ordinal  |
+    // The year is 15 bits when `large-dates` is not enabled.
+    value: NonZeroI32,
+}
+
+impl Date {
+    /// The minimum valid `Date`.
+    ///
+    /// The value of this may vary depending on the feature flags enabled.
+    // Safety: `ordinal` is not zero.
+    #[allow(clippy::undocumented_unsafe_blocks)]
+    pub const MIN: Self = unsafe { Self::__from_ordinal_date_unchecked(MIN_YEAR, 1) };
+
+    /// The maximum valid `Date`.
+    ///
+    /// The value of this may vary depending on the feature flags enabled.
+    // Safety: `ordinal` is not zero.
+    #[allow(clippy::undocumented_unsafe_blocks)]
+    pub const MAX: Self =
+        unsafe { Self::__from_ordinal_date_unchecked(MAX_YEAR, days_in_year(MAX_YEAR)) };
+
+    // region: constructors
+    /// Construct a `Date` from the year and ordinal values, the validity of which must be
+    /// guaranteed by the caller.
+    ///
+    /// # Safety
+    ///
+    /// `ordinal` must not be zero. `year` should be in the range `MIN_YEAR..=MAX_YEAR`, but this
+    /// is not a safety invariant.
+    #[doc(hidden)]
+    pub const unsafe fn __from_ordinal_date_unchecked(year: i32, ordinal: u16) -> Self {
+        debug_assert!(year >= MIN_YEAR);
+        debug_assert!(year <= MAX_YEAR);
+        debug_assert!(ordinal != 0);
+        debug_assert!(ordinal <= days_in_year(year));
+
+        Self {
+            // Safety: The caller must guarantee that `ordinal` is not zero.
+            value: unsafe { NonZeroI32::new_unchecked((year << 9) | ordinal as i32) },
+        }
+    }
+
+    /// Attempt to create a `Date` from the year, month, and day.
+    ///
+    /// ```rust
+    /// # use time::{Date, Month};
+    /// assert!(Date::from_calendar_date(2019, Month::January, 1).is_ok());
+    /// assert!(Date::from_calendar_date(2019, Month::December, 31).is_ok());
+    /// ```
+    ///
+    /// ```rust
+    /// # use time::{Date, Month};
+    /// assert!(Date::from_calendar_date(2019, Month::February, 29).is_err()); // 2019 isn't a leap year.
+    /// ```
+    pub const fn from_calendar_date(
+        year: i32,
+        month: Month,
+        day: u8,
+    ) -> Result<Self, error::ComponentRange> {
+        /// Cumulative days through the beginning of a month in both common and leap years.
+        const DAYS_CUMULATIVE_COMMON_LEAP: [[u16; 12]; 2] = [
+            [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
+            [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335],
+        ];
+
+        ensure_ranged!(Year: year);
+        match day {
+            1..=28 => {}
+            29..=31 if day <= days_in_year_month(year, month) => {}
+            _ => {
+                return Err(error::ComponentRange {
+                    name: "day",
+                    minimum: 1,
+                    maximum: days_in_year_month(year, month) as _,
+                    value: day as _,
+                    conditional_range: true,
+                });
+            }
+        }
+
+        // Safety: `ordinal` is not zero.
+        Ok(unsafe {
+            Self::__from_ordinal_date_unchecked(
+                year,
+                DAYS_CUMULATIVE_COMMON_LEAP[is_leap_year(year) as usize][month as usize - 1]
+                    + day as u16,
+            )
+        })
+    }
+
+    /// Attempt to create a `Date` from the year and ordinal day number.
+    ///
+    /// ```rust
+    /// # use time::Date;
+    /// assert!(Date::from_ordinal_date(2019, 1).is_ok());
+    /// assert!(Date::from_ordinal_date(2019, 365).is_ok());
+    /// ```
+    ///
+    /// ```rust
+    /// # use time::Date;
+    /// assert!(Date::from_ordinal_date(2019, 366).is_err()); // 2019 isn't a leap year.
+    /// ```
+    pub const fn from_ordinal_date(year: i32, ordinal: u16) -> Result<Self, error::ComponentRange> {
+        ensure_ranged!(Year: year);
+        match ordinal {
+            1..=365 => {}
+            366 if is_leap_year(year) => {}
+            _ => {
+                return Err(error::ComponentRange {
+                    name: "ordinal",
+                    minimum: 1,
+                    maximum: days_in_year(year) as _,
+                    value: ordinal as _,
+                    conditional_range: true,
+                });
+            }
+        }
+
+        // Safety: `ordinal` is not zero.
+        Ok(unsafe { Self::__from_ordinal_date_unchecked(year, ordinal) })
+    }
+
+    /// Attempt to create a `Date` from the ISO year, week, and weekday.
+    ///
+    /// ```rust
+    /// # use time::{Date, Weekday::*};
+    /// assert!(Date::from_iso_week_date(2019, 1, Monday).is_ok());
+    /// assert!(Date::from_iso_week_date(2019, 1, Tuesday).is_ok());
+    /// assert!(Date::from_iso_week_date(2020, 53, Friday).is_ok());
+    /// ```
+    ///
+    /// ```rust
+    /// # use time::{Date, Weekday::*};
+    /// assert!(Date::from_iso_week_date(2019, 53, Monday).is_err()); // 2019 doesn't have 53 weeks.
+    /// ```
+    pub const fn from_iso_week_date(
+        year: i32,
+        week: u8,
+        weekday: Weekday,
+    ) -> Result<Self, error::ComponentRange> {
+        ensure_ranged!(Year: year);
+        match week {
+            1..=52 => {}
+            53 if week <= weeks_in_year(year) => {}
+            _ => {
+                return Err(error::ComponentRange {
+                    name: "week",
+                    minimum: 1,
+                    maximum: weeks_in_year(year) as _,
+                    value: week as _,
+                    conditional_range: true,
+                });
+            }
+        }
+
+        let adj_year = year - 1;
+        let raw = 365 * adj_year + div_floor!(adj_year, 4) - div_floor!(adj_year, 100)
+            + div_floor!(adj_year, 400);
+        let jan_4 = match (raw % 7) as i8 {
+            -6 | 1 => 8,
+            -5 | 2 => 9,
+            -4 | 3 => 10,
+            -3 | 4 => 4,
+            -2 | 5 => 5,
+            -1 | 6 => 6,
+            _ => 7,
+        };
+        let ordinal = week as i16 * 7 + weekday.number_from_monday() as i16 - jan_4;
+
+        Ok(if ordinal <= 0 {
+            // Safety: `ordinal` is not zero.
+            unsafe {
+                Self::__from_ordinal_date_unchecked(
+                    year - 1,
+                    (ordinal as u16).wrapping_add(days_in_year(year - 1)),
+                )
+            }
+        } else if ordinal > days_in_year(year) as i16 {
+            // Safety: `ordinal` is not zero.
+            unsafe {
+                Self::__from_ordinal_date_unchecked(year + 1, ordinal as u16 - days_in_year(year))
+            }
+        } else {
+            // Safety: `ordinal` is not zero.
+            unsafe { Self::__from_ordinal_date_unchecked(year, ordinal as _) }
+        })
+    }
+
+    /// Create a `Date` from the Julian day.
+    ///
+    /// The algorithm to perform this conversion is derived from one provided by Peter Baum; it is
+    /// freely available [here](https://www.researchgate.net/publication/316558298_Date_Algorithms).
+    ///
+    /// ```rust
+    /// # use time::Date;
+    /// # use time_macros::date;
+    /// assert_eq!(Date::from_julian_day(0), Ok(date!(-4713 - 11 - 24)));
+    /// assert_eq!(Date::from_julian_day(2_451_545), Ok(date!(2000 - 01 - 01)));
+    /// assert_eq!(Date::from_julian_day(2_458_485), Ok(date!(2019 - 01 - 01)));
+    /// assert_eq!(Date::from_julian_day(2_458_849), Ok(date!(2019 - 12 - 31)));
+    /// ```
+    #[doc(alias = "from_julian_date")]
+    pub const fn from_julian_day(julian_day: i32) -> Result<Self, error::ComponentRange> {
+        type JulianDay = RangedI32<{ Date::MIN.to_julian_day() }, { Date::MAX.to_julian_day() }>;
+        ensure_ranged!(JulianDay: julian_day);
+        Ok(Self::from_julian_day_unchecked(julian_day))
+    }
+
+    /// Create a `Date` from the Julian day.
+    ///
+    /// This does not check the validity of the provided Julian day, and as such may result in an
+    /// internally invalid value.
+    #[doc(alias = "from_julian_date_unchecked")]
+    pub(crate) const fn from_julian_day_unchecked(julian_day: i32) -> Self {
+        debug_assert!(julian_day >= Self::MIN.to_julian_day());
+        debug_assert!(julian_day <= Self::MAX.to_julian_day());
+
+        // To avoid a potential overflow, the value may need to be widened for some arithmetic.
+
+        let z = julian_day - 1_721_119;
+        let (mut year, mut ordinal) = if julian_day < -19_752_948 || julian_day > 23_195_514 {
+            let g = 100 * z as i64 - 25;
+            let a = (g / 3_652_425) as i32;
+            let b = a - a / 4;
+            let year = div_floor!(100 * b as i64 + g, 36525) as i32;
+            let ordinal = (b + z - div_floor!(36525 * year as i64, 100) as i32) as _;
+            (year, ordinal)
+        } else {
+            let g = 100 * z - 25;
+            let a = g / 3_652_425;
+            let b = a - a / 4;
+            let year = div_floor!(100 * b + g, 36525);
+            let ordinal = (b + z - div_floor!(36525 * year, 100)) as _;
+            (year, ordinal)
+        };
+
+        if is_leap_year(year) {
+            ordinal += 60;
+            cascade!(ordinal in 1..367 => year);
+        } else {
+            ordinal += 59;
+            cascade!(ordinal in 1..366 => year);
+        }
+
+        // Safety: `ordinal` is not zero.
+        unsafe { Self::__from_ordinal_date_unchecked(year, ordinal) }
+    }
+    // endregion constructors
+
+    // region: getters
+    /// Get the year of the date.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).year(), 2019);
+    /// assert_eq!(date!(2019 - 12 - 31).year(), 2019);
+    /// assert_eq!(date!(2020 - 01 - 01).year(), 2020);
+    /// ```
+    pub const fn year(self) -> i32 {
+        self.value.get() >> 9
+    }
+
+    /// Get the month.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).month(), Month::January);
+    /// assert_eq!(date!(2019 - 12 - 31).month(), Month::December);
+    /// ```
+    pub const fn month(self) -> Month {
+        self.month_day().0
+    }
+
+    /// Get the day of the month.
+    ///
+    /// The returned value will always be in the range `1..=31`.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).day(), 1);
+    /// assert_eq!(date!(2019 - 12 - 31).day(), 31);
+    /// ```
+    pub const fn day(self) -> u8 {
+        self.month_day().1
+    }
+
+    /// Get the month and day. This is more efficient than fetching the components individually.
+    // For whatever reason, rustc has difficulty optimizing this function. It's significantly faster
+    // to write the statements out by hand.
+    pub(crate) const fn month_day(self) -> (Month, u8) {
+        /// The number of days up to and including the given month. Common years
+        /// are first, followed by leap years.
+        const CUMULATIVE_DAYS_IN_MONTH_COMMON_LEAP: [[u16; 11]; 2] = [
+            [31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
+            [31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335],
+        ];
+
+        let days = CUMULATIVE_DAYS_IN_MONTH_COMMON_LEAP[is_leap_year(self.year()) as usize];
+        let ordinal = self.ordinal();
+
+        if ordinal > days[10] {
+            (Month::December, (ordinal - days[10]) as _)
+        } else if ordinal > days[9] {
+            (Month::November, (ordinal - days[9]) as _)
+        } else if ordinal > days[8] {
+            (Month::October, (ordinal - days[8]) as _)
+        } else if ordinal > days[7] {
+            (Month::September, (ordinal - days[7]) as _)
+        } else if ordinal > days[6] {
+            (Month::August, (ordinal - days[6]) as _)
+        } else if ordinal > days[5] {
+            (Month::July, (ordinal - days[5]) as _)
+        } else if ordinal > days[4] {
+            (Month::June, (ordinal - days[4]) as _)
+        } else if ordinal > days[3] {
+            (Month::May, (ordinal - days[3]) as _)
+        } else if ordinal > days[2] {
+            (Month::April, (ordinal - days[2]) as _)
+        } else if ordinal > days[1] {
+            (Month::March, (ordinal - days[1]) as _)
+        } else if ordinal > days[0] {
+            (Month::February, (ordinal - days[0]) as _)
+        } else {
+            (Month::January, ordinal as _)
+        }
+    }
+
+    /// Get the day of the year.
+    ///
+    /// The returned value will always be in the range `1..=366` (`1..=365` for common years).
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).ordinal(), 1);
+    /// assert_eq!(date!(2019 - 12 - 31).ordinal(), 365);
+    /// ```
+    pub const fn ordinal(self) -> u16 {
+        (self.value.get() & 0x1FF) as _
+    }
+
+    /// Get the ISO 8601 year and week number.
+    pub(crate) const fn iso_year_week(self) -> (i32, u8) {
+        let (year, ordinal) = self.to_ordinal_date();
+
+        match ((ordinal + 10 - self.weekday().number_from_monday() as u16) / 7) as _ {
+            0 => (year - 1, weeks_in_year(year - 1)),
+            53 if weeks_in_year(year) == 52 => (year + 1, 1),
+            week => (year, week),
+        }
+    }
+
+    /// Get the ISO week number.
+    ///
+    /// The returned value will always be in the range `1..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).iso_week(), 1);
+    /// assert_eq!(date!(2019 - 10 - 04).iso_week(), 40);
+    /// assert_eq!(date!(2020 - 01 - 01).iso_week(), 1);
+    /// assert_eq!(date!(2020 - 12 - 31).iso_week(), 53);
+    /// assert_eq!(date!(2021 - 01 - 01).iso_week(), 53);
+    /// ```
+    pub const fn iso_week(self) -> u8 {
+        self.iso_year_week().1
+    }
+
+    /// Get the week number where week 1 begins on the first Sunday.
+    ///
+    /// The returned value will always be in the range `0..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).sunday_based_week(), 0);
+    /// assert_eq!(date!(2020 - 01 - 01).sunday_based_week(), 0);
+    /// assert_eq!(date!(2020 - 12 - 31).sunday_based_week(), 52);
+    /// assert_eq!(date!(2021 - 01 - 01).sunday_based_week(), 0);
+    /// ```
+    pub const fn sunday_based_week(self) -> u8 {
+        ((self.ordinal() as i16 - self.weekday().number_days_from_sunday() as i16 + 6) / 7) as _
+    }
+
+    /// Get the week number where week 1 begins on the first Monday.
+    ///
+    /// The returned value will always be in the range `0..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).monday_based_week(), 0);
+    /// assert_eq!(date!(2020 - 01 - 01).monday_based_week(), 0);
+    /// assert_eq!(date!(2020 - 12 - 31).monday_based_week(), 52);
+    /// assert_eq!(date!(2021 - 01 - 01).monday_based_week(), 0);
+    /// ```
+    pub const fn monday_based_week(self) -> u8 {
+        ((self.ordinal() as i16 - self.weekday().number_days_from_monday() as i16 + 6) / 7) as _
+    }
+
+    /// Get the year, month, and day.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2019 - 01 - 01).to_calendar_date(),
+    ///     (2019, Month::January, 1)
+    /// );
+    /// ```
+    pub const fn to_calendar_date(self) -> (i32, Month, u8) {
+        let (month, day) = self.month_day();
+        (self.year(), month, day)
+    }
+
+    /// Get the year and ordinal day number.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).to_ordinal_date(), (2019, 1));
+    /// ```
+    pub const fn to_ordinal_date(self) -> (i32, u16) {
+        (self.year(), self.ordinal())
+    }
+
+    /// Get the ISO 8601 year, week number, and weekday.
+    ///
+    /// ```rust
+    /// # use time::Weekday::*;
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).to_iso_week_date(), (2019, 1, Tuesday));
+    /// assert_eq!(date!(2019 - 10 - 04).to_iso_week_date(), (2019, 40, Friday));
+    /// assert_eq!(
+    ///     date!(2020 - 01 - 01).to_iso_week_date(),
+    ///     (2020, 1, Wednesday)
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).to_iso_week_date(),
+    ///     (2020, 53, Thursday)
+    /// );
+    /// assert_eq!(date!(2021 - 01 - 01).to_iso_week_date(), (2020, 53, Friday));
+    /// ```
+    pub const fn to_iso_week_date(self) -> (i32, u8, Weekday) {
+        let (year, ordinal) = self.to_ordinal_date();
+        let weekday = self.weekday();
+
+        match ((ordinal + 10 - self.weekday().number_from_monday() as u16) / 7) as _ {
+            0 => (year - 1, weeks_in_year(year - 1), weekday),
+            53 if weeks_in_year(year) == 52 => (year + 1, 1, weekday),
+            week => (year, week, weekday),
+        }
+    }
+
+    /// Get the weekday.
+    ///
+    /// ```rust
+    /// # use time::Weekday::*;
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2019 - 01 - 01).weekday(), Tuesday);
+    /// assert_eq!(date!(2019 - 02 - 01).weekday(), Friday);
+    /// assert_eq!(date!(2019 - 03 - 01).weekday(), Friday);
+    /// assert_eq!(date!(2019 - 04 - 01).weekday(), Monday);
+    /// assert_eq!(date!(2019 - 05 - 01).weekday(), Wednesday);
+    /// assert_eq!(date!(2019 - 06 - 01).weekday(), Saturday);
+    /// assert_eq!(date!(2019 - 07 - 01).weekday(), Monday);
+    /// assert_eq!(date!(2019 - 08 - 01).weekday(), Thursday);
+    /// assert_eq!(date!(2019 - 09 - 01).weekday(), Sunday);
+    /// assert_eq!(date!(2019 - 10 - 01).weekday(), Tuesday);
+    /// assert_eq!(date!(2019 - 11 - 01).weekday(), Friday);
+    /// assert_eq!(date!(2019 - 12 - 01).weekday(), Sunday);
+    /// ```
+    pub const fn weekday(self) -> Weekday {
+        match self.to_julian_day() % 7 {
+            -6 | 1 => Weekday::Tuesday,
+            -5 | 2 => Weekday::Wednesday,
+            -4 | 3 => Weekday::Thursday,
+            -3 | 4 => Weekday::Friday,
+            -2 | 5 => Weekday::Saturday,
+            -1 | 6 => Weekday::Sunday,
+            val => {
+                debug_assert!(val == 0);
+                Weekday::Monday
+            }
+        }
+    }
+
+    /// Get the next calendar date.
+    ///
+    /// ```rust
+    /// # use time::Date;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2019 - 01 - 01).next_day(),
+    ///     Some(date!(2019 - 01 - 02))
+    /// );
+    /// assert_eq!(
+    ///     date!(2019 - 01 - 31).next_day(),
+    ///     Some(date!(2019 - 02 - 01))
+    /// );
+    /// assert_eq!(
+    ///     date!(2019 - 12 - 31).next_day(),
+    ///     Some(date!(2020 - 01 - 01))
+    /// );
+    /// assert_eq!(Date::MAX.next_day(), None);
+    /// ```
+    pub const fn next_day(self) -> Option<Self> {
+        if self.ordinal() == 366 || (self.ordinal() == 365 && !is_leap_year(self.year())) {
+            if self.value.get() == Self::MAX.value.get() {
+                None
+            } else {
+                // Safety: `ordinal` is not zero.
+                unsafe { Some(Self::__from_ordinal_date_unchecked(self.year() + 1, 1)) }
+            }
+        } else {
+            Some(Self {
+                // Safety: `ordinal` is not zero.
+                value: unsafe { NonZeroI32::new_unchecked(self.value.get() + 1) },
+            })
+        }
+    }
+
+    /// Get the previous calendar date.
+    ///
+    /// ```rust
+    /// # use time::Date;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2019 - 01 - 02).previous_day(),
+    ///     Some(date!(2019 - 01 - 01))
+    /// );
+    /// assert_eq!(
+    ///     date!(2019 - 02 - 01).previous_day(),
+    ///     Some(date!(2019 - 01 - 31))
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 01 - 01).previous_day(),
+    ///     Some(date!(2019 - 12 - 31))
+    /// );
+    /// assert_eq!(Date::MIN.previous_day(), None);
+    /// ```
+    pub const fn previous_day(self) -> Option<Self> {
+        if self.ordinal() != 1 {
+            Some(Self {
+                // Safety: `ordinal` is not zero.
+                value: unsafe { NonZeroI32::new_unchecked(self.value.get() - 1) },
+            })
+        } else if self.value.get() == Self::MIN.value.get() {
+            None
+        } else {
+            // Safety: `ordinal` is not zero.
+            Some(unsafe {
+                Self::__from_ordinal_date_unchecked(self.year() - 1, days_in_year(self.year() - 1))
+            })
+        }
+    }
+
+    /// Calculates the first occurrence of a weekday that is strictly later than a given `Date`.
+    ///
+    /// # Panics
+    /// Panics if an overflow occurred.
+    ///
+    /// # Examples
+    /// ```
+    /// # use time::Weekday;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 28).next_occurrence(Weekday::Monday),
+    ///     date!(2023 - 07 - 03)
+    /// );
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 19).next_occurrence(Weekday::Monday),
+    ///     date!(2023 - 06 - 26)
+    /// );
+    /// ```
+    pub const fn next_occurrence(self, weekday: Weekday) -> Self {
+        expect_opt!(
+            self.checked_next_occurrence(weekday),
+            "overflow calculating the next occurrence of a weekday"
+        )
+    }
+
+    /// Calculates the first occurrence of a weekday that is strictly earlier than a given `Date`.
+    ///
+    /// # Panics
+    /// Panics if an overflow occurred.
+    ///
+    /// # Examples
+    /// ```
+    /// # use time::Weekday;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 28).prev_occurrence(Weekday::Monday),
+    ///     date!(2023 - 06 - 26)
+    /// );
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 19).prev_occurrence(Weekday::Monday),
+    ///     date!(2023 - 06 - 12)
+    /// );
+    /// ```
+    pub const fn prev_occurrence(self, weekday: Weekday) -> Self {
+        expect_opt!(
+            self.checked_prev_occurrence(weekday),
+            "overflow calculating the previous occurrence of a weekday"
+        )
+    }
+
+    /// Calculates the `n`th occurrence of a weekday that is strictly later than a given `Date`.
+    ///
+    /// # Panics
+    /// Panics if an overflow occurred or if `n == 0`.
+    ///
+    /// # Examples
+    /// ```
+    /// # use time::Weekday;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 25).nth_next_occurrence(Weekday::Monday, 5),
+    ///     date!(2023 - 07 - 24)
+    /// );
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 26).nth_next_occurrence(Weekday::Monday, 5),
+    ///     date!(2023 - 07 - 31)
+    /// );
+    /// ```
+    pub const fn nth_next_occurrence(self, weekday: Weekday, n: u8) -> Self {
+        expect_opt!(
+            self.checked_nth_next_occurrence(weekday, n),
+            "overflow calculating the next occurrence of a weekday"
+        )
+    }
+
+    /// Calculates the `n`th occurrence of a weekday that is strictly earlier than a given `Date`.
+    ///
+    /// # Panics
+    /// Panics if an overflow occurred or if `n == 0`.
+    ///
+    /// # Examples
+    /// ```
+    /// # use time::Weekday;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 27).nth_prev_occurrence(Weekday::Monday, 3),
+    ///     date!(2023 - 06 - 12)
+    /// );
+    /// assert_eq!(
+    ///     date!(2023 - 06 - 26).nth_prev_occurrence(Weekday::Monday, 3),
+    ///     date!(2023 - 06 - 05)
+    /// );
+    /// ```
+    pub const fn nth_prev_occurrence(self, weekday: Weekday, n: u8) -> Self {
+        expect_opt!(
+            self.checked_nth_prev_occurrence(weekday, n),
+            "overflow calculating the previous occurrence of a weekday"
+        )
+    }
+
+    /// Get the Julian day for the date.
+    ///
+    /// The algorithm to perform this conversion is derived from one provided by Peter Baum; it is
+    /// freely available [here](https://www.researchgate.net/publication/316558298_Date_Algorithms).
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(-4713 - 11 - 24).to_julian_day(), 0);
+    /// assert_eq!(date!(2000 - 01 - 01).to_julian_day(), 2_451_545);
+    /// assert_eq!(date!(2019 - 01 - 01).to_julian_day(), 2_458_485);
+    /// assert_eq!(date!(2019 - 12 - 31).to_julian_day(), 2_458_849);
+    /// ```
+    pub const fn to_julian_day(self) -> i32 {
+        let year = self.year() - 1;
+        let ordinal = self.ordinal() as i32;
+
+        ordinal + 365 * year + div_floor!(year, 4) - div_floor!(year, 100)
+            + div_floor!(year, 400)
+            + 1_721_425
+    }
+    // endregion getters
+
+    // region: checked arithmetic
+    /// Computes `self + duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.checked_add(1.days()), None);
+    /// assert_eq!(Date::MIN.checked_add((-2).days()), None);
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_add(2.days()),
+    ///     Some(date!(2021 - 01 - 02))
+    /// );
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// This function only takes whole days into account.
+    ///
+    /// ```rust
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.checked_add(23.hours()), Some(Date::MAX));
+    /// assert_eq!(Date::MIN.checked_add((-23).hours()), Some(Date::MIN));
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_add(23.hours()),
+    ///     Some(date!(2020 - 12 - 31))
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_add(47.hours()),
+    ///     Some(date!(2021 - 01 - 01))
+    /// );
+    /// ```
+    pub const fn checked_add(self, duration: Duration) -> Option<Self> {
+        let whole_days = duration.whole_days();
+        if whole_days < i32::MIN as i64 || whole_days > i32::MAX as i64 {
+            return None;
+        }
+
+        let julian_day = const_try_opt!(self.to_julian_day().checked_add(whole_days as _));
+        if let Ok(date) = Self::from_julian_day(julian_day) {
+            Some(date)
+        } else {
+            None
+        }
+    }
+
+    /// Computes `self + duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Date, ext::NumericalStdDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.checked_add_std(1.std_days()), None);
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_add_std(2.std_days()),
+    ///     Some(date!(2021 - 01 - 02))
+    /// );
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// This function only takes whole days into account.
+    ///
+    /// ```rust
+    /// # use time::{Date, ext::NumericalStdDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.checked_add_std(23.std_hours()), Some(Date::MAX));
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_add_std(23.std_hours()),
+    ///     Some(date!(2020 - 12 - 31))
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_add_std(47.std_hours()),
+    ///     Some(date!(2021 - 01 - 01))
+    /// );
+    /// ```
+    pub const fn checked_add_std(self, duration: StdDuration) -> Option<Self> {
+        let whole_days = duration.as_secs() / Second::per(Day) as u64;
+        if whole_days > i32::MAX as u64 {
+            return None;
+        }
+
+        let julian_day = const_try_opt!(self.to_julian_day().checked_add(whole_days as _));
+        if let Ok(date) = Self::from_julian_day(julian_day) {
+            Some(date)
+        } else {
+            None
+        }
+    }
+
+    /// Computes `self - duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.checked_sub((-2).days()), None);
+    /// assert_eq!(Date::MIN.checked_sub(1.days()), None);
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_sub(2.days()),
+    ///     Some(date!(2020 - 12 - 29))
+    /// );
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// This function only takes whole days into account.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.checked_sub((-23).hours()), Some(Date::MAX));
+    /// assert_eq!(Date::MIN.checked_sub(23.hours()), Some(Date::MIN));
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_sub(23.hours()),
+    ///     Some(date!(2020 - 12 - 31))
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_sub(47.hours()),
+    ///     Some(date!(2020 - 12 - 30))
+    /// );
+    /// ```
+    pub const fn checked_sub(self, duration: Duration) -> Option<Self> {
+        let whole_days = duration.whole_days();
+        if whole_days < i32::MIN as i64 || whole_days > i32::MAX as i64 {
+            return None;
+        }
+
+        let julian_day = const_try_opt!(self.to_julian_day().checked_sub(whole_days as _));
+        if let Ok(date) = Self::from_julian_day(julian_day) {
+            Some(date)
+        } else {
+            None
+        }
+    }
+
+    /// Computes `self - duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalStdDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MIN.checked_sub_std(1.std_days()), None);
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_sub_std(2.std_days()),
+    ///     Some(date!(2020 - 12 - 29))
+    /// );
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// This function only takes whole days into account.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalStdDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MIN.checked_sub_std(23.std_hours()), Some(Date::MIN));
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_sub_std(23.std_hours()),
+    ///     Some(date!(2020 - 12 - 31))
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).checked_sub_std(47.std_hours()),
+    ///     Some(date!(2020 - 12 - 30))
+    /// );
+    /// ```
+    pub const fn checked_sub_std(self, duration: StdDuration) -> Option<Self> {
+        let whole_days = duration.as_secs() / Second::per(Day) as u64;
+        if whole_days > i32::MAX as u64 {
+            return None;
+        }
+
+        let julian_day = const_try_opt!(self.to_julian_day().checked_sub(whole_days as _));
+        if let Ok(date) = Self::from_julian_day(julian_day) {
+            Some(date)
+        } else {
+            None
+        }
+    }
+
+    /// Calculates the first occurrence of a weekday that is strictly later than a given `Date`.
+    /// Returns `None` if an overflow occurred.
+    pub(crate) const fn checked_next_occurrence(self, weekday: Weekday) -> Option<Self> {
+        let day_diff = match weekday as i8 - self.weekday() as i8 {
+            1 | -6 => 1,
+            2 | -5 => 2,
+            3 | -4 => 3,
+            4 | -3 => 4,
+            5 | -2 => 5,
+            6 | -1 => 6,
+            val => {
+                debug_assert!(val == 0);
+                7
+            }
+        };
+
+        self.checked_add(Duration::days(day_diff))
+    }
+
+    /// Calculates the first occurrence of a weekday that is strictly earlier than a given `Date`.
+    /// Returns `None` if an overflow occurred.
+    pub(crate) const fn checked_prev_occurrence(self, weekday: Weekday) -> Option<Self> {
+        let day_diff = match weekday as i8 - self.weekday() as i8 {
+            1 | -6 => 6,
+            2 | -5 => 5,
+            3 | -4 => 4,
+            4 | -3 => 3,
+            5 | -2 => 2,
+            6 | -1 => 1,
+            val => {
+                debug_assert!(val == 0);
+                7
+            }
+        };
+
+        self.checked_sub(Duration::days(day_diff))
+    }
+
+    /// Calculates the `n`th occurrence of a weekday that is strictly later than a given `Date`.
+    /// Returns `None` if an overflow occurred or if `n == 0`.
+    pub(crate) const fn checked_nth_next_occurrence(self, weekday: Weekday, n: u8) -> Option<Self> {
+        if n == 0 {
+            return None;
+        }
+
+        const_try_opt!(self.checked_next_occurrence(weekday))
+            .checked_add(Duration::weeks(n as i64 - 1))
+    }
+
+    /// Calculates the `n`th occurrence of a weekday that is strictly earlier than a given `Date`.
+    /// Returns `None` if an overflow occurred or if `n == 0`.
+    pub(crate) const fn checked_nth_prev_occurrence(self, weekday: Weekday, n: u8) -> Option<Self> {
+        if n == 0 {
+            return None;
+        }
+
+        const_try_opt!(self.checked_prev_occurrence(weekday))
+            .checked_sub(Duration::weeks(n as i64 - 1))
+    }
+    // endregion: checked arithmetic
+
+    // region: saturating arithmetic
+    /// Computes `self + duration`, saturating value on overflow.
+    ///
+    /// ```rust
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.saturating_add(1.days()), Date::MAX);
+    /// assert_eq!(Date::MIN.saturating_add((-2).days()), Date::MIN);
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).saturating_add(2.days()),
+    ///     date!(2021 - 01 - 02)
+    /// );
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// This function only takes whole days into account.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).saturating_add(23.hours()),
+    ///     date!(2020 - 12 - 31)
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).saturating_add(47.hours()),
+    ///     date!(2021 - 01 - 01)
+    /// );
+    /// ```
+    pub const fn saturating_add(self, duration: Duration) -> Self {
+        if let Some(datetime) = self.checked_add(duration) {
+            datetime
+        } else if duration.is_negative() {
+            Self::MIN
+        } else {
+            debug_assert!(duration.is_positive());
+            Self::MAX
+        }
+    }
+
+    /// Computes `self - duration`, saturating value on overflow.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::date;
+    /// assert_eq!(Date::MAX.saturating_sub((-2).days()), Date::MAX);
+    /// assert_eq!(Date::MIN.saturating_sub(1.days()), Date::MIN);
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).saturating_sub(2.days()),
+    ///     date!(2020 - 12 - 29)
+    /// );
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// This function only takes whole days into account.
+    ///
+    /// ```
+    /// # use time::ext::NumericalDuration;
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).saturating_sub(23.hours()),
+    ///     date!(2020 - 12 - 31)
+    /// );
+    /// assert_eq!(
+    ///     date!(2020 - 12 - 31).saturating_sub(47.hours()),
+    ///     date!(2020 - 12 - 30)
+    /// );
+    /// ```
+    pub const fn saturating_sub(self, duration: Duration) -> Self {
+        if let Some(datetime) = self.checked_sub(duration) {
+            datetime
+        } else if duration.is_negative() {
+            Self::MAX
+        } else {
+            debug_assert!(duration.is_positive());
+            Self::MIN
+        }
+    }
+    // region: saturating arithmetic
+
+    // region: replacement
+    /// Replace the year. The month and day will be unchanged.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2022 - 02 - 18).replace_year(2019),
+    ///     Ok(date!(2019 - 02 - 18))
+    /// );
+    /// assert!(date!(2022 - 02 - 18).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year
+    /// assert!(date!(2022 - 02 - 18).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid year
+    /// ```
+    #[must_use = "This method does not mutate the original `Date`."]
+    pub const fn replace_year(self, year: i32) -> Result<Self, error::ComponentRange> {
+        ensure_ranged!(Year: year);
+
+        let ordinal = self.ordinal();
+
+        // Dates in January and February are unaffected by leap years.
+        if ordinal <= 59 {
+            // Safety: `ordinal` is not zero.
+            return Ok(unsafe { Self::__from_ordinal_date_unchecked(year, ordinal) });
+        }
+
+        match (is_leap_year(self.year()), is_leap_year(year)) {
+            (false, false) | (true, true) => {
+                // Safety: `ordinal` is not zero.
+                Ok(unsafe { Self::__from_ordinal_date_unchecked(year, ordinal) })
+            }
+            // February 29 does not exist in common years.
+            (true, false) if ordinal == 60 => Err(error::ComponentRange {
+                name: "day",
+                value: 29,
+                minimum: 1,
+                maximum: 28,
+                conditional_range: true,
+            }),
+            // We're going from a common year to a leap year. Shift dates in March and later by
+            // one day.
+            // Safety: `ordinal` is not zero.
+            (false, true) => Ok(unsafe { Self::__from_ordinal_date_unchecked(year, ordinal + 1) }),
+            // We're going from a leap year to a common year. Shift dates in January and
+            // February by one day.
+            // Safety: `ordinal` is not zero.
+            (true, false) => Ok(unsafe { Self::__from_ordinal_date_unchecked(year, ordinal - 1) }),
+        }
+    }
+
+    /// Replace the month of the year.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// # use time::Month;
+    /// assert_eq!(
+    ///     date!(2022 - 02 - 18).replace_month(Month::January),
+    ///     Ok(date!(2022 - 01 - 18))
+    /// );
+    /// assert!(
+    ///     date!(2022 - 01 - 30)
+    ///         .replace_month(Month::February)
+    ///         .is_err()
+    /// ); // 30 isn't a valid day in February
+    /// ```
+    #[must_use = "This method does not mutate the original `Date`."]
+    pub const fn replace_month(self, month: Month) -> Result<Self, error::ComponentRange> {
+        let (year, _, day) = self.to_calendar_date();
+        Self::from_calendar_date(year, month, day)
+    }
+
+    /// Replace the day of the month.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(
+    ///     date!(2022 - 02 - 18).replace_day(1),
+    ///     Ok(date!(2022 - 02 - 01))
+    /// );
+    /// assert!(date!(2022 - 02 - 18).replace_day(0).is_err()); // 0 isn't a valid day
+    /// assert!(date!(2022 - 02 - 18).replace_day(30).is_err()); // 30 isn't a valid day in February
+    /// ```
+    #[must_use = "This method does not mutate the original `Date`."]
+    pub const fn replace_day(self, day: u8) -> Result<Self, error::ComponentRange> {
+        match day {
+            1..=28 => {}
+            29..=31 if day <= days_in_year_month(self.year(), self.month()) => {}
+            _ => {
+                return Err(error::ComponentRange {
+                    name: "day",
+                    minimum: 1,
+                    maximum: days_in_year_month(self.year(), self.month()) as _,
+                    value: day as _,
+                    conditional_range: true,
+                });
+            }
+        }
+
+        // Safety: `ordinal` is not zero.
+        Ok(unsafe {
+            Self::__from_ordinal_date_unchecked(
+                self.year(),
+                (self.ordinal() as i16 - self.day() as i16 + day as i16) as _,
+            )
+        })
+    }
+
+    /// Replace the day of the year.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert_eq!(date!(2022 - 049).replace_ordinal(1), Ok(date!(2022 - 001)));
+    /// assert!(date!(2022 - 049).replace_ordinal(0).is_err()); // 0 isn't a valid ordinal
+    /// assert!(date!(2022 - 049).replace_ordinal(366).is_err()); // 2022 isn't a leap year
+    /// ````
+    #[must_use = "This method does not mutate the original `Date`."]
+    pub const fn replace_ordinal(self, ordinal: u16) -> Result<Self, error::ComponentRange> {
+        match ordinal {
+            1..=365 => {}
+            366 if is_leap_year(self.year()) => {}
+            _ => {
+                return Err(error::ComponentRange {
+                    name: "ordinal",
+                    minimum: 1,
+                    maximum: days_in_year(self.year()) as _,
+                    value: ordinal as _,
+                    conditional_range: true,
+                });
+            }
+        }
+
+        // Safety: `ordinal` is in range.
+        Ok(unsafe { Self::__from_ordinal_date_unchecked(self.year(), ordinal) })
+    }
+    // endregion replacement
+}
+
+// region: attach time
+/// Methods to add a [`Time`] component, resulting in a [`PrimitiveDateTime`].
+impl Date {
+    /// Create a [`PrimitiveDateTime`] using the existing date. The [`Time`] component will be set
+    /// to midnight.
+    ///
+    /// ```rust
+    /// # use time_macros::{date, datetime};
+    /// assert_eq!(date!(1970-01-01).midnight(), datetime!(1970-01-01 0:00));
+    /// ```
+    pub const fn midnight(self) -> PrimitiveDateTime {
+        PrimitiveDateTime::new(self, Time::MIDNIGHT)
+    }
+
+    /// Create a [`PrimitiveDateTime`] using the existing date and the provided [`Time`].
+    ///
+    /// ```rust
+    /// # use time_macros::{date, datetime, time};
+    /// assert_eq!(
+    ///     date!(1970-01-01).with_time(time!(0:00)),
+    ///     datetime!(1970-01-01 0:00),
+    /// );
+    /// ```
+    pub const fn with_time(self, time: Time) -> PrimitiveDateTime {
+        PrimitiveDateTime::new(self, time)
+    }
+
+    /// Attempt to create a [`PrimitiveDateTime`] using the existing date and the provided time.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert!(date!(1970 - 01 - 01).with_hms(0, 0, 0).is_ok());
+    /// assert!(date!(1970 - 01 - 01).with_hms(24, 0, 0).is_err());
+    /// ```
+    pub const fn with_hms(
+        self,
+        hour: u8,
+        minute: u8,
+        second: u8,
+    ) -> Result<PrimitiveDateTime, error::ComponentRange> {
+        Ok(PrimitiveDateTime::new(
+            self,
+            const_try!(Time::from_hms(hour, minute, second)),
+        ))
+    }
+
+    /// Attempt to create a [`PrimitiveDateTime`] using the existing date and the provided time.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert!(date!(1970 - 01 - 01).with_hms_milli(0, 0, 0, 0).is_ok());
+    /// assert!(date!(1970 - 01 - 01).with_hms_milli(24, 0, 0, 0).is_err());
+    /// ```
+    pub const fn with_hms_milli(
+        self,
+        hour: u8,
+        minute: u8,
+        second: u8,
+        millisecond: u16,
+    ) -> Result<PrimitiveDateTime, error::ComponentRange> {
+        Ok(PrimitiveDateTime::new(
+            self,
+            const_try!(Time::from_hms_milli(hour, minute, second, millisecond)),
+        ))
+    }
+
+    /// Attempt to create a [`PrimitiveDateTime`] using the existing date and the provided time.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert!(date!(1970 - 01 - 01).with_hms_micro(0, 0, 0, 0).is_ok());
+    /// assert!(date!(1970 - 01 - 01).with_hms_micro(24, 0, 0, 0).is_err());
+    /// ```
+    pub const fn with_hms_micro(
+        self,
+        hour: u8,
+        minute: u8,
+        second: u8,
+        microsecond: u32,
+    ) -> Result<PrimitiveDateTime, error::ComponentRange> {
+        Ok(PrimitiveDateTime::new(
+            self,
+            const_try!(Time::from_hms_micro(hour, minute, second, microsecond)),
+        ))
+    }
+
+    /// Attempt to create a [`PrimitiveDateTime`] using the existing date and the provided time.
+    ///
+    /// ```rust
+    /// # use time_macros::date;
+    /// assert!(date!(1970 - 01 - 01).with_hms_nano(0, 0, 0, 0).is_ok());
+    /// assert!(date!(1970 - 01 - 01).with_hms_nano(24, 0, 0, 0).is_err());
+    /// ```
+    pub const fn with_hms_nano(
+        self,
+        hour: u8,
+        minute: u8,
+        second: u8,
+        nanosecond: u32,
+    ) -> Result<PrimitiveDateTime, error::ComponentRange> {
+        Ok(PrimitiveDateTime::new(
+            self,
+            const_try!(Time::from_hms_nano(hour, minute, second, nanosecond)),
+        ))
+    }
+}
+// endregion attach time
+
+// region: formatting & parsing
+#[cfg(feature = "formatting")]
+impl Date {
+    /// Format the `Date` using the provided [format description](crate::format_description).
+    pub fn format_into(
+        self,
+        output: &mut impl io::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<usize, error::Format> {
+        format.format_into(output, Some(self), None, None)
+    }
+
+    /// Format the `Date` using the provided [format description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::{format_description};
+    /// # use time_macros::date;
+    /// let format = format_description::parse("[year]-[month]-[day]")?;
+    /// assert_eq!(date!(2020 - 01 - 02).format(&format)?, "2020-01-02");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format(self, format: &(impl Formattable + ?Sized)) -> Result<String, error::Format> {
+        format.format(Some(self), None, None)
+    }
+}
+
+#[cfg(feature = "parsing")]
+impl Date {
+    /// Parse a `Date` from the input using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::Date;
+    /// # use time_macros::{date, format_description};
+    /// let format = format_description!("[year]-[month]-[day]");
+    /// assert_eq!(Date::parse("2020-01-02", &format)?, date!(2020 - 01 - 02));
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn parse(
+        input: &str,
+        description: &(impl Parsable + ?Sized),
+    ) -> Result<Self, error::Parse> {
+        description.parse_date(input.as_bytes())
+    }
+}
+
+mod private {
+    #[non_exhaustive]
+    #[derive(Debug, Clone, Copy)]
+    pub struct DateMetadata {
+        /// The width of the year component, including the sign.
+        pub(super) year_width: u8,
+        /// Whether the sign should be displayed.
+        pub(super) display_sign: bool,
+        pub(super) year: i32,
+        pub(super) month: u8,
+        pub(super) day: u8,
+    }
+}
+use private::DateMetadata;
+
+impl SmartDisplay for Date {
+    type Metadata = DateMetadata;
+
+    fn metadata(&self, _: FormatterOptions) -> Metadata<Self> {
+        let (year, month, day) = self.to_calendar_date();
+
+        // There is a minimum of four digits for any year.
+        let mut year_width = cmp::max(year.unsigned_abs().num_digits(), 4);
+        let display_sign = if !(0..10_000).contains(&year) {
+            // An extra character is required for the sign.
+            year_width += 1;
+            true
+        } else {
+            false
+        };
+
+        let formatted_width = year_width.extend::<usize>()
+            + smart_display::padded_width_of!(
+                "-",
+                u8::from(month) => width(2),
+                "-",
+                day => width(2),
+            );
+
+        Metadata::new(
+            formatted_width,
+            self,
+            DateMetadata {
+                year_width,
+                display_sign,
+                year,
+                month: u8::from(month),
+                day,
+            },
+        )
+    }
+
+    fn fmt_with_metadata(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        metadata: Metadata<Self>,
+    ) -> fmt::Result {
+        let DateMetadata {
+            year_width,
+            display_sign,
+            year,
+            month,
+            day,
+        } = *metadata;
+        let year_width = year_width.extend();
+
+        if display_sign {
+            f.pad_with_width(
+                metadata.unpadded_width(),
+                format_args!("{year:+0year_width$}-{month:02}-{day:02}"),
+            )
+        } else {
+            f.pad_with_width(
+                metadata.unpadded_width(),
+                format_args!("{year:0year_width$}-{month:02}-{day:02}"),
+            )
+        }
+    }
+}
+
+impl fmt::Display for Date {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        SmartDisplay::fmt(self, f)
+    }
+}
+
+impl fmt::Debug for Date {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        fmt::Display::fmt(self, f)
+    }
+}
+// endregion formatting & parsing
+
+// region: trait impls
+impl Add<Duration> for Date {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, duration: Duration) -> Self::Output {
+        self.checked_add(duration)
+            .expect("overflow adding duration to date")
+    }
+}
+
+impl Add<StdDuration> for Date {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, duration: StdDuration) -> Self::Output {
+        self.checked_add_std(duration)
+            .expect("overflow adding duration to date")
+    }
+}
+
+impl_add_assign!(Date: Duration, StdDuration);
+
+impl Sub<Duration> for Date {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, duration: Duration) -> Self::Output {
+        self.checked_sub(duration)
+            .expect("overflow subtracting duration from date")
+    }
+}
+
+impl Sub<StdDuration> for Date {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, duration: StdDuration) -> Self::Output {
+        self.checked_sub_std(duration)
+            .expect("overflow subtracting duration from date")
+    }
+}
+
+impl_sub_assign!(Date: Duration, StdDuration);
+
+impl Sub for Date {
+    type Output = Duration;
+
+    fn sub(self, other: Self) -> Self::Output {
+        Duration::days((self.to_julian_day() - other.to_julian_day()).extend())
+    }
+}
+// endregion trait impls
diff --git a/time/src/duration.rs b/time/src/duration.rs
new file mode 100644
index 000000000..b3d00566b
--- /dev/null
+++ b/time/src/duration.rs
@@ -0,0 +1,1576 @@
+//! The [`Duration`] struct and its associated `impl`s.
+
+use core::cmp::Ordering;
+use core::fmt;
+use core::iter::Sum;
+use core::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
+use core::time::Duration as StdDuration;
+
+use deranged::RangedI32;
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::error;
+use crate::internal_macros::{
+    const_try_opt, expect_opt, impl_add_assign, impl_div_assign, impl_mul_assign, impl_sub_assign,
+};
+#[cfg(feature = "std")]
+#[allow(deprecated)]
+use crate::Instant;
+
+/// By explicitly inserting this enum where padding is expected, the compiler is able to better
+/// perform niche value optimization.
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub(crate) enum Padding {
+    #[allow(clippy::missing_docs_in_private_items)]
+    Optimize,
+}
+
+/// The type of the `nanosecond` field of `Duration`.
+type Nanoseconds =
+    RangedI32<{ -(Nanosecond::per(Second) as i32 - 1) }, { Nanosecond::per(Second) as i32 - 1 }>;
+
+/// A span of time with nanosecond precision.
+///
+/// Each `Duration` is composed of a whole number of seconds and a fractional part represented in
+/// nanoseconds.
+///
+/// This implementation allows for negative durations, unlike [`core::time::Duration`].
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Duration {
+    /// Number of whole seconds.
+    seconds: i64,
+    /// Number of nanoseconds within the second. The sign always matches the `seconds` field.
+    // Sign must match that of `seconds` (though this is not a safety requirement).
+    nanoseconds: Nanoseconds,
+    #[allow(clippy::missing_docs_in_private_items)]
+    padding: Padding,
+}
+
+impl fmt::Debug for Duration {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Duration")
+            .field("seconds", &self.seconds)
+            .field("nanoseconds", &self.nanoseconds)
+            .finish()
+    }
+}
+
+impl Default for Duration {
+    fn default() -> Self {
+        Self {
+            seconds: 0,
+            nanoseconds: Nanoseconds::new_static::<0>(),
+            padding: Padding::Optimize,
+        }
+    }
+}
+
+/// This is adapted from the [`std` implementation][std], which uses mostly bit
+/// operations to ensure the highest precision:
+///
+/// Changes from `std` are marked and explained below.
+///
+/// [std]: https://github.com/rust-lang/rust/blob/3a37c2f0523c87147b64f1b8099fc9df22e8c53e/library/core/src/time.rs#L1262-L1340
+#[rustfmt::skip] // Skip `rustfmt` because it reformats the arguments of the macro weirdly.
+macro_rules! try_from_secs {
+    (
+        secs = $secs: expr,
+        mantissa_bits = $mant_bits: literal,
+        exponent_bits = $exp_bits: literal,
+        offset = $offset: literal,
+        bits_ty = $bits_ty:ty,
+        bits_ty_signed = $bits_ty_signed:ty,
+        double_ty = $double_ty:ty,
+        float_ty = $float_ty:ty,
+        is_nan = $is_nan:expr,
+        is_overflow = $is_overflow:expr,
+    ) => {{
+        'value: {
+            const MIN_EXP: i16 = 1 - (1i16 << $exp_bits) / 2;
+            const MANT_MASK: $bits_ty = (1 << $mant_bits) - 1;
+            const EXP_MASK: $bits_ty = (1 << $exp_bits) - 1;
+
+            // Change from std: No error check for negative values necessary.
+
+            let bits = $secs.to_bits();
+            let mant = (bits & MANT_MASK) | (MANT_MASK + 1);
+            let exp = ((bits >> $mant_bits) & EXP_MASK) as i16 + MIN_EXP;
+
+            let (secs, nanos) = if exp < -31 {
+                // the input represents less than 1ns and can not be rounded to it
+                (0u64, 0u32)
+            } else if exp < 0 {
+                // the input is less than 1 second
+                let t = <$double_ty>::from(mant) << ($offset + exp);
+                let nanos_offset = $mant_bits + $offset;
+                let nanos_tmp = u128::from(Nanosecond::per(Second)) * u128::from(t);
+                let nanos = (nanos_tmp >> nanos_offset) as u32;
+
+                let rem_mask = (1 << nanos_offset) - 1;
+                let rem_msb_mask = 1 << (nanos_offset - 1);
+                let rem = nanos_tmp & rem_mask;
+                let is_tie = rem == rem_msb_mask;
+                let is_even = (nanos & 1) == 0;
+                let rem_msb = nanos_tmp & rem_msb_mask == 0;
+                let add_ns = !(rem_msb || (is_even && is_tie));
+
+                // f32 does not have enough precision to trigger the second branch
+                // since it can not represent numbers between 0.999_999_940_395 and 1.0.
+                let nanos = nanos + add_ns as u32;
+                if ($mant_bits == 23) || (nanos != Nanosecond::per(Second)) {
+                    (0, nanos)
+                } else {
+                    (1, 0)
+                }
+            } else if exp < $mant_bits {
+                let secs = u64::from(mant >> ($mant_bits - exp));
+                let t = <$double_ty>::from((mant << exp) & MANT_MASK);
+                let nanos_offset = $mant_bits;
+                let nanos_tmp = <$double_ty>::from(Nanosecond::per(Second)) * t;
+                let nanos = (nanos_tmp >> nanos_offset) as u32;
+
+                let rem_mask = (1 << nanos_offset) - 1;
+                let rem_msb_mask = 1 << (nanos_offset - 1);
+                let rem = nanos_tmp & rem_mask;
+                let is_tie = rem == rem_msb_mask;
+                let is_even = (nanos & 1) == 0;
+                let rem_msb = nanos_tmp & rem_msb_mask == 0;
+                let add_ns = !(rem_msb || (is_even && is_tie));
+
+                // f32 does not have enough precision to trigger the second branch.
+                // For example, it can not represent numbers between 1.999_999_880...
+                // and 2.0. Bigger values result in even smaller precision of the
+                // fractional part.
+                let nanos = nanos + add_ns as u32;
+                if ($mant_bits == 23) || (nanos != Nanosecond::per(Second)) {
+                    (secs, nanos)
+                } else {
+                    (secs + 1, 0)
+                }
+            } else if exp < 63 {
+                // Change from std: The exponent here is 63 instead of 64,
+                // because i64::MAX + 1 is 2^63.
+
+                // the input has no fractional part
+                let secs = u64::from(mant) << (exp - $mant_bits);
+                (secs, 0)
+            } else if bits == (i64::MIN as $float_ty).to_bits() {
+                // Change from std: Signed integers are asymmetrical in that
+                // iN::MIN is -iN::MAX - 1. So for example i8 covers the
+                // following numbers -128..=127. The check above (exp < 63)
+                // doesn't cover i64::MIN as that is -2^63, so we have this
+                // additional case to handle the asymmetry of iN::MIN.
+                break 'value Self::new_ranged_unchecked(i64::MIN, Nanoseconds::new_static::<0>());
+            } else if $secs.is_nan() {
+                // Change from std: std doesn't differentiate between the error
+                // cases.
+                $is_nan
+            } else {
+                $is_overflow
+            };
+
+            // Change from std: All the code is mostly unmodified in that it
+            // simply calculates an unsigned integer. Here we extract the sign
+            // bit and assign it to the number. We basically manually do two's
+            // complement here, we could also use an if and just negate the
+            // numbers based on the sign, but it turns out to be quite a bit
+            // slower.
+            let mask = (bits as $bits_ty_signed) >> ($mant_bits + $exp_bits);
+            #[allow(trivial_numeric_casts)]
+            let secs_signed = ((secs as i64) ^ (mask as i64)) - (mask as i64);
+            #[allow(trivial_numeric_casts)]
+            let nanos_signed = ((nanos as i32) ^ (mask as i32)) - (mask as i32);
+            // Safety: `nanos_signed` is in range.
+            unsafe { Self::new_unchecked(secs_signed, nanos_signed) }
+        }
+    }};
+}
+
+impl Duration {
+    // region: constants
+    /// Equivalent to `0.seconds()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::ZERO, 0.seconds());
+    /// ```
+    pub const ZERO: Self = Self::seconds(0);
+
+    /// Equivalent to `1.nanoseconds()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::NANOSECOND, 1.nanoseconds());
+    /// ```
+    pub const NANOSECOND: Self = Self::nanoseconds(1);
+
+    /// Equivalent to `1.microseconds()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::MICROSECOND, 1.microseconds());
+    /// ```
+    pub const MICROSECOND: Self = Self::microseconds(1);
+
+    /// Equivalent to `1.milliseconds()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::MILLISECOND, 1.milliseconds());
+    /// ```
+    pub const MILLISECOND: Self = Self::milliseconds(1);
+
+    /// Equivalent to `1.seconds()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::SECOND, 1.seconds());
+    /// ```
+    pub const SECOND: Self = Self::seconds(1);
+
+    /// Equivalent to `1.minutes()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::MINUTE, 1.minutes());
+    /// ```
+    pub const MINUTE: Self = Self::minutes(1);
+
+    /// Equivalent to `1.hours()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::HOUR, 1.hours());
+    /// ```
+    pub const HOUR: Self = Self::hours(1);
+
+    /// Equivalent to `1.days()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::DAY, 1.days());
+    /// ```
+    pub const DAY: Self = Self::days(1);
+
+    /// Equivalent to `1.weeks()`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::WEEK, 1.weeks());
+    /// ```
+    pub const WEEK: Self = Self::weeks(1);
+
+    /// The minimum possible duration. Adding any negative duration to this will cause an overflow.
+    pub const MIN: Self = Self::new_ranged(i64::MIN, Nanoseconds::MIN);
+
+    /// The maximum possible duration. Adding any positive duration to this will cause an overflow.
+    pub const MAX: Self = Self::new_ranged(i64::MAX, Nanoseconds::MAX);
+    // endregion constants
+
+    // region: is_{sign}
+    /// Check if a duration is exactly zero.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert!(0.seconds().is_zero());
+    /// assert!(!1.nanoseconds().is_zero());
+    /// ```
+    pub const fn is_zero(self) -> bool {
+        self.seconds == 0 && self.nanoseconds.get() == 0
+    }
+
+    /// Check if a duration is negative.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert!((-1).seconds().is_negative());
+    /// assert!(!0.seconds().is_negative());
+    /// assert!(!1.seconds().is_negative());
+    /// ```
+    pub const fn is_negative(self) -> bool {
+        self.seconds < 0 || self.nanoseconds.get() < 0
+    }
+
+    /// Check if a duration is positive.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert!(1.seconds().is_positive());
+    /// assert!(!0.seconds().is_positive());
+    /// assert!(!(-1).seconds().is_positive());
+    /// ```
+    pub const fn is_positive(self) -> bool {
+        self.seconds > 0 || self.nanoseconds.get() > 0
+    }
+    // endregion is_{sign}
+
+    // region: abs
+    /// Get the absolute value of the duration.
+    ///
+    /// This method saturates the returned value if it would otherwise overflow.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.seconds().abs(), 1.seconds());
+    /// assert_eq!(0.seconds().abs(), 0.seconds());
+    /// assert_eq!((-1).seconds().abs(), 1.seconds());
+    /// ```
+    pub const fn abs(self) -> Self {
+        match self.seconds.checked_abs() {
+            Some(seconds) => Self::new_ranged_unchecked(seconds, self.nanoseconds.abs()),
+            None => Self::MAX,
+        }
+    }
+
+    /// Convert the existing `Duration` to a `std::time::Duration` and its sign. This returns a
+    /// [`std::time::Duration`] and does not saturate the returned value (unlike [`Duration::abs`]).
+    ///
+    /// ```rust
+    /// # use time::ext::{NumericalDuration, NumericalStdDuration};
+    /// assert_eq!(1.seconds().unsigned_abs(), 1.std_seconds());
+    /// assert_eq!(0.seconds().unsigned_abs(), 0.std_seconds());
+    /// assert_eq!((-1).seconds().unsigned_abs(), 1.std_seconds());
+    /// ```
+    pub const fn unsigned_abs(self) -> StdDuration {
+        StdDuration::new(
+            self.seconds.unsigned_abs(),
+            self.nanoseconds.get().unsigned_abs(),
+        )
+    }
+    // endregion abs
+
+    // region: constructors
+    /// Create a new `Duration` without checking the validity of the components.
+    ///
+    /// # Safety
+    ///
+    /// - `nanoseconds` must be in the range `-999_999_999..=999_999_999`.
+    ///
+    /// While the sign of `nanoseconds` is required to be the same as the sign of `seconds`, this is
+    /// not a safety invariant.
+    pub(crate) const unsafe fn new_unchecked(seconds: i64, nanoseconds: i32) -> Self {
+        Self::new_ranged_unchecked(
+            seconds,
+            // Safety: The caller must uphold the safety invariants.
+            unsafe { Nanoseconds::new_unchecked(nanoseconds) },
+        )
+    }
+
+    /// Create a new `Duration` without checking the validity of the components.
+    pub(crate) const fn new_ranged_unchecked(seconds: i64, nanoseconds: Nanoseconds) -> Self {
+        if seconds < 0 {
+            debug_assert!(nanoseconds.get() <= 0);
+        } else if seconds > 0 {
+            debug_assert!(nanoseconds.get() >= 0);
+        }
+
+        Self {
+            seconds,
+            nanoseconds,
+            padding: Padding::Optimize,
+        }
+    }
+
+    /// Create a new `Duration` with the provided seconds and nanoseconds. If nanoseconds is at
+    /// least ±10<sup>9</sup>, it will wrap to the number of seconds.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::new(1, 0), 1.seconds());
+    /// assert_eq!(Duration::new(-1, 0), (-1).seconds());
+    /// assert_eq!(Duration::new(1, 2_000_000_000), 3.seconds());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    pub const fn new(mut seconds: i64, mut nanoseconds: i32) -> Self {
+        seconds = expect_opt!(
+            seconds.checked_add(nanoseconds as i64 / Nanosecond::per(Second) as i64),
+            "overflow constructing `time::Duration`"
+        );
+        nanoseconds %= Nanosecond::per(Second) as i32;
+
+        if seconds > 0 && nanoseconds < 0 {
+            // `seconds` cannot overflow here because it is positive.
+            seconds -= 1;
+            nanoseconds += Nanosecond::per(Second) as i32;
+        } else if seconds < 0 && nanoseconds > 0 {
+            // `seconds` cannot overflow here because it is negative.
+            seconds += 1;
+            nanoseconds -= Nanosecond::per(Second) as i32;
+        }
+
+        // Safety: `nanoseconds` is in range due to the modulus above.
+        unsafe { Self::new_unchecked(seconds, nanoseconds) }
+    }
+
+    /// Create a new `Duration` with the provided seconds and nanoseconds.
+    pub(crate) const fn new_ranged(mut seconds: i64, mut nanoseconds: Nanoseconds) -> Self {
+        if seconds > 0 && nanoseconds.get() < 0 {
+            // `seconds` cannot overflow here because it is positive.
+            seconds -= 1;
+            // Safety: `nanoseconds` is negative with a maximum of 999,999,999, so adding a billion
+            // to it is guaranteed to result in an in-range value.
+            nanoseconds = unsafe {
+                Nanoseconds::new_unchecked(nanoseconds.get() + Nanosecond::per(Second) as i32)
+            };
+        } else if seconds < 0 && nanoseconds.get() > 0 {
+            // `seconds` cannot overflow here because it is negative.
+            seconds += 1;
+            // Safety: `nanoseconds` is positive with a minimum of -999,999,999, so subtracting a
+            // billion from it is guaranteed to result in an in-range value.
+            nanoseconds = unsafe {
+                Nanoseconds::new_unchecked(nanoseconds.get() - Nanosecond::per(Second) as i32)
+            };
+        }
+
+        Self::new_ranged_unchecked(seconds, nanoseconds)
+    }
+
+    /// Create a new `Duration` with the given number of weeks. Equivalent to
+    /// `Duration::seconds(weeks * 604_800)`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::weeks(1), 604_800.seconds());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    pub const fn weeks(weeks: i64) -> Self {
+        Self::seconds(expect_opt!(
+            weeks.checked_mul(Second::per(Week) as _),
+            "overflow constructing `time::Duration`"
+        ))
+    }
+
+    /// Create a new `Duration` with the given number of days. Equivalent to
+    /// `Duration::seconds(days * 86_400)`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::days(1), 86_400.seconds());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    pub const fn days(days: i64) -> Self {
+        Self::seconds(expect_opt!(
+            days.checked_mul(Second::per(Day) as _),
+            "overflow constructing `time::Duration`"
+        ))
+    }
+
+    /// Create a new `Duration` with the given number of hours. Equivalent to
+    /// `Duration::seconds(hours * 3_600)`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::hours(1), 3_600.seconds());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    pub const fn hours(hours: i64) -> Self {
+        Self::seconds(expect_opt!(
+            hours.checked_mul(Second::per(Hour) as _),
+            "overflow constructing `time::Duration`"
+        ))
+    }
+
+    /// Create a new `Duration` with the given number of minutes. Equivalent to
+    /// `Duration::seconds(minutes * 60)`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::minutes(1), 60.seconds());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    pub const fn minutes(minutes: i64) -> Self {
+        Self::seconds(expect_opt!(
+            minutes.checked_mul(Second::per(Minute) as _),
+            "overflow constructing `time::Duration`"
+        ))
+    }
+
+    /// Create a new `Duration` with the given number of seconds.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::seconds(1), 1_000.milliseconds());
+    /// ```
+    pub const fn seconds(seconds: i64) -> Self {
+        Self::new_ranged_unchecked(seconds, Nanoseconds::new_static::<0>())
+    }
+
+    /// Creates a new `Duration` from the specified number of seconds represented as `f64`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::seconds_f64(0.5), 0.5.seconds());
+    /// assert_eq!(Duration::seconds_f64(-0.5), (-0.5).seconds());
+    /// ```
+    pub fn seconds_f64(seconds: f64) -> Self {
+        try_from_secs!(
+            secs = seconds,
+            mantissa_bits = 52,
+            exponent_bits = 11,
+            offset = 44,
+            bits_ty = u64,
+            bits_ty_signed = i64,
+            double_ty = u128,
+            float_ty = f64,
+            is_nan = crate::expect_failed("passed NaN to `time::Duration::seconds_f64`"),
+            is_overflow = crate::expect_failed("overflow constructing `time::Duration`"),
+        )
+    }
+
+    /// Creates a new `Duration` from the specified number of seconds represented as `f32`.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::seconds_f32(0.5), 0.5.seconds());
+    /// assert_eq!(Duration::seconds_f32(-0.5), (-0.5).seconds());
+    /// ```
+    pub fn seconds_f32(seconds: f32) -> Self {
+        try_from_secs!(
+            secs = seconds,
+            mantissa_bits = 23,
+            exponent_bits = 8,
+            offset = 41,
+            bits_ty = u32,
+            bits_ty_signed = i32,
+            double_ty = u64,
+            float_ty = f32,
+            is_nan = crate::expect_failed("passed NaN to `time::Duration::seconds_f32`"),
+            is_overflow = crate::expect_failed("overflow constructing `time::Duration`"),
+        )
+    }
+
+    /// Creates a new `Duration` from the specified number of seconds
+    /// represented as `f64`. Any values that are out of bounds are saturated at
+    /// the minimum or maximum respectively. `NaN` gets turned into a `Duration`
+    /// of 0 seconds.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::saturating_seconds_f64(0.5), 0.5.seconds());
+    /// assert_eq!(Duration::saturating_seconds_f64(-0.5), (-0.5).seconds());
+    /// assert_eq!(
+    ///     Duration::saturating_seconds_f64(f64::NAN),
+    ///     Duration::new(0, 0),
+    /// );
+    /// assert_eq!(
+    ///     Duration::saturating_seconds_f64(f64::NEG_INFINITY),
+    ///     Duration::MIN,
+    /// );
+    /// assert_eq!(
+    ///     Duration::saturating_seconds_f64(f64::INFINITY),
+    ///     Duration::MAX,
+    /// );
+    /// ```
+    pub fn saturating_seconds_f64(seconds: f64) -> Self {
+        try_from_secs!(
+            secs = seconds,
+            mantissa_bits = 52,
+            exponent_bits = 11,
+            offset = 44,
+            bits_ty = u64,
+            bits_ty_signed = i64,
+            double_ty = u128,
+            float_ty = f64,
+            is_nan = return Self::ZERO,
+            is_overflow = return if seconds < 0.0 { Self::MIN } else { Self::MAX },
+        )
+    }
+
+    /// Creates a new `Duration` from the specified number of seconds
+    /// represented as `f32`. Any values that are out of bounds are saturated at
+    /// the minimum or maximum respectively. `NaN` gets turned into a `Duration`
+    /// of 0 seconds.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::saturating_seconds_f32(0.5), 0.5.seconds());
+    /// assert_eq!(Duration::saturating_seconds_f32(-0.5), (-0.5).seconds());
+    /// assert_eq!(
+    ///     Duration::saturating_seconds_f32(f32::NAN),
+    ///     Duration::new(0, 0),
+    /// );
+    /// assert_eq!(
+    ///     Duration::saturating_seconds_f32(f32::NEG_INFINITY),
+    ///     Duration::MIN,
+    /// );
+    /// assert_eq!(
+    ///     Duration::saturating_seconds_f32(f32::INFINITY),
+    ///     Duration::MAX,
+    /// );
+    /// ```
+    pub fn saturating_seconds_f32(seconds: f32) -> Self {
+        try_from_secs!(
+            secs = seconds,
+            mantissa_bits = 23,
+            exponent_bits = 8,
+            offset = 41,
+            bits_ty = u32,
+            bits_ty_signed = i32,
+            double_ty = u64,
+            float_ty = f32,
+            is_nan = return Self::ZERO,
+            is_overflow = return if seconds < 0.0 { Self::MIN } else { Self::MAX },
+        )
+    }
+
+    /// Creates a new `Duration` from the specified number of seconds
+    /// represented as `f64`. Returns `None` if the `Duration` can't be
+    /// represented.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::checked_seconds_f64(0.5), Some(0.5.seconds()));
+    /// assert_eq!(Duration::checked_seconds_f64(-0.5), Some((-0.5).seconds()));
+    /// assert_eq!(Duration::checked_seconds_f64(f64::NAN), None);
+    /// assert_eq!(Duration::checked_seconds_f64(f64::NEG_INFINITY), None);
+    /// assert_eq!(Duration::checked_seconds_f64(f64::INFINITY), None);
+    /// ```
+    pub fn checked_seconds_f64(seconds: f64) -> Option<Self> {
+        Some(try_from_secs!(
+            secs = seconds,
+            mantissa_bits = 52,
+            exponent_bits = 11,
+            offset = 44,
+            bits_ty = u64,
+            bits_ty_signed = i64,
+            double_ty = u128,
+            float_ty = f64,
+            is_nan = return None,
+            is_overflow = return None,
+        ))
+    }
+
+    /// Creates a new `Duration` from the specified number of seconds
+    /// represented as `f32`. Returns `None` if the `Duration` can't be
+    /// represented.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::checked_seconds_f32(0.5), Some(0.5.seconds()));
+    /// assert_eq!(Duration::checked_seconds_f32(-0.5), Some((-0.5).seconds()));
+    /// assert_eq!(Duration::checked_seconds_f32(f32::NAN), None);
+    /// assert_eq!(Duration::checked_seconds_f32(f32::NEG_INFINITY), None);
+    /// assert_eq!(Duration::checked_seconds_f32(f32::INFINITY), None);
+    /// ```
+    pub fn checked_seconds_f32(seconds: f32) -> Option<Self> {
+        Some(try_from_secs!(
+            secs = seconds,
+            mantissa_bits = 23,
+            exponent_bits = 8,
+            offset = 41,
+            bits_ty = u32,
+            bits_ty_signed = i32,
+            double_ty = u64,
+            float_ty = f32,
+            is_nan = return None,
+            is_overflow = return None,
+        ))
+    }
+
+    /// Create a new `Duration` with the given number of milliseconds.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::milliseconds(1), 1_000.microseconds());
+    /// assert_eq!(Duration::milliseconds(-1), (-1_000).microseconds());
+    /// ```
+    pub const fn milliseconds(milliseconds: i64) -> Self {
+        // Safety: `nanoseconds` is guaranteed to be in range because of the modulus.
+        unsafe {
+            Self::new_unchecked(
+                milliseconds / Millisecond::per(Second) as i64,
+                (milliseconds % Millisecond::per(Second) as i64
+                    * Nanosecond::per(Millisecond) as i64) as _,
+            )
+        }
+    }
+
+    /// Create a new `Duration` with the given number of microseconds.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::microseconds(1), 1_000.nanoseconds());
+    /// assert_eq!(Duration::microseconds(-1), (-1_000).nanoseconds());
+    /// ```
+    pub const fn microseconds(microseconds: i64) -> Self {
+        // Safety: `nanoseconds` is guaranteed to be in range because of the modulus.
+        unsafe {
+            Self::new_unchecked(
+                microseconds / Microsecond::per(Second) as i64,
+                (microseconds % Microsecond::per(Second) as i64
+                    * Nanosecond::per(Microsecond) as i64) as _,
+            )
+        }
+    }
+
+    /// Create a new `Duration` with the given number of nanoseconds.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(Duration::nanoseconds(1), 1.microseconds() / 1_000);
+    /// assert_eq!(Duration::nanoseconds(-1), (-1).microseconds() / 1_000);
+    /// ```
+    pub const fn nanoseconds(nanoseconds: i64) -> Self {
+        // Safety: `nanoseconds` is guaranteed to be in range because of the modulus.
+        unsafe {
+            Self::new_unchecked(
+                nanoseconds / Nanosecond::per(Second) as i64,
+                (nanoseconds % Nanosecond::per(Second) as i64) as _,
+            )
+        }
+    }
+
+    /// Create a new `Duration` with the given number of nanoseconds.
+    ///
+    /// As the input range cannot be fully mapped to the output, this should only be used where it's
+    /// known to result in a valid value.
+    pub(crate) const fn nanoseconds_i128(nanoseconds: i128) -> Self {
+        let seconds = nanoseconds / Nanosecond::per(Second) as i128;
+        let nanoseconds = nanoseconds % Nanosecond::per(Second) as i128;
+
+        if seconds > i64::MAX as i128 || seconds < i64::MIN as i128 {
+            crate::expect_failed("overflow constructing `time::Duration`");
+        }
+
+        // Safety: `nanoseconds` is guaranteed to be in range because of the modulus above.
+        unsafe { Self::new_unchecked(seconds as _, nanoseconds as _) }
+    }
+    // endregion constructors
+
+    // region: getters
+    /// Get the number of whole weeks in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.weeks().whole_weeks(), 1);
+    /// assert_eq!((-1).weeks().whole_weeks(), -1);
+    /// assert_eq!(6.days().whole_weeks(), 0);
+    /// assert_eq!((-6).days().whole_weeks(), 0);
+    /// ```
+    pub const fn whole_weeks(self) -> i64 {
+        self.whole_seconds() / Second::per(Week) as i64
+    }
+
+    /// Get the number of whole days in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.days().whole_days(), 1);
+    /// assert_eq!((-1).days().whole_days(), -1);
+    /// assert_eq!(23.hours().whole_days(), 0);
+    /// assert_eq!((-23).hours().whole_days(), 0);
+    /// ```
+    pub const fn whole_days(self) -> i64 {
+        self.whole_seconds() / Second::per(Day) as i64
+    }
+
+    /// Get the number of whole hours in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.hours().whole_hours(), 1);
+    /// assert_eq!((-1).hours().whole_hours(), -1);
+    /// assert_eq!(59.minutes().whole_hours(), 0);
+    /// assert_eq!((-59).minutes().whole_hours(), 0);
+    /// ```
+    pub const fn whole_hours(self) -> i64 {
+        self.whole_seconds() / Second::per(Hour) as i64
+    }
+
+    /// Get the number of whole minutes in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.minutes().whole_minutes(), 1);
+    /// assert_eq!((-1).minutes().whole_minutes(), -1);
+    /// assert_eq!(59.seconds().whole_minutes(), 0);
+    /// assert_eq!((-59).seconds().whole_minutes(), 0);
+    /// ```
+    pub const fn whole_minutes(self) -> i64 {
+        self.whole_seconds() / Second::per(Minute) as i64
+    }
+
+    /// Get the number of whole seconds in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.seconds().whole_seconds(), 1);
+    /// assert_eq!((-1).seconds().whole_seconds(), -1);
+    /// assert_eq!(1.minutes().whole_seconds(), 60);
+    /// assert_eq!((-1).minutes().whole_seconds(), -60);
+    /// ```
+    pub const fn whole_seconds(self) -> i64 {
+        self.seconds
+    }
+
+    /// Get the number of fractional seconds in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.5.seconds().as_seconds_f64(), 1.5);
+    /// assert_eq!((-1.5).seconds().as_seconds_f64(), -1.5);
+    /// ```
+    pub fn as_seconds_f64(self) -> f64 {
+        self.seconds as f64 + self.nanoseconds.get() as f64 / Nanosecond::per(Second) as f64
+    }
+
+    /// Get the number of fractional seconds in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.5.seconds().as_seconds_f32(), 1.5);
+    /// assert_eq!((-1.5).seconds().as_seconds_f32(), -1.5);
+    /// ```
+    pub fn as_seconds_f32(self) -> f32 {
+        self.seconds as f32 + self.nanoseconds.get() as f32 / Nanosecond::per(Second) as f32
+    }
+
+    /// Get the number of whole milliseconds in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.seconds().whole_milliseconds(), 1_000);
+    /// assert_eq!((-1).seconds().whole_milliseconds(), -1_000);
+    /// assert_eq!(1.milliseconds().whole_milliseconds(), 1);
+    /// assert_eq!((-1).milliseconds().whole_milliseconds(), -1);
+    /// ```
+    pub const fn whole_milliseconds(self) -> i128 {
+        self.seconds as i128 * Millisecond::per(Second) as i128
+            + self.nanoseconds.get() as i128 / Nanosecond::per(Millisecond) as i128
+    }
+
+    /// Get the number of milliseconds past the number of whole seconds.
+    ///
+    /// Always in the range `-999..=999`.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.4.seconds().subsec_milliseconds(), 400);
+    /// assert_eq!((-1.4).seconds().subsec_milliseconds(), -400);
+    /// ```
+    // Allow the lint, as the value is guaranteed to be less than 1000.
+    pub const fn subsec_milliseconds(self) -> i16 {
+        (self.nanoseconds.get() / Nanosecond::per(Millisecond) as i32) as _
+    }
+
+    /// Get the number of whole microseconds in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.milliseconds().whole_microseconds(), 1_000);
+    /// assert_eq!((-1).milliseconds().whole_microseconds(), -1_000);
+    /// assert_eq!(1.microseconds().whole_microseconds(), 1);
+    /// assert_eq!((-1).microseconds().whole_microseconds(), -1);
+    /// ```
+    pub const fn whole_microseconds(self) -> i128 {
+        self.seconds as i128 * Microsecond::per(Second) as i128
+            + self.nanoseconds.get() as i128 / Nanosecond::per(Microsecond) as i128
+    }
+
+    /// Get the number of microseconds past the number of whole seconds.
+    ///
+    /// Always in the range `-999_999..=999_999`.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.0004.seconds().subsec_microseconds(), 400);
+    /// assert_eq!((-1.0004).seconds().subsec_microseconds(), -400);
+    /// ```
+    pub const fn subsec_microseconds(self) -> i32 {
+        self.nanoseconds.get() / Nanosecond::per(Microsecond) as i32
+    }
+
+    /// Get the number of nanoseconds in the duration.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.microseconds().whole_nanoseconds(), 1_000);
+    /// assert_eq!((-1).microseconds().whole_nanoseconds(), -1_000);
+    /// assert_eq!(1.nanoseconds().whole_nanoseconds(), 1);
+    /// assert_eq!((-1).nanoseconds().whole_nanoseconds(), -1);
+    /// ```
+    pub const fn whole_nanoseconds(self) -> i128 {
+        self.seconds as i128 * Nanosecond::per(Second) as i128 + self.nanoseconds.get() as i128
+    }
+
+    /// Get the number of nanoseconds past the number of whole seconds.
+    ///
+    /// The returned value will always be in the range `-999_999_999..=999_999_999`.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(1.000_000_400.seconds().subsec_nanoseconds(), 400);
+    /// assert_eq!((-1.000_000_400).seconds().subsec_nanoseconds(), -400);
+    /// ```
+    pub const fn subsec_nanoseconds(self) -> i32 {
+        self.nanoseconds.get()
+    }
+
+    /// Get the number of nanoseconds past the number of whole seconds.
+    #[cfg(feature = "quickcheck")]
+    pub(crate) const fn subsec_nanoseconds_ranged(self) -> Nanoseconds {
+        self.nanoseconds
+    }
+    // endregion getters
+
+    // region: checked arithmetic
+    /// Computes `self + rhs`, returning `None` if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(5.seconds().checked_add(5.seconds()), Some(10.seconds()));
+    /// assert_eq!(Duration::MAX.checked_add(1.nanoseconds()), None);
+    /// assert_eq!((-5).seconds().checked_add(5.seconds()), Some(0.seconds()));
+    /// ```
+    pub const fn checked_add(self, rhs: Self) -> Option<Self> {
+        let mut seconds = const_try_opt!(self.seconds.checked_add(rhs.seconds));
+        let mut nanoseconds = self.nanoseconds.get() + rhs.nanoseconds.get();
+
+        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+            nanoseconds -= Nanosecond::per(Second) as i32;
+            seconds = const_try_opt!(seconds.checked_add(1));
+        } else if nanoseconds <= -(Nanosecond::per(Second) as i32) || seconds > 0 && nanoseconds < 0
+        {
+            nanoseconds += Nanosecond::per(Second) as i32;
+            seconds = const_try_opt!(seconds.checked_sub(1));
+        }
+
+        // Safety: `nanoseconds` is guaranteed to be in range because of the overflow handling.
+        unsafe { Some(Self::new_unchecked(seconds, nanoseconds)) }
+    }
+
+    /// Computes `self - rhs`, returning `None` if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(5.seconds().checked_sub(5.seconds()), Some(Duration::ZERO));
+    /// assert_eq!(Duration::MIN.checked_sub(1.nanoseconds()), None);
+    /// assert_eq!(5.seconds().checked_sub(10.seconds()), Some((-5).seconds()));
+    /// ```
+    pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
+        let mut seconds = const_try_opt!(self.seconds.checked_sub(rhs.seconds));
+        let mut nanoseconds = self.nanoseconds.get() - rhs.nanoseconds.get();
+
+        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+            nanoseconds -= Nanosecond::per(Second) as i32;
+            seconds = const_try_opt!(seconds.checked_add(1));
+        } else if nanoseconds <= -(Nanosecond::per(Second) as i32) || seconds > 0 && nanoseconds < 0
+        {
+            nanoseconds += Nanosecond::per(Second) as i32;
+            seconds = const_try_opt!(seconds.checked_sub(1));
+        }
+
+        // Safety: `nanoseconds` is guaranteed to be in range because of the overflow handling.
+        unsafe { Some(Self::new_unchecked(seconds, nanoseconds)) }
+    }
+
+    /// Computes `self * rhs`, returning `None` if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(5.seconds().checked_mul(2), Some(10.seconds()));
+    /// assert_eq!(5.seconds().checked_mul(-2), Some((-10).seconds()));
+    /// assert_eq!(5.seconds().checked_mul(0), Some(0.seconds()));
+    /// assert_eq!(Duration::MAX.checked_mul(2), None);
+    /// assert_eq!(Duration::MIN.checked_mul(2), None);
+    /// ```
+    pub const fn checked_mul(self, rhs: i32) -> Option<Self> {
+        // Multiply nanoseconds as i64, because it cannot overflow that way.
+        let total_nanos = self.nanoseconds.get() as i64 * rhs as i64;
+        let extra_secs = total_nanos / Nanosecond::per(Second) as i64;
+        let nanoseconds = (total_nanos % Nanosecond::per(Second) as i64) as _;
+        let seconds = const_try_opt!(
+            const_try_opt!(self.seconds.checked_mul(rhs as _)).checked_add(extra_secs)
+        );
+
+        // Safety: `nanoseconds` is guaranteed to be in range because of the modulus above.
+        unsafe { Some(Self::new_unchecked(seconds, nanoseconds)) }
+    }
+
+    /// Computes `self / rhs`, returning `None` if `rhs == 0` or if the result would overflow.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// assert_eq!(10.seconds().checked_div(2), Some(5.seconds()));
+    /// assert_eq!(10.seconds().checked_div(-2), Some((-5).seconds()));
+    /// assert_eq!(1.seconds().checked_div(0), None);
+    /// ```
+    pub const fn checked_div(self, rhs: i32) -> Option<Self> {
+        let (secs, extra_secs) = (
+            const_try_opt!(self.seconds.checked_div(rhs as i64)),
+            self.seconds % (rhs as i64),
+        );
+        let (mut nanos, extra_nanos) = (self.nanoseconds.get() / rhs, self.nanoseconds.get() % rhs);
+        nanos += ((extra_secs * (Nanosecond::per(Second) as i64) + extra_nanos as i64)
+            / (rhs as i64)) as i32;
+
+        // Safety: `nanoseconds` is in range.
+        unsafe { Some(Self::new_unchecked(secs, nanos)) }
+    }
+
+    /// Computes `-self`, returning `None` if the result would overflow.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// # use time::Duration;
+    /// assert_eq!(5.seconds().checked_neg(), Some((-5).seconds()));
+    /// assert_eq!(Duration::MIN.checked_neg(), None);
+    /// ```
+    pub const fn checked_neg(self) -> Option<Self> {
+        if self.seconds == i64::MIN {
+            None
+        } else {
+            Some(Self::new_ranged_unchecked(
+                -self.seconds,
+                self.nanoseconds.neg(),
+            ))
+        }
+    }
+    // endregion checked arithmetic
+
+    // region: saturating arithmetic
+    /// Computes `self + rhs`, saturating if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(5.seconds().saturating_add(5.seconds()), 10.seconds());
+    /// assert_eq!(Duration::MAX.saturating_add(1.nanoseconds()), Duration::MAX);
+    /// assert_eq!(
+    ///     Duration::MIN.saturating_add((-1).nanoseconds()),
+    ///     Duration::MIN
+    /// );
+    /// assert_eq!((-5).seconds().saturating_add(5.seconds()), Duration::ZERO);
+    /// ```
+    pub const fn saturating_add(self, rhs: Self) -> Self {
+        let (mut seconds, overflow) = self.seconds.overflowing_add(rhs.seconds);
+        if overflow {
+            if self.seconds > 0 {
+                return Self::MAX;
+            }
+            return Self::MIN;
+        }
+        let mut nanoseconds = self.nanoseconds.get() + rhs.nanoseconds.get();
+
+        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+            nanoseconds -= Nanosecond::per(Second) as i32;
+            seconds = match seconds.checked_add(1) {
+                Some(seconds) => seconds,
+                None => return Self::MAX,
+            };
+        } else if nanoseconds <= -(Nanosecond::per(Second) as i32) || seconds > 0 && nanoseconds < 0
+        {
+            nanoseconds += Nanosecond::per(Second) as i32;
+            seconds = match seconds.checked_sub(1) {
+                Some(seconds) => seconds,
+                None => return Self::MIN,
+            };
+        }
+
+        // Safety: `nanoseconds` is guaranteed to be in range because of the overflow handling.
+        unsafe { Self::new_unchecked(seconds, nanoseconds) }
+    }
+
+    /// Computes `self - rhs`, saturating if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(5.seconds().saturating_sub(5.seconds()), Duration::ZERO);
+    /// assert_eq!(Duration::MIN.saturating_sub(1.nanoseconds()), Duration::MIN);
+    /// assert_eq!(
+    ///     Duration::MAX.saturating_sub((-1).nanoseconds()),
+    ///     Duration::MAX
+    /// );
+    /// assert_eq!(5.seconds().saturating_sub(10.seconds()), (-5).seconds());
+    /// ```
+    pub const fn saturating_sub(self, rhs: Self) -> Self {
+        let (mut seconds, overflow) = self.seconds.overflowing_sub(rhs.seconds);
+        if overflow {
+            if self.seconds > 0 {
+                return Self::MAX;
+            }
+            return Self::MIN;
+        }
+        let mut nanoseconds = self.nanoseconds.get() - rhs.nanoseconds.get();
+
+        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+            nanoseconds -= Nanosecond::per(Second) as i32;
+            seconds = match seconds.checked_add(1) {
+                Some(seconds) => seconds,
+                None => return Self::MAX,
+            };
+        } else if nanoseconds <= -(Nanosecond::per(Second) as i32) || seconds > 0 && nanoseconds < 0
+        {
+            nanoseconds += Nanosecond::per(Second) as i32;
+            seconds = match seconds.checked_sub(1) {
+                Some(seconds) => seconds,
+                None => return Self::MIN,
+            };
+        }
+
+        // Safety: `nanoseconds` is guaranteed to be in range because of the overflow handling.
+        unsafe { Self::new_unchecked(seconds, nanoseconds) }
+    }
+
+    /// Computes `self * rhs`, saturating if an overflow occurred.
+    ///
+    /// ```rust
+    /// # use time::{Duration, ext::NumericalDuration};
+    /// assert_eq!(5.seconds().saturating_mul(2), 10.seconds());
+    /// assert_eq!(5.seconds().saturating_mul(-2), (-10).seconds());
+    /// assert_eq!(5.seconds().saturating_mul(0), Duration::ZERO);
+    /// assert_eq!(Duration::MAX.saturating_mul(2), Duration::MAX);
+    /// assert_eq!(Duration::MIN.saturating_mul(2), Duration::MIN);
+    /// assert_eq!(Duration::MAX.saturating_mul(-2), Duration::MIN);
+    /// assert_eq!(Duration::MIN.saturating_mul(-2), Duration::MAX);
+    /// ```
+    pub const fn saturating_mul(self, rhs: i32) -> Self {
+        // Multiply nanoseconds as i64, because it cannot overflow that way.
+        let total_nanos = self.nanoseconds.get() as i64 * rhs as i64;
+        let extra_secs = total_nanos / Nanosecond::per(Second) as i64;
+        let nanoseconds = (total_nanos % Nanosecond::per(Second) as i64) as _;
+        let (seconds, overflow1) = self.seconds.overflowing_mul(rhs as _);
+        if overflow1 {
+            if self.seconds > 0 && rhs > 0 || self.seconds < 0 && rhs < 0 {
+                return Self::MAX;
+            }
+            return Self::MIN;
+        }
+        let (seconds, overflow2) = seconds.overflowing_add(extra_secs);
+        if overflow2 {
+            if self.seconds > 0 && rhs > 0 {
+                return Self::MAX;
+            }
+            return Self::MIN;
+        }
+
+        // Safety: `nanoseconds` is guaranteed to be in range because of to the modulus above.
+        unsafe { Self::new_unchecked(seconds, nanoseconds) }
+    }
+    // endregion saturating arithmetic
+
+    /// Runs a closure, returning the duration of time it took to run. The return value of the
+    /// closure is provided in the second part of the tuple.
+    #[cfg(feature = "std")]
+    #[deprecated(
+        since = "0.3.32",
+        note = "extremely limited use case, not intended for benchmarking"
+    )]
+    #[allow(deprecated)]
+    pub fn time_fn<T>(f: impl FnOnce() -> T) -> (Self, T) {
+        let start = Instant::now();
+        let return_value = f();
+        let end = Instant::now();
+
+        (end - start, return_value)
+    }
+}
+
+// region: trait impls
+/// The format returned by this implementation is not stable and must not be relied upon.
+///
+/// By default this produces an exact, full-precision printout of the duration.
+/// For a concise, rounded printout instead, you can use the `.N` format specifier:
+///
+/// ```
+/// # use time::Duration;
+/// #
+/// let duration = Duration::new(123456, 789011223);
+/// println!("{duration:.3}");
+/// ```
+///
+/// For the purposes of this implementation, a day is exactly 24 hours and a minute is exactly 60
+/// seconds.
+impl fmt::Display for Duration {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.is_negative() {
+            f.write_str("-")?;
+        }
+
+        if let Some(_precision) = f.precision() {
+            // Concise, rounded representation.
+
+            if self.is_zero() {
+                // Write a zero value with the requested precision.
+                return (0.).fmt(f).and_then(|_| f.write_str("s"));
+            }
+
+            /// Format the first item that produces a value greater than 1 and then break.
+            macro_rules! item {
+                ($name:literal, $value:expr) => {
+                    let value = $value;
+                    if value >= 1.0 {
+                        return value.fmt(f).and_then(|_| f.write_str($name));
+                    }
+                };
+            }
+
+            // Even if this produces a de-normal float, because we're rounding we don't really care.
+            let seconds = self.unsigned_abs().as_secs_f64();
+
+            item!("d", seconds / Second::per(Day) as f64);
+            item!("h", seconds / Second::per(Hour) as f64);
+            item!("m", seconds / Second::per(Minute) as f64);
+            item!("s", seconds);
+            item!("ms", seconds * Millisecond::per(Second) as f64);
+            item!("µs", seconds * Microsecond::per(Second) as f64);
+            item!("ns", seconds * Nanosecond::per(Second) as f64);
+        } else {
+            // Precise, but verbose representation.
+
+            if self.is_zero() {
+                return f.write_str("0s");
+            }
+
+            /// Format a single item.
+            macro_rules! item {
+                ($name:literal, $value:expr) => {
+                    match $value {
+                        0 => Ok(()),
+                        value => value.fmt(f).and_then(|_| f.write_str($name)),
+                    }
+                };
+            }
+
+            let seconds = self.seconds.unsigned_abs();
+            let nanoseconds = self.nanoseconds.get().unsigned_abs();
+
+            item!("d", seconds / Second::per(Day).extend::<u64>())?;
+            item!(
+                "h",
+                seconds / Second::per(Hour).extend::<u64>() % Hour::per(Day).extend::<u64>()
+            )?;
+            item!(
+                "m",
+                seconds / Second::per(Minute).extend::<u64>() % Minute::per(Hour).extend::<u64>()
+            )?;
+            item!("s", seconds % Second::per(Minute).extend::<u64>())?;
+            item!("ms", nanoseconds / Nanosecond::per(Millisecond))?;
+            item!(
+                "µs",
+                nanoseconds / Nanosecond::per(Microsecond).extend::<u32>()
+                    % Microsecond::per(Millisecond).extend::<u32>()
+            )?;
+            item!(
+                "ns",
+                nanoseconds % Nanosecond::per(Microsecond).extend::<u32>()
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+impl TryFrom<StdDuration> for Duration {
+    type Error = error::ConversionRange;
+
+    fn try_from(original: StdDuration) -> Result<Self, error::ConversionRange> {
+        Ok(Self::new(
+            original
+                .as_secs()
+                .try_into()
+                .map_err(|_| error::ConversionRange)?,
+            original.subsec_nanos().cast_signed(),
+        ))
+    }
+}
+
+impl TryFrom<Duration> for StdDuration {
+    type Error = error::ConversionRange;
+
+    fn try_from(duration: Duration) -> Result<Self, error::ConversionRange> {
+        Ok(Self::new(
+            duration
+                .seconds
+                .try_into()
+                .map_err(|_| error::ConversionRange)?,
+            duration
+                .nanoseconds
+                .get()
+                .try_into()
+                .map_err(|_| error::ConversionRange)?,
+        ))
+    }
+}
+
+impl Add for Duration {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, rhs: Self) -> Self::Output {
+        self.checked_add(rhs)
+            .expect("overflow when adding durations")
+    }
+}
+
+impl Add<StdDuration> for Duration {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, std_duration: StdDuration) -> Self::Output {
+        self + Self::try_from(std_duration)
+            .expect("overflow converting `std::time::Duration` to `time::Duration`")
+    }
+}
+
+impl Add<Duration> for StdDuration {
+    type Output = Duration;
+
+    fn add(self, rhs: Duration) -> Self::Output {
+        rhs + self
+    }
+}
+
+impl_add_assign!(Duration: Self, StdDuration);
+
+impl AddAssign<Duration> for StdDuration {
+    /// # Panics
+    ///
+    /// This may panic if the resulting addition cannot be represented.
+    fn add_assign(&mut self, rhs: Duration) {
+        *self = (*self + rhs).try_into().expect(
+            "Cannot represent a resulting duration in std. Try `let x = x + rhs;`, which will \
+             change the type.",
+        );
+    }
+}
+
+impl Neg for Duration {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        self.checked_neg().expect("overflow when negating duration")
+    }
+}
+
+impl Sub for Duration {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: Self) -> Self::Output {
+        self.checked_sub(rhs)
+            .expect("overflow when subtracting durations")
+    }
+}
+
+impl Sub<StdDuration> for Duration {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: StdDuration) -> Self::Output {
+        self - Self::try_from(rhs)
+            .expect("overflow converting `std::time::Duration` to `time::Duration`")
+    }
+}
+
+impl Sub<Duration> for StdDuration {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: Duration) -> Self::Output {
+        Duration::try_from(self)
+            .expect("overflow converting `std::time::Duration` to `time::Duration`")
+            - rhs
+    }
+}
+
+impl_sub_assign!(Duration: Self, StdDuration);
+
+impl SubAssign<Duration> for StdDuration {
+    /// # Panics
+    ///
+    /// This may panic if the resulting subtraction can not be represented.
+    fn sub_assign(&mut self, rhs: Duration) {
+        *self = (*self - rhs).try_into().expect(
+            "Cannot represent a resulting duration in std. Try `let x = x - rhs;`, which will \
+             change the type.",
+        );
+    }
+}
+
+/// Implement `Mul` (reflexively) and `Div` for `Duration` for various types.
+macro_rules! duration_mul_div_int {
+    ($($type:ty),+) => {$(
+        impl Mul<$type> for Duration {
+            type Output = Self;
+
+            fn mul(self, rhs: $type) -> Self::Output {
+                Self::nanoseconds_i128(
+                    self.whole_nanoseconds()
+                        .checked_mul(rhs.cast_signed().extend::<i128>())
+                        .expect("overflow when multiplying duration")
+                )
+            }
+        }
+
+        impl Mul<Duration> for $type {
+            type Output = Duration;
+
+            fn mul(self, rhs: Duration) -> Self::Output {
+                rhs * self
+            }
+        }
+
+        impl Div<$type> for Duration {
+            type Output = Self;
+
+            fn div(self, rhs: $type) -> Self::Output {
+                Self::nanoseconds_i128(
+                    self.whole_nanoseconds() / rhs.cast_signed().extend::<i128>()
+                )
+            }
+        }
+    )+};
+}
+duration_mul_div_int![i8, i16, i32, u8, u16, u32];
+
+impl Mul<f32> for Duration {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Self::seconds_f32(self.as_seconds_f32() * rhs)
+    }
+}
+
+impl Mul<Duration> for f32 {
+    type Output = Duration;
+
+    fn mul(self, rhs: Duration) -> Self::Output {
+        rhs * self
+    }
+}
+
+impl Mul<f64> for Duration {
+    type Output = Self;
+
+    fn mul(self, rhs: f64) -> Self::Output {
+        Self::seconds_f64(self.as_seconds_f64() * rhs)
+    }
+}
+
+impl Mul<Duration> for f64 {
+    type Output = Duration;
+
+    fn mul(self, rhs: Duration) -> Self::Output {
+        rhs * self
+    }
+}
+
+impl_mul_assign!(Duration: i8, i16, i32, u8, u16, u32, f32, f64);
+
+impl Div<f32> for Duration {
+    type Output = Self;
+
+    fn div(self, rhs: f32) -> Self::Output {
+        Self::seconds_f32(self.as_seconds_f32() / rhs)
+    }
+}
+
+impl Div<f64> for Duration {
+    type Output = Self;
+
+    fn div(self, rhs: f64) -> Self::Output {
+        Self::seconds_f64(self.as_seconds_f64() / rhs)
+    }
+}
+
+impl_div_assign!(Duration: i8, i16, i32, u8, u16, u32, f32, f64);
+
+impl Div for Duration {
+    type Output = f64;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        self.as_seconds_f64() / rhs.as_seconds_f64()
+    }
+}
+
+impl Div<StdDuration> for Duration {
+    type Output = f64;
+
+    fn div(self, rhs: StdDuration) -> Self::Output {
+        self.as_seconds_f64() / rhs.as_secs_f64()
+    }
+}
+
+impl Div<Duration> for StdDuration {
+    type Output = f64;
+
+    fn div(self, rhs: Duration) -> Self::Output {
+        self.as_secs_f64() / rhs.as_seconds_f64()
+    }
+}
+
+impl PartialEq<StdDuration> for Duration {
+    fn eq(&self, rhs: &StdDuration) -> bool {
+        Ok(*self) == Self::try_from(*rhs)
+    }
+}
+
+impl PartialEq<Duration> for StdDuration {
+    fn eq(&self, rhs: &Duration) -> bool {
+        rhs == self
+    }
+}
+
+impl PartialOrd<StdDuration> for Duration {
+    fn partial_cmp(&self, rhs: &StdDuration) -> Option<Ordering> {
+        if rhs.as_secs() > i64::MAX.cast_unsigned() {
+            return Some(Ordering::Less);
+        }
+
+        Some(
+            self.seconds
+                .cmp(&rhs.as_secs().cast_signed())
+                .then_with(|| {
+                    self.nanoseconds
+                        .get()
+                        .cmp(&rhs.subsec_nanos().cast_signed())
+                }),
+        )
+    }
+}
+
+impl PartialOrd<Duration> for StdDuration {
+    fn partial_cmp(&self, rhs: &Duration) -> Option<Ordering> {
+        rhs.partial_cmp(self).map(Ordering::reverse)
+    }
+}
+
+impl Sum for Duration {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.reduce(|a, b| a + b).unwrap_or_default()
+    }
+}
+
+impl<'a> Sum<&'a Self> for Duration {
+    fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
+        iter.copied().sum()
+    }
+}
+// endregion trait impls
diff --git a/time/src/error/component_range.rs b/time/src/error/component_range.rs
new file mode 100644
index 000000000..8a6e605ed
--- /dev/null
+++ b/time/src/error/component_range.rs
@@ -0,0 +1,93 @@
+//! Component range error
+
+use core::fmt;
+
+use crate::error;
+
+/// An error type indicating that a component provided to a method was out of range, causing a
+/// failure.
+// i64 is the narrowest type fitting all use cases. This eliminates the need for a type parameter.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ComponentRange {
+    /// Name of the component.
+    pub(crate) name: &'static str,
+    /// Minimum allowed value, inclusive.
+    pub(crate) minimum: i64,
+    /// Maximum allowed value, inclusive.
+    pub(crate) maximum: i64,
+    /// Value that was provided.
+    pub(crate) value: i64,
+    /// The minimum and/or maximum value is conditional on the value of other
+    /// parameters.
+    pub(crate) conditional_range: bool,
+}
+
+impl ComponentRange {
+    /// Obtain the name of the component whose value was out of range.
+    pub const fn name(self) -> &'static str {
+        self.name
+    }
+
+    /// Whether the value's permitted range is conditional, i.e. whether an input with this
+    /// value could have succeeded if the values of other components were different.
+    pub const fn is_conditional(self) -> bool {
+        self.conditional_range
+    }
+}
+
+impl fmt::Display for ComponentRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} must be in the range {}..={}",
+            self.name, self.minimum, self.maximum
+        )?;
+
+        if self.conditional_range {
+            f.write_str(", given values of other parameters")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl From<ComponentRange> for crate::Error {
+    fn from(original: ComponentRange) -> Self {
+        Self::ComponentRange(original)
+    }
+}
+
+impl TryFrom<crate::Error> for ComponentRange {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::ComponentRange(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+/// **This trait implementation is deprecated and will be removed in a future breaking release.**
+#[cfg(feature = "serde")]
+impl serde::de::Expected for ComponentRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "a value in the range {}..={}",
+            self.minimum, self.maximum
+        )
+    }
+}
+
+#[cfg(feature = "serde")]
+impl ComponentRange {
+    /// Convert the error to a deserialization error.
+    pub(crate) fn into_de_error<E: serde::de::Error>(self) -> E {
+        E::invalid_value(serde::de::Unexpected::Signed(self.value), &self)
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for ComponentRange {}
diff --git a/time/src/error/conversion_range.rs b/time/src/error/conversion_range.rs
new file mode 100644
index 000000000..c97c4db2d
--- /dev/null
+++ b/time/src/error/conversion_range.rs
@@ -0,0 +1,37 @@
+//! Conversion range error
+
+use core::fmt;
+
+use crate::error;
+
+/// An error type indicating that a conversion failed because the target type could not store the
+/// initial value.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ConversionRange;
+
+impl fmt::Display for ConversionRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("Source value is out of range for the target type")
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for ConversionRange {}
+
+impl From<ConversionRange> for crate::Error {
+    fn from(err: ConversionRange) -> Self {
+        Self::ConversionRange(err)
+    }
+}
+
+impl TryFrom<crate::Error> for ConversionRange {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::ConversionRange(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
diff --git a/time/src/error/different_variant.rs b/time/src/error/different_variant.rs
new file mode 100644
index 000000000..873eb489e
--- /dev/null
+++ b/time/src/error/different_variant.rs
@@ -0,0 +1,35 @@
+//! Different variant error
+
+use core::fmt;
+
+/// An error type indicating that a [`TryFrom`](core::convert::TryFrom) call failed because the
+/// original value was of a different variant.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DifferentVariant;
+
+impl fmt::Display for DifferentVariant {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "value was of a different variant than required")
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for DifferentVariant {}
+
+impl From<DifferentVariant> for crate::Error {
+    fn from(err: DifferentVariant) -> Self {
+        Self::DifferentVariant(err)
+    }
+}
+
+impl TryFrom<crate::Error> for DifferentVariant {
+    type Error = Self;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::DifferentVariant(err) => Ok(err),
+            _ => Err(Self),
+        }
+    }
+}
diff --git a/time/src/error/format.rs b/time/src/error/format.rs
new file mode 100644
index 000000000..ad199baa5
--- /dev/null
+++ b/time/src/error/format.rs
@@ -0,0 +1,93 @@
+//! Error formatting a struct
+
+use core::fmt;
+use std::io;
+
+use crate::error;
+
+/// An error occurred when formatting.
+#[non_exhaustive]
+#[allow(missing_copy_implementations)]
+#[derive(Debug)]
+pub enum Format {
+    /// The type being formatted does not contain sufficient information to format a component.
+    #[non_exhaustive]
+    InsufficientTypeInformation,
+    /// The component named has a value that cannot be formatted into the requested format.
+    ///
+    /// This variant is only returned when using well-known formats.
+    InvalidComponent(&'static str),
+    /// A value of `std::io::Error` was returned internally.
+    StdIo(io::Error),
+}
+
+impl fmt::Display for Format {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InsufficientTypeInformation => f.write_str(
+                "The type being formatted does not contain sufficient information to format a \
+                 component.",
+            ),
+            Self::InvalidComponent(component) => write!(
+                f,
+                "The {component} component cannot be formatted into the requested format."
+            ),
+            Self::StdIo(err) => err.fmt(f),
+        }
+    }
+}
+
+impl From<io::Error> for Format {
+    fn from(err: io::Error) -> Self {
+        Self::StdIo(err)
+    }
+}
+
+impl TryFrom<Format> for io::Error {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: Format) -> Result<Self, Self::Error> {
+        match err {
+            Format::StdIo(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for Format {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::InsufficientTypeInformation | Self::InvalidComponent(_) => None,
+            Self::StdIo(ref err) => Some(err),
+        }
+    }
+}
+
+impl From<Format> for crate::Error {
+    fn from(original: Format) -> Self {
+        Self::Format(original)
+    }
+}
+
+impl TryFrom<crate::Error> for Format {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::Format(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Format {
+    /// Obtain an error type for the serializer.
+    #[doc(hidden)] // Exposed only for the `declare_format_string` macro
+    pub fn into_invalid_serde_value<S: serde::Serializer>(self) -> S::Error {
+        use serde::ser::Error;
+        S::Error::custom(self)
+    }
+}
diff --git a/time/src/error/indeterminate_offset.rs b/time/src/error/indeterminate_offset.rs
new file mode 100644
index 000000000..89f10b4a7
--- /dev/null
+++ b/time/src/error/indeterminate_offset.rs
@@ -0,0 +1,36 @@
+//! Indeterminate offset
+
+use core::fmt;
+
+use crate::error;
+
+/// The system's UTC offset could not be determined at the given datetime.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct IndeterminateOffset;
+
+impl fmt::Display for IndeterminateOffset {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("The system's UTC offset could not be determined")
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for IndeterminateOffset {}
+
+impl From<IndeterminateOffset> for crate::Error {
+    fn from(err: IndeterminateOffset) -> Self {
+        Self::IndeterminateOffset(err)
+    }
+}
+
+impl TryFrom<crate::Error> for IndeterminateOffset {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::IndeterminateOffset(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
diff --git a/time/src/error/invalid_format_description.rs b/time/src/error/invalid_format_description.rs
new file mode 100644
index 000000000..b2f5b7bda
--- /dev/null
+++ b/time/src/error/invalid_format_description.rs
@@ -0,0 +1,129 @@
+//! Invalid format description
+
+use alloc::string::String;
+use core::fmt;
+
+use crate::error;
+
+/// The format description provided was not valid.
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum InvalidFormatDescription {
+    /// There was a bracket pair that was opened but not closed.
+    #[non_exhaustive]
+    UnclosedOpeningBracket {
+        /// The zero-based index of the opening bracket.
+        index: usize,
+    },
+    /// A component name is not valid.
+    #[non_exhaustive]
+    InvalidComponentName {
+        /// The name of the invalid component name.
+        name: String,
+        /// The zero-based index the component name starts at.
+        index: usize,
+    },
+    /// A modifier is not valid.
+    #[non_exhaustive]
+    InvalidModifier {
+        /// The value of the invalid modifier.
+        value: String,
+        /// The zero-based index the modifier starts at.
+        index: usize,
+    },
+    /// A component name is missing.
+    #[non_exhaustive]
+    MissingComponentName {
+        /// The zero-based index where the component name should start.
+        index: usize,
+    },
+    /// A required modifier is missing.
+    #[non_exhaustive]
+    MissingRequiredModifier {
+        /// The name of the modifier that is missing.
+        name: &'static str,
+        /// The zero-based index of the component.
+        index: usize,
+    },
+    /// Something was expected, but not found.
+    #[non_exhaustive]
+    Expected {
+        /// What was expected to be present, but wasn't.
+        what: &'static str,
+        /// The zero-based index the item was expected to be found at.
+        index: usize,
+    },
+    /// Certain behavior is not supported in the given context.
+    #[non_exhaustive]
+    NotSupported {
+        /// The behavior that is not supported.
+        what: &'static str,
+        /// The context in which the behavior is not supported.
+        context: &'static str,
+        /// The zero-based index the error occurred at.
+        index: usize,
+    },
+}
+
+impl From<InvalidFormatDescription> for crate::Error {
+    fn from(original: InvalidFormatDescription) -> Self {
+        Self::InvalidFormatDescription(original)
+    }
+}
+
+impl TryFrom<crate::Error> for InvalidFormatDescription {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::InvalidFormatDescription(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+impl fmt::Display for InvalidFormatDescription {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use InvalidFormatDescription::*;
+        match self {
+            UnclosedOpeningBracket { index } => {
+                write!(f, "unclosed opening bracket at byte index {index}")
+            }
+            InvalidComponentName { name, index } => {
+                write!(f, "invalid component name `{name}` at byte index {index}")
+            }
+            InvalidModifier { value, index } => {
+                write!(f, "invalid modifier `{value}` at byte index {index}")
+            }
+            MissingComponentName { index } => {
+                write!(f, "missing component name at byte index {index}")
+            }
+            MissingRequiredModifier { name, index } => {
+                write!(
+                    f,
+                    "missing required modifier `{name}` for component at byte index {index}"
+                )
+            }
+            Expected {
+                what: expected,
+                index,
+            } => {
+                write!(f, "expected {expected} at byte index {index}")
+            }
+            NotSupported {
+                what,
+                context,
+                index,
+            } => {
+                write!(
+                    f,
+                    "{what} is not supported in {context} at byte index {index}"
+                )
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for InvalidFormatDescription {}
diff --git a/time/src/error/invalid_variant.rs b/time/src/error/invalid_variant.rs
new file mode 100644
index 000000000..7c2426b60
--- /dev/null
+++ b/time/src/error/invalid_variant.rs
@@ -0,0 +1,35 @@
+//! Invalid variant error
+
+use core::fmt;
+
+/// An error type indicating that a [`FromStr`](core::str::FromStr) call failed because the value
+/// was not a valid variant.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct InvalidVariant;
+
+impl fmt::Display for InvalidVariant {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "value was not a valid variant")
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for InvalidVariant {}
+
+impl From<InvalidVariant> for crate::Error {
+    fn from(err: InvalidVariant) -> Self {
+        Self::InvalidVariant(err)
+    }
+}
+
+impl TryFrom<crate::Error> for InvalidVariant {
+    type Error = crate::error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::InvalidVariant(err) => Ok(err),
+            _ => Err(crate::error::DifferentVariant),
+        }
+    }
+}
diff --git a/time/src/error/mod.rs b/time/src/error/mod.rs
new file mode 100644
index 000000000..8ee6b8481
--- /dev/null
+++ b/time/src/error/mod.rs
@@ -0,0 +1,131 @@
+//! Various error types returned by methods in the time crate.
+
+mod component_range;
+mod conversion_range;
+mod different_variant;
+#[cfg(feature = "formatting")]
+mod format;
+#[cfg(feature = "local-offset")]
+mod indeterminate_offset;
+#[cfg(all(any(feature = "formatting", feature = "parsing"), feature = "alloc"))]
+mod invalid_format_description;
+mod invalid_variant;
+#[cfg(feature = "parsing")]
+mod parse;
+#[cfg(feature = "parsing")]
+mod parse_from_description;
+#[cfg(feature = "parsing")]
+mod try_from_parsed;
+
+use core::fmt;
+
+pub use component_range::ComponentRange;
+pub use conversion_range::ConversionRange;
+pub use different_variant::DifferentVariant;
+#[cfg(feature = "formatting")]
+pub use format::Format;
+#[cfg(feature = "local-offset")]
+pub use indeterminate_offset::IndeterminateOffset;
+#[cfg(all(any(feature = "formatting", feature = "parsing"), feature = "alloc"))]
+pub use invalid_format_description::InvalidFormatDescription;
+pub use invalid_variant::InvalidVariant;
+#[cfg(feature = "parsing")]
+pub use parse::Parse;
+#[cfg(feature = "parsing")]
+pub use parse_from_description::ParseFromDescription;
+#[cfg(feature = "parsing")]
+pub use try_from_parsed::TryFromParsed;
+
+#[cfg(feature = "parsing")]
+use crate::internal_macros::bug;
+
+/// A unified error type for anything returned by a method in the time crate.
+///
+/// This can be used when you either don't know or don't care about the exact error returned.
+/// `Result<_, time::Error>` (or its alias `time::Result<_>`) will work in these situations.
+#[allow(missing_copy_implementations, variant_size_differences)]
+#[non_exhaustive]
+#[derive(Debug)]
+pub enum Error {
+    #[allow(missing_docs)]
+    ConversionRange(ConversionRange),
+    #[allow(missing_docs)]
+    ComponentRange(ComponentRange),
+    #[cfg(feature = "local-offset")]
+    #[allow(missing_docs)]
+    IndeterminateOffset(IndeterminateOffset),
+    #[cfg(feature = "formatting")]
+    #[allow(missing_docs)]
+    Format(Format),
+    #[cfg(feature = "parsing")]
+    #[allow(missing_docs)]
+    ParseFromDescription(ParseFromDescription),
+    #[cfg(feature = "parsing")]
+    #[allow(missing_docs)]
+    #[non_exhaustive]
+    #[deprecated(
+        since = "0.3.28",
+        note = "no longer output. moved to the `ParseFromDescription` variant"
+    )]
+    UnexpectedTrailingCharacters,
+    #[cfg(feature = "parsing")]
+    #[allow(missing_docs)]
+    TryFromParsed(TryFromParsed),
+    #[cfg(all(any(feature = "formatting", feature = "parsing"), feature = "alloc"))]
+    #[allow(missing_docs)]
+    InvalidFormatDescription(InvalidFormatDescription),
+    #[allow(missing_docs)]
+    DifferentVariant(DifferentVariant),
+    #[allow(missing_docs)]
+    InvalidVariant(InvalidVariant),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::ConversionRange(e) => e.fmt(f),
+            Self::ComponentRange(e) => e.fmt(f),
+            #[cfg(feature = "local-offset")]
+            Self::IndeterminateOffset(e) => e.fmt(f),
+            #[cfg(feature = "formatting")]
+            Self::Format(e) => e.fmt(f),
+            #[cfg(feature = "parsing")]
+            Self::ParseFromDescription(e) => e.fmt(f),
+            #[cfg(feature = "parsing")]
+            #[allow(deprecated)]
+            Self::UnexpectedTrailingCharacters => bug!("variant should not be used"),
+            #[cfg(feature = "parsing")]
+            Self::TryFromParsed(e) => e.fmt(f),
+            #[cfg(all(any(feature = "formatting", feature = "parsing"), feature = "alloc"))]
+            Self::InvalidFormatDescription(e) => e.fmt(f),
+            Self::DifferentVariant(e) => e.fmt(f),
+            Self::InvalidVariant(e) => e.fmt(f),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::ConversionRange(err) => Some(err),
+            Self::ComponentRange(err) => Some(err),
+            #[cfg(feature = "local-offset")]
+            Self::IndeterminateOffset(err) => Some(err),
+            #[cfg(feature = "formatting")]
+            Self::Format(err) => Some(err),
+            #[cfg(feature = "parsing")]
+            Self::ParseFromDescription(err) => Some(err),
+            #[cfg(feature = "parsing")]
+            #[allow(deprecated)]
+            Self::UnexpectedTrailingCharacters => bug!("variant should not be used"),
+            #[cfg(feature = "parsing")]
+            Self::TryFromParsed(err) => Some(err),
+            #[cfg(all(any(feature = "formatting", feature = "parsing"), feature = "alloc"))]
+            Self::InvalidFormatDescription(err) => Some(err),
+            Self::DifferentVariant(err) => Some(err),
+            Self::InvalidVariant(err) => Some(err),
+        }
+    }
+}
diff --git a/time/src/error/parse.rs b/time/src/error/parse.rs
new file mode 100644
index 000000000..adc625911
--- /dev/null
+++ b/time/src/error/parse.rs
@@ -0,0 +1,107 @@
+//! Error that occurred at some stage of parsing
+
+use core::fmt;
+
+use crate::error::{self, ParseFromDescription, TryFromParsed};
+use crate::internal_macros::bug;
+
+/// An error that occurred at some stage of parsing.
+#[allow(variant_size_differences)]
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Parse {
+    #[allow(missing_docs)]
+    TryFromParsed(TryFromParsed),
+    #[allow(missing_docs)]
+    ParseFromDescription(ParseFromDescription),
+    /// The input should have ended, but there were characters remaining.
+    #[non_exhaustive]
+    #[deprecated(
+        since = "0.3.28",
+        note = "no longer output. moved to the `ParseFromDescription` variant"
+    )]
+    UnexpectedTrailingCharacters,
+}
+
+impl fmt::Display for Parse {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::TryFromParsed(err) => err.fmt(f),
+            Self::ParseFromDescription(err) => err.fmt(f),
+            #[allow(deprecated)]
+            Self::UnexpectedTrailingCharacters => bug!("variant should not be used"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for Parse {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::TryFromParsed(err) => Some(err),
+            Self::ParseFromDescription(err) => Some(err),
+            #[allow(deprecated)]
+            Self::UnexpectedTrailingCharacters => bug!("variant should not be used"),
+        }
+    }
+}
+
+impl From<TryFromParsed> for Parse {
+    fn from(err: TryFromParsed) -> Self {
+        Self::TryFromParsed(err)
+    }
+}
+
+impl TryFrom<Parse> for TryFromParsed {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: Parse) -> Result<Self, Self::Error> {
+        match err {
+            Parse::TryFromParsed(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+impl From<ParseFromDescription> for Parse {
+    fn from(err: ParseFromDescription) -> Self {
+        Self::ParseFromDescription(err)
+    }
+}
+
+impl TryFrom<Parse> for ParseFromDescription {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: Parse) -> Result<Self, Self::Error> {
+        match err {
+            Parse::ParseFromDescription(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+impl From<Parse> for crate::Error {
+    fn from(err: Parse) -> Self {
+        match err {
+            Parse::TryFromParsed(err) => Self::TryFromParsed(err),
+            Parse::ParseFromDescription(err) => Self::ParseFromDescription(err),
+            #[allow(deprecated)]
+            Parse::UnexpectedTrailingCharacters => bug!("variant should not be used"),
+        }
+    }
+}
+
+impl TryFrom<crate::Error> for Parse {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::ParseFromDescription(err) => Ok(Self::ParseFromDescription(err)),
+            #[allow(deprecated)]
+            crate::Error::UnexpectedTrailingCharacters => bug!("variant should not be used"),
+            crate::Error::TryFromParsed(err) => Ok(Self::TryFromParsed(err)),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
diff --git a/time/src/error/parse_from_description.rs b/time/src/error/parse_from_description.rs
new file mode 100644
index 000000000..52a8a3e09
--- /dev/null
+++ b/time/src/error/parse_from_description.rs
@@ -0,0 +1,54 @@
+//! Error parsing an input into a [`Parsed`](crate::parsing::Parsed) struct
+
+use core::fmt;
+
+use crate::error;
+
+/// An error that occurred while parsing the input into a [`Parsed`](crate::parsing::Parsed) struct.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ParseFromDescription {
+    /// A string literal was not what was expected.
+    #[non_exhaustive]
+    InvalidLiteral,
+    /// A dynamic component was not valid.
+    InvalidComponent(&'static str),
+    /// The input was expected to have ended, but there are characters that remain.
+    #[non_exhaustive]
+    UnexpectedTrailingCharacters,
+}
+
+impl fmt::Display for ParseFromDescription {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InvalidLiteral => f.write_str("a character literal was not valid"),
+            Self::InvalidComponent(name) => {
+                write!(f, "the '{name}' component could not be parsed")
+            }
+            Self::UnexpectedTrailingCharacters => {
+                f.write_str("unexpected trailing characters; the end of input was expected")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for ParseFromDescription {}
+
+impl From<ParseFromDescription> for crate::Error {
+    fn from(original: ParseFromDescription) -> Self {
+        Self::ParseFromDescription(original)
+    }
+}
+
+impl TryFrom<crate::Error> for ParseFromDescription {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::ParseFromDescription(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
diff --git a/time/src/error/try_from_parsed.rs b/time/src/error/try_from_parsed.rs
new file mode 100644
index 000000000..f7a9fe49a
--- /dev/null
+++ b/time/src/error/try_from_parsed.rs
@@ -0,0 +1,72 @@
+//! Error converting a [`Parsed`](crate::parsing::Parsed) struct to another type
+
+use core::fmt;
+
+use crate::error;
+
+/// An error that occurred when converting a [`Parsed`](crate::parsing::Parsed) to another type.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TryFromParsed {
+    /// The [`Parsed`](crate::parsing::Parsed) did not include enough information to construct the
+    /// type.
+    InsufficientInformation,
+    /// Some component contained an invalid value for the type.
+    ComponentRange(error::ComponentRange),
+}
+
+impl fmt::Display for TryFromParsed {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InsufficientInformation => f.write_str(
+                "the `Parsed` struct did not include enough information to construct the type",
+            ),
+            Self::ComponentRange(err) => err.fmt(f),
+        }
+    }
+}
+
+impl From<error::ComponentRange> for TryFromParsed {
+    fn from(v: error::ComponentRange) -> Self {
+        Self::ComponentRange(v)
+    }
+}
+
+impl TryFrom<TryFromParsed> for error::ComponentRange {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: TryFromParsed) -> Result<Self, Self::Error> {
+        match err {
+            TryFromParsed::ComponentRange(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[allow(clippy::std_instead_of_core)]
+impl std::error::Error for TryFromParsed {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::InsufficientInformation => None,
+            Self::ComponentRange(err) => Some(err),
+        }
+    }
+}
+
+impl From<TryFromParsed> for crate::Error {
+    fn from(original: TryFromParsed) -> Self {
+        Self::TryFromParsed(original)
+    }
+}
+
+impl TryFrom<crate::Error> for TryFromParsed {
+    type Error = error::DifferentVariant;
+
+    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
+        match err {
+            crate::Error::TryFromParsed(err) => Ok(err),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
diff --git a/time/src/ext/digit_count.rs b/time/src/ext/digit_count.rs
new file mode 100644
index 000000000..fb42ce9e0
--- /dev/null
+++ b/time/src/ext/digit_count.rs
@@ -0,0 +1,26 @@
+use num_conv::prelude::*;
+
+/// A trait that indicates the formatted width of the value can be determined.
+///
+/// Note that this should not be implemented for any signed integers. This forces the caller to
+/// write the sign if desired.
+pub(crate) trait DigitCount {
+    /// The number of digits in the stringified value.
+    fn num_digits(self) -> u8;
+}
+
+/// A macro to generate implementations of `DigitCount` for unsigned integers.
+macro_rules! impl_digit_count {
+    ($($t:ty),* $(,)?) => {
+        $(impl DigitCount for $t {
+            fn num_digits(self) -> u8 {
+                match self.checked_ilog10() {
+                    Some(n) => n.truncate::<u8>() + 1,
+                    None => 1,
+                }
+            }
+        })*
+    };
+}
+
+impl_digit_count!(u8, u16, u32);
diff --git a/time/src/ext/instant.rs b/time/src/ext/instant.rs
new file mode 100644
index 000000000..dbc6a948f
--- /dev/null
+++ b/time/src/ext/instant.rs
@@ -0,0 +1,100 @@
+use std::time::Instant as StdInstant;
+
+use crate::Duration;
+
+/// Sealed trait to prevent downstream implementations.
+mod sealed {
+    /// A trait that cannot be implemented by downstream users.
+    pub trait Sealed: Sized {}
+    impl Sealed for std::time::Instant {}
+}
+
+/// An extension trait for [`std::time::Instant`] that adds methods for
+/// [`time::Duration`](Duration)s.
+pub trait InstantExt: sealed::Sealed {
+    /// # Panics
+    ///
+    /// This function may panic if the resulting point in time cannot be represented by the
+    /// underlying data structure. See [`InstantExt::checked_add_signed`] for a non-panicking
+    /// version.
+    fn add_signed(self, duration: Duration) -> Self {
+        self.checked_add_signed(duration)
+            .expect("overflow when adding duration to instant")
+    }
+
+    /// # Panics
+    ///
+    /// This function may panic if the resulting point in time cannot be represented by the
+    /// underlying data structure. See [`InstantExt::checked_sub_signed`] for a non-panicking
+    /// version.
+    fn sub_signed(self, duration: Duration) -> Self {
+        self.checked_sub_signed(duration)
+            .expect("overflow when subtracting duration from instant")
+    }
+
+    /// Returns `Some(t)` where `t` is the time `self.checked_add_signed(duration)` if `t` can be
+    /// represented as `Instant` (which means it's inside the bounds of the underlying data
+    /// structure), `None` otherwise.
+    fn checked_add_signed(&self, duration: Duration) -> Option<Self>;
+
+    /// Returns `Some(t)` where `t` is the time `self.checked_sub_signed(duration)` if `t` can be
+    /// represented as `Instant` (which means it's inside the bounds of the underlying data
+    /// structure), `None` otherwise.
+    fn checked_sub_signed(&self, duration: Duration) -> Option<Self>;
+
+    /// Returns the amount of time elapsed from another instant to this one. This will be negative
+    /// if `earlier` is later than `self`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use std::thread::sleep;
+    /// # use std::time::{Duration, Instant};
+    /// # use time::ext::InstantExt;
+    /// let now = Instant::now();
+    /// sleep(Duration::new(1, 0));
+    /// let new_now = Instant::now();
+    /// println!("{:?}", new_now.signed_duration_since(now)); // positive
+    /// println!("{:?}", now.signed_duration_since(new_now)); // negative
+    /// ```
+    fn signed_duration_since(&self, earlier: Self) -> Duration;
+}
+
+impl InstantExt for StdInstant {
+    fn checked_add_signed(&self, duration: Duration) -> Option<Self> {
+        if duration.is_positive() {
+            self.checked_add(duration.unsigned_abs())
+        } else if duration.is_negative() {
+            #[allow(clippy::unchecked_duration_subtraction)]
+            self.checked_sub(duration.unsigned_abs())
+        } else {
+            debug_assert!(duration.is_zero());
+            Some(*self)
+        }
+    }
+
+    fn checked_sub_signed(&self, duration: Duration) -> Option<Self> {
+        if duration.is_positive() {
+            #[allow(clippy::unchecked_duration_subtraction)]
+            self.checked_sub(duration.unsigned_abs())
+        } else if duration.is_negative() {
+            self.checked_add(duration.unsigned_abs())
+        } else {
+            debug_assert!(duration.is_zero());
+            Some(*self)
+        }
+    }
+
+    fn signed_duration_since(&self, earlier: Self) -> Duration {
+        if *self > earlier {
+            self.saturating_duration_since(earlier)
+                .try_into()
+                .unwrap_or(Duration::MAX)
+        } else {
+            earlier
+                .saturating_duration_since(*self)
+                .try_into()
+                .map_or(Duration::MIN, |d: Duration| -d)
+        }
+    }
+}
diff --git a/time/src/ext/mod.rs b/time/src/ext/mod.rs
new file mode 100644
index 000000000..7cc2d0d92
--- /dev/null
+++ b/time/src/ext/mod.rs
@@ -0,0 +1,13 @@
+//! Extension traits.
+
+mod digit_count;
+#[cfg(feature = "std")]
+mod instant;
+mod numerical_duration;
+mod numerical_std_duration;
+
+pub(crate) use self::digit_count::DigitCount;
+#[cfg(feature = "std")]
+pub use self::instant::InstantExt;
+pub use self::numerical_duration::NumericalDuration;
+pub use self::numerical_std_duration::NumericalStdDuration;
diff --git a/time/src/ext/numerical_duration.rs b/time/src/ext/numerical_duration.rs
new file mode 100644
index 000000000..fb9209d23
--- /dev/null
+++ b/time/src/ext/numerical_duration.rs
@@ -0,0 +1,140 @@
+use crate::convert::*;
+use crate::Duration;
+
+/// Sealed trait to prevent downstream implementations.
+mod sealed {
+    /// A trait that cannot be implemented by downstream users.
+    pub trait Sealed {}
+    impl Sealed for i64 {}
+    impl Sealed for f64 {}
+}
+
+/// Create [`Duration`]s from numeric literals.
+///
+/// # Examples
+///
+/// Basic construction of [`Duration`]s.
+///
+/// ```rust
+/// # use time::{Duration, ext::NumericalDuration};
+/// assert_eq!(5.nanoseconds(), Duration::nanoseconds(5));
+/// assert_eq!(5.microseconds(), Duration::microseconds(5));
+/// assert_eq!(5.milliseconds(), Duration::milliseconds(5));
+/// assert_eq!(5.seconds(), Duration::seconds(5));
+/// assert_eq!(5.minutes(), Duration::minutes(5));
+/// assert_eq!(5.hours(), Duration::hours(5));
+/// assert_eq!(5.days(), Duration::days(5));
+/// assert_eq!(5.weeks(), Duration::weeks(5));
+/// ```
+///
+/// Signed integers work as well!
+///
+/// ```rust
+/// # use time::{Duration, ext::NumericalDuration};
+/// assert_eq!((-5).nanoseconds(), Duration::nanoseconds(-5));
+/// assert_eq!((-5).microseconds(), Duration::microseconds(-5));
+/// assert_eq!((-5).milliseconds(), Duration::milliseconds(-5));
+/// assert_eq!((-5).seconds(), Duration::seconds(-5));
+/// assert_eq!((-5).minutes(), Duration::minutes(-5));
+/// assert_eq!((-5).hours(), Duration::hours(-5));
+/// assert_eq!((-5).days(), Duration::days(-5));
+/// assert_eq!((-5).weeks(), Duration::weeks(-5));
+/// ```
+///
+/// Just like any other [`Duration`], they can be added, subtracted, etc.
+///
+/// ```rust
+/// # use time::ext::NumericalDuration;
+/// assert_eq!(2.seconds() + 500.milliseconds(), 2_500.milliseconds());
+/// assert_eq!(2.seconds() - 500.milliseconds(), 1_500.milliseconds());
+/// ```
+///
+/// When called on floating point values, any remainder of the floating point value will be
+/// truncated. Keep in mind that floating point numbers are inherently imprecise and have
+/// limited capacity.
+pub trait NumericalDuration: sealed::Sealed {
+    /// Create a [`Duration`] from the number of nanoseconds.
+    fn nanoseconds(self) -> Duration;
+    /// Create a [`Duration`] from the number of microseconds.
+    fn microseconds(self) -> Duration;
+    /// Create a [`Duration`] from the number of milliseconds.
+    fn milliseconds(self) -> Duration;
+    /// Create a [`Duration`] from the number of seconds.
+    fn seconds(self) -> Duration;
+    /// Create a [`Duration`] from the number of minutes.
+    fn minutes(self) -> Duration;
+    /// Create a [`Duration`] from the number of hours.
+    fn hours(self) -> Duration;
+    /// Create a [`Duration`] from the number of days.
+    fn days(self) -> Duration;
+    /// Create a [`Duration`] from the number of weeks.
+    fn weeks(self) -> Duration;
+}
+
+impl NumericalDuration for i64 {
+    fn nanoseconds(self) -> Duration {
+        Duration::nanoseconds(self)
+    }
+
+    fn microseconds(self) -> Duration {
+        Duration::microseconds(self)
+    }
+
+    fn milliseconds(self) -> Duration {
+        Duration::milliseconds(self)
+    }
+
+    fn seconds(self) -> Duration {
+        Duration::seconds(self)
+    }
+
+    fn minutes(self) -> Duration {
+        Duration::minutes(self)
+    }
+
+    fn hours(self) -> Duration {
+        Duration::hours(self)
+    }
+
+    fn days(self) -> Duration {
+        Duration::days(self)
+    }
+
+    fn weeks(self) -> Duration {
+        Duration::weeks(self)
+    }
+}
+
+impl NumericalDuration for f64 {
+    fn nanoseconds(self) -> Duration {
+        Duration::nanoseconds(self as _)
+    }
+
+    fn microseconds(self) -> Duration {
+        Duration::nanoseconds((self * Nanosecond::per(Microsecond) as Self) as _)
+    }
+
+    fn milliseconds(self) -> Duration {
+        Duration::nanoseconds((self * Nanosecond::per(Millisecond) as Self) as _)
+    }
+
+    fn seconds(self) -> Duration {
+        Duration::nanoseconds((self * Nanosecond::per(Second) as Self) as _)
+    }
+
+    fn minutes(self) -> Duration {
+        Duration::nanoseconds((self * Nanosecond::per(Minute) as Self) as _)
+    }
+
+    fn hours(self) -> Duration {
+        Duration::nanoseconds((self * Nanosecond::per(Hour) as Self) as _)
+    }
+
+    fn days(self) -> Duration {
+        Duration::nanoseconds((self * Nanosecond::per(Day) as Self) as _)
+    }
+
+    fn weeks(self) -> Duration {
+        Duration::nanoseconds((self * Nanosecond::per(Week) as Self) as _)
+    }
+}
diff --git a/time/src/ext/numerical_std_duration.rs b/time/src/ext/numerical_std_duration.rs
new file mode 100644
index 000000000..062b33f76
--- /dev/null
+++ b/time/src/ext/numerical_std_duration.rs
@@ -0,0 +1,192 @@
+use core::time::Duration as StdDuration;
+
+use num_conv::prelude::*;
+
+use crate::convert::*;
+
+/// Sealed trait to prevent downstream implementations.
+mod sealed {
+    /// A trait that cannot be implemented by downstream users.
+    pub trait Sealed {}
+    impl Sealed for u64 {}
+    impl Sealed for f64 {}
+}
+
+/// Create [`std::time::Duration`]s from numeric literals.
+///
+/// # Examples
+///
+/// Basic construction of [`std::time::Duration`]s.
+///
+/// ```rust
+/// # use time::ext::NumericalStdDuration;
+/// # use core::time::Duration;
+/// assert_eq!(5.std_nanoseconds(), Duration::from_nanos(5));
+/// assert_eq!(5.std_microseconds(), Duration::from_micros(5));
+/// assert_eq!(5.std_milliseconds(), Duration::from_millis(5));
+/// assert_eq!(5.std_seconds(), Duration::from_secs(5));
+/// assert_eq!(5.std_minutes(), Duration::from_secs(5 * 60));
+/// assert_eq!(5.std_hours(), Duration::from_secs(5 * 3_600));
+/// assert_eq!(5.std_days(), Duration::from_secs(5 * 86_400));
+/// assert_eq!(5.std_weeks(), Duration::from_secs(5 * 604_800));
+/// ```
+///
+/// Just like any other [`std::time::Duration`], they can be added, subtracted, etc.
+///
+/// ```rust
+/// # use time::ext::NumericalStdDuration;
+/// assert_eq!(
+///     2.std_seconds() + 500.std_milliseconds(),
+///     2_500.std_milliseconds()
+/// );
+/// assert_eq!(
+///     2.std_seconds() - 500.std_milliseconds(),
+///     1_500.std_milliseconds()
+/// );
+/// ```
+///
+/// When called on floating point values, any remainder of the floating point value will be
+/// truncated. Keep in mind that floating point numbers are inherently imprecise and have
+/// limited capacity.
+pub trait NumericalStdDuration: sealed::Sealed {
+    /// Create a [`std::time::Duration`] from the number of nanoseconds.
+    fn std_nanoseconds(self) -> StdDuration;
+    /// Create a [`std::time::Duration`] from the number of microseconds.
+    fn std_microseconds(self) -> StdDuration;
+    /// Create a [`std::time::Duration`] from the number of milliseconds.
+    fn std_milliseconds(self) -> StdDuration;
+    /// Create a [`std::time::Duration`] from the number of seconds.
+    fn std_seconds(self) -> StdDuration;
+    /// Create a [`std::time::Duration`] from the number of minutes.
+    fn std_minutes(self) -> StdDuration;
+    /// Create a [`std::time::Duration`] from the number of hours.
+    fn std_hours(self) -> StdDuration;
+    /// Create a [`std::time::Duration`] from the number of days.
+    fn std_days(self) -> StdDuration;
+    /// Create a [`std::time::Duration`] from the number of weeks.
+    fn std_weeks(self) -> StdDuration;
+}
+
+impl NumericalStdDuration for u64 {
+    fn std_nanoseconds(self) -> StdDuration {
+        StdDuration::from_nanos(self)
+    }
+
+    fn std_microseconds(self) -> StdDuration {
+        StdDuration::from_micros(self)
+    }
+
+    fn std_milliseconds(self) -> StdDuration {
+        StdDuration::from_millis(self)
+    }
+
+    fn std_seconds(self) -> StdDuration {
+        StdDuration::from_secs(self)
+    }
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn std_minutes(self) -> StdDuration {
+        StdDuration::from_secs(
+            self.checked_mul(Second::per(Minute).extend())
+                .expect("overflow constructing `time::Duration`"),
+        )
+    }
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn std_hours(self) -> StdDuration {
+        StdDuration::from_secs(
+            self.checked_mul(Second::per(Hour).extend())
+                .expect("overflow constructing `time::Duration`"),
+        )
+    }
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn std_days(self) -> StdDuration {
+        StdDuration::from_secs(
+            self.checked_mul(Second::per(Day).extend())
+                .expect("overflow constructing `time::Duration`"),
+        )
+    }
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn std_weeks(self) -> StdDuration {
+        StdDuration::from_secs(
+            self.checked_mul(Second::per(Week).extend())
+                .expect("overflow constructing `time::Duration`"),
+        )
+    }
+}
+
+impl NumericalStdDuration for f64 {
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_nanoseconds(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos(self as _)
+    }
+
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_microseconds(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos((self * Nanosecond::per(Microsecond) as Self) as _)
+    }
+
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_milliseconds(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos((self * Nanosecond::per(Millisecond) as Self) as _)
+    }
+
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_seconds(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos((self * Nanosecond::per(Second) as Self) as _)
+    }
+
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_minutes(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos((self * Nanosecond::per(Minute) as Self) as _)
+    }
+
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_hours(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos((self * Nanosecond::per(Hour) as Self) as _)
+    }
+
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_days(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos((self * Nanosecond::per(Day) as Self) as _)
+    }
+
+    /// # Panics
+    ///
+    /// This will panic if self is negative.
+    fn std_weeks(self) -> StdDuration {
+        assert!(self >= 0.);
+        StdDuration::from_nanos((self * Nanosecond::per(Week) as Self) as _)
+    }
+}
diff --git a/time/src/format_description/borrowed_format_item.rs b/time/src/format_description/borrowed_format_item.rs
new file mode 100644
index 000000000..4f3e6386c
--- /dev/null
+++ b/time/src/format_description/borrowed_format_item.rs
@@ -0,0 +1,119 @@
+//! A format item with borrowed data.
+
+#[cfg(feature = "alloc")]
+use alloc::string::String;
+#[cfg(feature = "alloc")]
+use core::fmt;
+
+/// A complete description of how to format and parse a type.
+///
+/// This alias exists for backwards-compatibility. It is recommended to use `BorrowedFormatItem`
+/// for clarity, as it is more explicit that the data is borrowed rather than owned.
+#[cfg(doc)]
+#[deprecated(
+    since = "0.3.35",
+    note = "use `BorrowedFormatItem` instead for clarity"
+)]
+pub type FormatItem<'a> = BorrowedFormatItem<'a>;
+
+#[cfg(not(doc))]
+pub use self::BorrowedFormatItem as FormatItem;
+use crate::error;
+use crate::format_description::Component;
+
+/// A complete description of how to format and parse a type.
+#[non_exhaustive]
+#[cfg_attr(not(feature = "alloc"), derive(Debug))]
+#[derive(Clone, PartialEq, Eq)]
+pub enum BorrowedFormatItem<'a> {
+    /// Bytes that are formatted as-is.
+    ///
+    /// **Note**: These bytes **should** be UTF-8, but are not required to be. The value is passed
+    /// through `String::from_utf8_lossy` when necessary.
+    Literal(&'a [u8]),
+    /// A minimal representation of a single non-literal item.
+    Component(Component),
+    /// A series of literals or components that collectively form a partial or complete
+    /// description.
+    Compound(&'a [Self]),
+    /// A `FormatItem` that may or may not be present when parsing. If parsing fails, there
+    /// will be no effect on the resulting `struct`.
+    ///
+    /// This variant has no effect on formatting, as the value is guaranteed to be present.
+    Optional(&'a Self),
+    /// A series of `FormatItem`s where, when parsing, the first successful parse is used. When
+    /// formatting, the first element of the slice is used.  An empty slice is a no-op when
+    /// formatting or parsing.
+    First(&'a [Self]),
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Debug for BorrowedFormatItem<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Literal(literal) => f.write_str(&String::from_utf8_lossy(literal)),
+            Self::Component(component) => component.fmt(f),
+            Self::Compound(compound) => compound.fmt(f),
+            Self::Optional(item) => f.debug_tuple("Optional").field(item).finish(),
+            Self::First(items) => f.debug_tuple("First").field(items).finish(),
+        }
+    }
+}
+
+impl From<Component> for BorrowedFormatItem<'_> {
+    fn from(component: Component) -> Self {
+        Self::Component(component)
+    }
+}
+
+impl TryFrom<BorrowedFormatItem<'_>> for Component {
+    type Error = error::DifferentVariant;
+
+    fn try_from(value: BorrowedFormatItem<'_>) -> Result<Self, Self::Error> {
+        match value {
+            BorrowedFormatItem::Component(component) => Ok(component),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+impl<'a> From<&'a [BorrowedFormatItem<'_>]> for BorrowedFormatItem<'a> {
+    fn from(items: &'a [BorrowedFormatItem<'_>]) -> Self {
+        Self::Compound(items)
+    }
+}
+
+impl<'a> TryFrom<BorrowedFormatItem<'a>> for &[BorrowedFormatItem<'a>] {
+    type Error = error::DifferentVariant;
+
+    fn try_from(value: BorrowedFormatItem<'a>) -> Result<Self, Self::Error> {
+        match value {
+            BorrowedFormatItem::Compound(items) => Ok(items),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+impl PartialEq<Component> for BorrowedFormatItem<'_> {
+    fn eq(&self, rhs: &Component) -> bool {
+        matches!(self, Self::Component(component) if component == rhs)
+    }
+}
+
+impl PartialEq<BorrowedFormatItem<'_>> for Component {
+    fn eq(&self, rhs: &BorrowedFormatItem<'_>) -> bool {
+        rhs == self
+    }
+}
+
+impl PartialEq<&[Self]> for BorrowedFormatItem<'_> {
+    fn eq(&self, rhs: &&[Self]) -> bool {
+        matches!(self, Self::Compound(compound) if compound == rhs)
+    }
+}
+
+impl PartialEq<BorrowedFormatItem<'_>> for &[BorrowedFormatItem<'_>] {
+    fn eq(&self, rhs: &BorrowedFormatItem<'_>) -> bool {
+        rhs == self
+    }
+}
diff --git a/time/src/format_description/component.rs b/time/src/format_description/component.rs
new file mode 100644
index 000000000..9119c0905
--- /dev/null
+++ b/time/src/format_description/component.rs
@@ -0,0 +1,44 @@
+//! Part of a format description.
+
+use crate::format_description::modifier;
+
+/// A component of a larger format description.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Component {
+    /// Day of the month.
+    Day(modifier::Day),
+    /// Month of the year.
+    Month(modifier::Month),
+    /// Ordinal day of the year.
+    Ordinal(modifier::Ordinal),
+    /// Day of the week.
+    Weekday(modifier::Weekday),
+    /// Week within the year.
+    WeekNumber(modifier::WeekNumber),
+    /// Year of the date.
+    Year(modifier::Year),
+    /// Hour of the day.
+    Hour(modifier::Hour),
+    /// Minute within the hour.
+    Minute(modifier::Minute),
+    /// AM/PM part of the time.
+    Period(modifier::Period),
+    /// Second within the minute.
+    Second(modifier::Second),
+    /// Subsecond within the second.
+    Subsecond(modifier::Subsecond),
+    /// Hour of the UTC offset.
+    OffsetHour(modifier::OffsetHour),
+    /// Minute within the hour of the UTC offset.
+    OffsetMinute(modifier::OffsetMinute),
+    /// Second within the minute of the UTC offset.
+    OffsetSecond(modifier::OffsetSecond),
+    /// A number of bytes to ignore when parsing. This has no effect on formatting.
+    Ignore(modifier::Ignore),
+    /// A Unix timestamp.
+    UnixTimestamp(modifier::UnixTimestamp),
+    /// The end of input. Parsing this component will fail if there is any input remaining. This
+    /// component neither affects formatting nor consumes any input when parsing.
+    End(modifier::End),
+}
diff --git a/time/src/format_description/mod.rs b/time/src/format_description/mod.rs
new file mode 100644
index 000000000..67882afe7
--- /dev/null
+++ b/time/src/format_description/mod.rs
@@ -0,0 +1,38 @@
+//! Description of how types should be formatted and parsed.
+//!
+//! The formatted value will be output to the provided writer. Format descriptions can be
+//! [well-known](crate::format_description::well_known) or obtained by using the
+//! [`format_description!`](crate::macros::format_description) macro or a function listed below.
+//!
+//! For examples, see the implementors of [Formattable](crate::formatting::Formattable),
+//! e.g. [`well_known::Rfc3339`].
+
+mod borrowed_format_item;
+mod component;
+pub mod modifier;
+#[cfg(feature = "alloc")]
+mod owned_format_item;
+#[cfg(feature = "alloc")]
+mod parse;
+
+pub use borrowed_format_item::BorrowedFormatItem;
+#[allow(deprecated)]
+pub use borrowed_format_item::FormatItem;
+#[cfg(feature = "alloc")]
+pub use owned_format_item::OwnedFormatItem;
+
+pub use self::component::Component;
+#[cfg(feature = "alloc")]
+pub use self::parse::{parse, parse_borrowed, parse_owned};
+
+/// Well-known formats, typically standards.
+pub mod well_known {
+    pub mod iso8601;
+    mod rfc2822;
+    mod rfc3339;
+
+    #[doc(inline)]
+    pub use iso8601::Iso8601;
+    pub use rfc2822::Rfc2822;
+    pub use rfc3339::Rfc3339;
+}
diff --git a/time/src/format_description/modifier.rs b/time/src/format_description/modifier.rs
new file mode 100644
index 000000000..3a57bb6f6
--- /dev/null
+++ b/time/src/format_description/modifier.rs
@@ -0,0 +1,418 @@
+//! Various modifiers for components.
+
+use core::num::NonZeroU16;
+
+// region: date modifiers
+/// Day of the month.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Day {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+}
+
+/// The representation of a month.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MonthRepr {
+    /// The number of the month (January is 1, December is 12).
+    Numerical,
+    /// The long form of the month name (e.g. "January").
+    Long,
+    /// The short form of the month name (e.g. "Jan").
+    Short,
+}
+
+/// Month of the year.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Month {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+    /// What form of representation should be used?
+    pub repr: MonthRepr,
+    /// Is the value case sensitive when parsing?
+    pub case_sensitive: bool,
+}
+
+/// Ordinal day of the year.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Ordinal {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+}
+
+/// The representation used for the day of the week.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WeekdayRepr {
+    /// The short form of the weekday (e.g. "Mon").
+    Short,
+    /// The long form of the weekday (e.g. "Monday").
+    Long,
+    /// A numerical representation using Sunday as the first day of the week.
+    ///
+    /// Sunday is either 0 or 1, depending on the other modifier's value.
+    Sunday,
+    /// A numerical representation using Monday as the first day of the week.
+    ///
+    /// Monday is either 0 or 1, depending on the other modifier's value.
+    Monday,
+}
+
+/// Day of the week.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Weekday {
+    /// What form of representation should be used?
+    pub repr: WeekdayRepr,
+    /// When using a numerical representation, should it be zero or one-indexed?
+    pub one_indexed: bool,
+    /// Is the value case sensitive when parsing?
+    pub case_sensitive: bool,
+}
+
+/// The representation used for the week number.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WeekNumberRepr {
+    /// Week 1 is the week that contains January 4.
+    Iso,
+    /// Week 1 begins on the first Sunday of the calendar year.
+    Sunday,
+    /// Week 1 begins on the first Monday of the calendar year.
+    Monday,
+}
+
+/// Week within the year.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct WeekNumber {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+    /// What kind of representation should be used?
+    pub repr: WeekNumberRepr,
+}
+
+/// The representation used for a year value.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum YearRepr {
+    /// The full value of the year.
+    Full,
+    /// Only the last two digits of the year.
+    LastTwo,
+}
+
+/// Year of the date.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Year {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+    /// What kind of representation should be used?
+    pub repr: YearRepr,
+    /// Whether the value is based on the ISO week number or the Gregorian calendar.
+    pub iso_week_based: bool,
+    /// Whether the `+` sign is present when a positive year contains fewer than five digits.
+    pub sign_is_mandatory: bool,
+}
+// endregion date modifiers
+
+// region: time modifiers
+/// Hour of the day.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Hour {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+    /// Is the hour displayed using a 12 or 24-hour clock?
+    pub is_12_hour_clock: bool,
+}
+
+/// Minute within the hour.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Minute {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+}
+
+/// AM/PM part of the time.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Period {
+    /// Is the period uppercase or lowercase?
+    pub is_uppercase: bool,
+    /// Is the value case sensitive when parsing?
+    ///
+    /// Note that when `false`, the `is_uppercase` field has no effect on parsing behavior.
+    pub case_sensitive: bool,
+}
+
+/// Second within the minute.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Second {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+}
+
+/// The number of digits present in a subsecond representation.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SubsecondDigits {
+    /// Exactly one digit.
+    One,
+    /// Exactly two digits.
+    Two,
+    /// Exactly three digits.
+    Three,
+    /// Exactly four digits.
+    Four,
+    /// Exactly five digits.
+    Five,
+    /// Exactly six digits.
+    Six,
+    /// Exactly seven digits.
+    Seven,
+    /// Exactly eight digits.
+    Eight,
+    /// Exactly nine digits.
+    Nine,
+    /// Any number of digits (up to nine) that is at least one. When formatting, the minimum digits
+    /// necessary will be used.
+    OneOrMore,
+}
+
+/// Subsecond within the second.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Subsecond {
+    /// How many digits are present in the component?
+    pub digits: SubsecondDigits,
+}
+// endregion time modifiers
+
+// region: offset modifiers
+/// Hour of the UTC offset.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct OffsetHour {
+    /// Whether the `+` sign is present on positive values.
+    pub sign_is_mandatory: bool,
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+}
+
+/// Minute within the hour of the UTC offset.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct OffsetMinute {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+}
+
+/// Second within the minute of the UTC offset.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct OffsetSecond {
+    /// The padding to obtain the minimum width.
+    pub padding: Padding,
+}
+// endregion offset modifiers
+
+/// Type of padding to ensure a minimum width.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Padding {
+    /// A space character (` `) should be used as padding.
+    Space,
+    /// A zero character (`0`) should be used as padding.
+    Zero,
+    /// There is no padding. This can result in a width below the otherwise minimum number of
+    /// characters.
+    None,
+}
+
+/// Ignore some number of bytes.
+///
+/// This has no effect when formatting.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Ignore {
+    /// The number of bytes to ignore.
+    pub count: NonZeroU16,
+}
+
+// Needed as `Default` is deliberately not implemented for `Ignore`. The number of bytes to ignore
+// must be explicitly provided.
+impl Ignore {
+    /// Create an instance of `Ignore` with the provided number of bytes to ignore.
+    pub const fn count(count: NonZeroU16) -> Self {
+        Self { count }
+    }
+}
+
+/// The precision of a Unix timestamp.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum UnixTimestampPrecision {
+    /// Seconds since the Unix epoch.
+    Second,
+    /// Milliseconds since the Unix epoch.
+    Millisecond,
+    /// Microseconds since the Unix epoch.
+    Microsecond,
+    /// Nanoseconds since the Unix epoch.
+    Nanosecond,
+}
+
+/// A Unix timestamp.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct UnixTimestamp {
+    /// The precision of the timestamp.
+    pub precision: UnixTimestampPrecision,
+    /// Whether the `+` sign must be present for a non-negative timestamp.
+    pub sign_is_mandatory: bool,
+}
+
+/// The end of input.
+///
+/// There is currently not customization for this modifier.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct End;
+
+/// Generate the provided code if and only if `pub` is present.
+macro_rules! if_pub {
+    (pub $(#[$attr:meta])*; $($x:tt)*) => {
+        $(#[$attr])*
+        ///
+        /// This function exists since [`Default::default()`] cannot be used in a `const` context.
+        /// It may be removed once that becomes possible. As the [`Default`] trait is in the
+        /// prelude, removing this function in the future will not cause any resolution failures for
+        /// the overwhelming majority of users; only users who use `#![no_implicit_prelude]` will be
+        /// affected. As such it will not be considered a breaking change.
+        $($x)*
+    };
+    ($($_:tt)*) => {};
+}
+
+/// Implement `Default` for the given type. This also generates an inherent implementation of a
+/// `default` method that is `const fn`, permitting the default value to be used in const contexts.
+// Every modifier should use this macro rather than a derived `Default`.
+macro_rules! impl_const_default {
+    ($($(#[$doc:meta])* $(@$pub:ident)? $type:ty => $default:expr;)*) => {$(
+        impl $type {
+            if_pub! {
+                $($pub)?
+                $(#[$doc])*;
+                pub const fn default() -> Self {
+                    $default
+                }
+            }
+        }
+
+        $(#[$doc])*
+        impl Default for $type {
+            fn default() -> Self {
+                $default
+            }
+        }
+    )*};
+}
+
+impl_const_default! {
+    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
+    @pub Day => Self { padding: Padding::Zero };
+    /// Creates a modifier that indicates the value uses the
+    /// [`Numerical`](Self::Numerical) representation.
+    MonthRepr => Self::Numerical;
+    /// Creates an instance of this type that indicates the value uses the
+    /// [`Numerical`](MonthRepr::Numerical) representation, is [padded with zeroes](Padding::Zero),
+    /// and is case-sensitive when parsing.
+    @pub Month => Self {
+        padding: Padding::Zero,
+        repr: MonthRepr::Numerical,
+        case_sensitive: true,
+    };
+    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
+    @pub Ordinal => Self { padding: Padding::Zero };
+    /// Creates a modifier that indicates the value uses the [`Long`](Self::Long) representation.
+    WeekdayRepr => Self::Long;
+    /// Creates a modifier that indicates the value uses the [`Long`](WeekdayRepr::Long)
+    /// representation and is case-sensitive when parsing. If the representation is changed to a
+    /// numerical one, the instance defaults to one-based indexing.
+    @pub Weekday => Self {
+        repr: WeekdayRepr::Long,
+        one_indexed: true,
+        case_sensitive: true,
+    };
+    /// Creates a modifier that indicates that the value uses the [`Iso`](Self::Iso) representation.
+    WeekNumberRepr => Self::Iso;
+    /// Creates a modifier that indicates that the value is [padded with zeroes](Padding::Zero)
+            /// and uses the [`Iso`](WeekNumberRepr::Iso) representation.
+    @pub WeekNumber => Self {
+        padding: Padding::Zero,
+        repr: WeekNumberRepr::Iso,
+    };
+    /// Creates a modifier that indicates the value uses the [`Full`](Self::Full) representation.
+    YearRepr => Self::Full;
+    /// Creates a modifier that indicates the value uses the [`Full`](YearRepr::Full)
+    /// representation, is [padded with zeroes](Padding::Zero), uses the Gregorian calendar as its
+    /// base, and only includes the year's sign if necessary.
+    @pub Year => Self {
+        padding: Padding::Zero,
+        repr: YearRepr::Full,
+        iso_week_based: false,
+        sign_is_mandatory: false,
+    };
+    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero) and
+    /// has the 24-hour representation.
+    @pub Hour => Self {
+        padding: Padding::Zero,
+        is_12_hour_clock: false,
+    };
+    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
+    @pub Minute => Self { padding: Padding::Zero };
+    /// Creates a modifier that indicates the value uses the upper-case representation and is
+    /// case-sensitive when parsing.
+    @pub Period => Self {
+        is_uppercase: true,
+        case_sensitive: true,
+    };
+    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
+    @pub Second => Self { padding: Padding::Zero };
+    /// Creates a modifier that indicates the stringified value contains [one or more
+    /// digits](Self::OneOrMore).
+    SubsecondDigits => Self::OneOrMore;
+    /// Creates a modifier that indicates the stringified value contains [one or more
+    /// digits](SubsecondDigits::OneOrMore).
+    @pub Subsecond => Self { digits: SubsecondDigits::OneOrMore };
+    /// Creates a modifier that indicates the value only uses a sign for negative values and is
+    /// [padded with zeroes](Padding::Zero).
+    @pub OffsetHour => Self {
+        sign_is_mandatory: false,
+        padding: Padding::Zero,
+    };
+    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
+    @pub OffsetMinute => Self { padding: Padding::Zero };
+    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
+    @pub OffsetSecond => Self { padding: Padding::Zero };
+    /// Creates a modifier that indicates the value is [padded with zeroes](Self::Zero).
+    Padding => Self::Zero;
+    /// Creates a modifier that indicates the value represents the [number of seconds](Self::Second)
+    /// since the Unix epoch.
+    UnixTimestampPrecision => Self::Second;
+    /// Creates a modifier that indicates the value represents the [number of
+    /// seconds](UnixTimestampPrecision::Second) since the Unix epoch. The sign is not mandatory.
+    @pub UnixTimestamp => Self {
+        precision: UnixTimestampPrecision::Second,
+        sign_is_mandatory: false,
+    };
+    /// Creates a modifier used to represent the end of input.
+    @pub End => End;
+}
diff --git a/time/src/format_description/owned_format_item.rs b/time/src/format_description/owned_format_item.rs
new file mode 100644
index 000000000..31ea9f90b
--- /dev/null
+++ b/time/src/format_description/owned_format_item.rs
@@ -0,0 +1,164 @@
+//! A format item with owned data.
+
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::fmt;
+
+use crate::error;
+use crate::format_description::{BorrowedFormatItem, Component};
+
+/// A complete description of how to format and parse a type.
+#[non_exhaustive]
+#[derive(Clone, PartialEq, Eq)]
+pub enum OwnedFormatItem {
+    /// Bytes that are formatted as-is.
+    ///
+    /// **Note**: These bytes **should** be UTF-8, but are not required to be. The value is passed
+    /// through `String::from_utf8_lossy` when necessary.
+    Literal(Box<[u8]>),
+    /// A minimal representation of a single non-literal item.
+    Component(Component),
+    /// A series of literals or components that collectively form a partial or complete
+    /// description.
+    Compound(Box<[Self]>),
+    /// A `FormatItem` that may or may not be present when parsing. If parsing fails, there
+    /// will be no effect on the resulting `struct`.
+    ///
+    /// This variant has no effect on formatting, as the value is guaranteed to be present.
+    Optional(Box<Self>),
+    /// A series of `FormatItem`s where, when parsing, the first successful parse is used. When
+    /// formatting, the first element of the [`Vec`] is used. An empty [`Vec`] is a no-op when
+    /// formatting or parsing.
+    First(Box<[Self]>),
+}
+
+impl fmt::Debug for OwnedFormatItem {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Literal(literal) => f.write_str(&String::from_utf8_lossy(literal)),
+            Self::Component(component) => component.fmt(f),
+            Self::Compound(compound) => compound.fmt(f),
+            Self::Optional(item) => f.debug_tuple("Optional").field(item).finish(),
+            Self::First(items) => f.debug_tuple("First").field(items).finish(),
+        }
+    }
+}
+
+// region: conversions from FormatItem
+impl From<BorrowedFormatItem<'_>> for OwnedFormatItem {
+    fn from(item: BorrowedFormatItem<'_>) -> Self {
+        (&item).into()
+    }
+}
+
+impl From<&BorrowedFormatItem<'_>> for OwnedFormatItem {
+    fn from(item: &BorrowedFormatItem<'_>) -> Self {
+        match item {
+            BorrowedFormatItem::Literal(literal) => {
+                Self::Literal(literal.to_vec().into_boxed_slice())
+            }
+            BorrowedFormatItem::Component(component) => Self::Component(*component),
+            BorrowedFormatItem::Compound(compound) => Self::Compound(
+                compound
+                    .iter()
+                    .cloned()
+                    .map(Into::into)
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice(),
+            ),
+            BorrowedFormatItem::Optional(item) => Self::Optional(Box::new((*item).into())),
+            BorrowedFormatItem::First(items) => Self::First(
+                items
+                    .iter()
+                    .cloned()
+                    .map(Into::into)
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice(),
+            ),
+        }
+    }
+}
+
+impl From<Vec<BorrowedFormatItem<'_>>> for OwnedFormatItem {
+    fn from(items: Vec<BorrowedFormatItem<'_>>) -> Self {
+        items.as_slice().into()
+    }
+}
+
+impl<'a, T: AsRef<[BorrowedFormatItem<'a>]> + ?Sized> From<&T> for OwnedFormatItem {
+    fn from(items: &T) -> Self {
+        Self::Compound(
+            items
+                .as_ref()
+                .iter()
+                .cloned()
+                .map(Into::into)
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+        )
+    }
+}
+// endregion conversions from FormatItem
+
+// region: from variants
+impl From<Component> for OwnedFormatItem {
+    fn from(component: Component) -> Self {
+        Self::Component(component)
+    }
+}
+
+impl TryFrom<OwnedFormatItem> for Component {
+    type Error = error::DifferentVariant;
+
+    fn try_from(value: OwnedFormatItem) -> Result<Self, Self::Error> {
+        match value {
+            OwnedFormatItem::Component(component) => Ok(component),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+
+impl From<Vec<Self>> for OwnedFormatItem {
+    fn from(items: Vec<Self>) -> Self {
+        Self::Compound(items.into_boxed_slice())
+    }
+}
+
+impl TryFrom<OwnedFormatItem> for Vec<OwnedFormatItem> {
+    type Error = error::DifferentVariant;
+
+    fn try_from(value: OwnedFormatItem) -> Result<Self, Self::Error> {
+        match value {
+            OwnedFormatItem::Compound(items) => Ok(items.into_vec()),
+            _ => Err(error::DifferentVariant),
+        }
+    }
+}
+// endregion from variants
+
+// region: equality
+impl PartialEq<Component> for OwnedFormatItem {
+    fn eq(&self, rhs: &Component) -> bool {
+        matches!(self, Self::Component(component) if component == rhs)
+    }
+}
+
+impl PartialEq<OwnedFormatItem> for Component {
+    fn eq(&self, rhs: &OwnedFormatItem) -> bool {
+        rhs == self
+    }
+}
+
+impl PartialEq<&[Self]> for OwnedFormatItem {
+    fn eq(&self, rhs: &&[Self]) -> bool {
+        matches!(self, Self::Compound(compound) if &&**compound == rhs)
+    }
+}
+
+impl PartialEq<OwnedFormatItem> for &[OwnedFormatItem] {
+    fn eq(&self, rhs: &OwnedFormatItem) -> bool {
+        rhs == self
+    }
+}
+// endregion equality
diff --git a/time/src/format_description/parse/ast.rs b/time/src/format_description/parse/ast.rs
new file mode 100644
index 000000000..c7fc5e05a
--- /dev/null
+++ b/time/src/format_description/parse/ast.rs
@@ -0,0 +1,384 @@
+//! AST for parsing format descriptions.
+
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::iter;
+
+use super::{lexer, unused, Error, Location, Spanned, SpannedValue, Unused};
+use crate::internal_macros::bug;
+
+/// One part of a complete format description.
+pub(super) enum Item<'a> {
+    /// A literal string, formatted and parsed as-is.
+    ///
+    /// This should never be present inside a nested format description.
+    Literal(Spanned<&'a [u8]>),
+    /// A sequence of brackets. The first acts as the escape character.
+    ///
+    /// This should never be present if the lexer has `BACKSLASH_ESCAPE` set to `true`.
+    EscapedBracket {
+        /// The first bracket.
+        _first: Unused<Location>,
+        /// The second bracket.
+        _second: Unused<Location>,
+    },
+    /// Part of a type, along with its modifiers.
+    Component {
+        /// Where the opening bracket was in the format string.
+        _opening_bracket: Unused<Location>,
+        /// Whitespace between the opening bracket and name.
+        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        /// The name of the component.
+        name: Spanned<&'a [u8]>,
+        /// The modifiers for the component.
+        modifiers: Box<[Modifier<'a>]>,
+        /// Whitespace between the modifiers and closing bracket.
+        _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        /// Where the closing bracket was in the format string.
+        _closing_bracket: Unused<Location>,
+    },
+    /// An optional sequence of items.
+    Optional {
+        /// Where the opening bracket was in the format string.
+        opening_bracket: Location,
+        /// Whitespace between the opening bracket and "optional".
+        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        /// The "optional" keyword.
+        _optional_kw: Unused<Spanned<&'a [u8]>>,
+        /// Whitespace between the "optional" keyword and the opening bracket.
+        _whitespace: Unused<Spanned<&'a [u8]>>,
+        /// The items within the optional sequence.
+        nested_format_description: NestedFormatDescription<'a>,
+        /// Where the closing bracket was in the format string.
+        closing_bracket: Location,
+    },
+    /// The first matching parse of a sequence of items.
+    First {
+        /// Where the opening bracket was in the format string.
+        opening_bracket: Location,
+        /// Whitespace between the opening bracket and "first".
+        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+        /// The "first" keyword.
+        _first_kw: Unused<Spanned<&'a [u8]>>,
+        /// Whitespace between the "first" keyword and the opening bracket.
+        _whitespace: Unused<Spanned<&'a [u8]>>,
+        /// The sequences of items to try.
+        nested_format_descriptions: Box<[NestedFormatDescription<'a>]>,
+        /// Where the closing bracket was in the format string.
+        closing_bracket: Location,
+    },
+}
+
+/// A format description that is nested within another format description.
+pub(super) struct NestedFormatDescription<'a> {
+    /// Where the opening bracket was in the format string.
+    pub(super) _opening_bracket: Unused<Location>,
+    /// The items within the nested format description.
+    pub(super) items: Box<[Item<'a>]>,
+    /// Where the closing bracket was in the format string.
+    pub(super) _closing_bracket: Unused<Location>,
+    /// Whitespace between the closing bracket and the next item.
+    pub(super) _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
+}
+
+/// A modifier for a component.
+pub(super) struct Modifier<'a> {
+    /// Whitespace preceding the modifier.
+    pub(super) _leading_whitespace: Unused<Spanned<&'a [u8]>>,
+    /// The key of the modifier.
+    pub(super) key: Spanned<&'a [u8]>,
+    /// Where the colon of the modifier was in the format string.
+    pub(super) _colon: Unused<Location>,
+    /// The value of the modifier.
+    pub(super) value: Spanned<&'a [u8]>,
+}
+
+/// Parse the provided tokens into an AST.
+pub(super) fn parse<
+    'item: 'iter,
+    'iter,
+    I: Iterator<Item = Result<lexer::Token<'item>, Error>>,
+    const VERSION: usize,
+>(
+    tokens: &'iter mut lexer::Lexed<I>,
+) -> impl Iterator<Item = Result<Item<'item>, Error>> + 'iter {
+    validate_version!(VERSION);
+    parse_inner::<_, false, VERSION>(tokens)
+}
+
+/// Parse the provided tokens into an AST. The const generic indicates whether the resulting
+/// [`Item`] will be used directly or as part of a [`NestedFormatDescription`].
+fn parse_inner<
+    'item,
+    I: Iterator<Item = Result<lexer::Token<'item>, Error>>,
+    const NESTED: bool,
+    const VERSION: usize,
+>(
+    tokens: &mut lexer::Lexed<I>,
+) -> impl Iterator<Item = Result<Item<'item>, Error>> + '_ {
+    validate_version!(VERSION);
+    iter::from_fn(move || {
+        if NESTED && tokens.peek_closing_bracket().is_some() {
+            return None;
+        }
+
+        let next = match tokens.next()? {
+            Ok(token) => token,
+            Err(err) => return Some(Err(err)),
+        };
+
+        Some(match next {
+            lexer::Token::Literal(Spanned { value: _, span: _ }) if NESTED => {
+                bug!("literal should not be present in nested description")
+            }
+            lexer::Token::Literal(value) => Ok(Item::Literal(value)),
+            lexer::Token::Bracket {
+                kind: lexer::BracketKind::Opening,
+                location,
+            } => {
+                if version!(..=1) {
+                    if let Some(second_location) = tokens.next_if_opening_bracket() {
+                        Ok(Item::EscapedBracket {
+                            _first: unused(location),
+                            _second: unused(second_location),
+                        })
+                    } else {
+                        parse_component::<_, VERSION>(location, tokens)
+                    }
+                } else {
+                    parse_component::<_, VERSION>(location, tokens)
+                }
+            }
+            lexer::Token::Bracket {
+                kind: lexer::BracketKind::Closing,
+                location: _,
+            } if NESTED => {
+                bug!("closing bracket should be caught by the `if` statement")
+            }
+            lexer::Token::Bracket {
+                kind: lexer::BracketKind::Closing,
+                location: _,
+            } => {
+                bug!("closing bracket should have been consumed by `parse_component`")
+            }
+            lexer::Token::ComponentPart {
+                kind: _, // whitespace is significant in nested components
+                value,
+            } if NESTED => Ok(Item::Literal(value)),
+            lexer::Token::ComponentPart { kind: _, value: _ } => {
+                bug!("component part should have been consumed by `parse_component`")
+            }
+        })
+    })
+}
+
+/// Parse a component. This assumes that the opening bracket has already been consumed.
+fn parse_component<
+    'a,
+    I: Iterator<Item = Result<lexer::Token<'a>, Error>>,
+    const VERSION: usize,
+>(
+    opening_bracket: Location,
+    tokens: &mut lexer::Lexed<I>,
+) -> Result<Item<'a>, Error> {
+    validate_version!(VERSION);
+    let leading_whitespace = tokens.next_if_whitespace();
+
+    let Some(name) = tokens.next_if_not_whitespace() else {
+        let span = match leading_whitespace {
+            Some(Spanned { value: _, span }) => span,
+            None => opening_bracket.to(opening_bracket),
+        };
+        return Err(Error {
+            _inner: unused(span.error("expected component name")),
+            public: crate::error::InvalidFormatDescription::MissingComponentName {
+                index: span.start.byte as _,
+            },
+        });
+    };
+
+    if *name == b"optional" {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
+            return Err(Error {
+                _inner: unused(name.span.error("expected whitespace after `optional`")),
+                public: crate::error::InvalidFormatDescription::Expected {
+                    what: "whitespace after `optional`",
+                    index: name.span.end.byte as _,
+                },
+            });
+        };
+
+        let nested = parse_nested::<_, VERSION>(whitespace.span.end, tokens)?;
+
+        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+            return Err(Error {
+                _inner: unused(opening_bracket.error("unclosed bracket")),
+                public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
+                    index: opening_bracket.byte as _,
+                },
+            });
+        };
+
+        return Ok(Item::Optional {
+            opening_bracket,
+            _leading_whitespace: unused(leading_whitespace),
+            _optional_kw: unused(name),
+            _whitespace: unused(whitespace),
+            nested_format_description: nested,
+            closing_bracket,
+        });
+    }
+
+    if *name == b"first" {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
+            return Err(Error {
+                _inner: unused(name.span.error("expected whitespace after `first`")),
+                public: crate::error::InvalidFormatDescription::Expected {
+                    what: "whitespace after `first`",
+                    index: name.span.end.byte as _,
+                },
+            });
+        };
+
+        let mut nested_format_descriptions = Vec::new();
+        while let Ok(description) = parse_nested::<_, VERSION>(whitespace.span.end, tokens) {
+            nested_format_descriptions.push(description);
+        }
+
+        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+            return Err(Error {
+                _inner: unused(opening_bracket.error("unclosed bracket")),
+                public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
+                    index: opening_bracket.byte as _,
+                },
+            });
+        };
+
+        return Ok(Item::First {
+            opening_bracket,
+            _leading_whitespace: unused(leading_whitespace),
+            _first_kw: unused(name),
+            _whitespace: unused(whitespace),
+            nested_format_descriptions: nested_format_descriptions.into_boxed_slice(),
+            closing_bracket,
+        });
+    }
+
+    let mut modifiers = Vec::new();
+    let trailing_whitespace = loop {
+        let Some(whitespace) = tokens.next_if_whitespace() else {
+            break None;
+        };
+
+        // This is not necessary for proper parsing, but provides a much better error when a nested
+        // description is used where it's not allowed.
+        if let Some(location) = tokens.next_if_opening_bracket() {
+            return Err(Error {
+                _inner: unused(
+                    location
+                        .to(location)
+                        .error("modifier must be of the form `key:value`"),
+                ),
+                public: crate::error::InvalidFormatDescription::InvalidModifier {
+                    value: String::from("["),
+                    index: location.byte as _,
+                },
+            });
+        }
+
+        let Some(Spanned { value, span }) = tokens.next_if_not_whitespace() else {
+            break Some(whitespace);
+        };
+
+        let Some(colon_index) = value.iter().position(|&b| b == b':') else {
+            return Err(Error {
+                _inner: unused(span.error("modifier must be of the form `key:value`")),
+                public: crate::error::InvalidFormatDescription::InvalidModifier {
+                    value: String::from_utf8_lossy(value).into_owned(),
+                    index: span.start.byte as _,
+                },
+            });
+        };
+        let key = &value[..colon_index];
+        let value = &value[colon_index + 1..];
+
+        if key.is_empty() {
+            return Err(Error {
+                _inner: unused(span.shrink_to_start().error("expected modifier key")),
+                public: crate::error::InvalidFormatDescription::InvalidModifier {
+                    value: String::new(),
+                    index: span.start.byte as _,
+                },
+            });
+        }
+        if value.is_empty() {
+            return Err(Error {
+                _inner: unused(span.shrink_to_end().error("expected modifier value")),
+                public: crate::error::InvalidFormatDescription::InvalidModifier {
+                    value: String::new(),
+                    index: span.shrink_to_end().start.byte as _,
+                },
+            });
+        }
+
+        modifiers.push(Modifier {
+            _leading_whitespace: unused(whitespace),
+            key: key.spanned(span.shrink_to_before(colon_index as _)),
+            _colon: unused(span.start.offset(colon_index as _)),
+            value: value.spanned(span.shrink_to_after(colon_index as _)),
+        });
+    };
+
+    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+        return Err(Error {
+            _inner: unused(opening_bracket.error("unclosed bracket")),
+            public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
+                index: opening_bracket.byte as _,
+            },
+        });
+    };
+
+    Ok(Item::Component {
+        _opening_bracket: unused(opening_bracket),
+        _leading_whitespace: unused(leading_whitespace),
+        name,
+        modifiers: modifiers.into_boxed_slice(),
+        _trailing_whitespace: unused(trailing_whitespace),
+        _closing_bracket: unused(closing_bracket),
+    })
+}
+
+/// Parse a nested format description. The location provided is the the most recent one consumed.
+fn parse_nested<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const VERSION: usize>(
+    last_location: Location,
+    tokens: &mut lexer::Lexed<I>,
+) -> Result<NestedFormatDescription<'a>, Error> {
+    validate_version!(VERSION);
+    let Some(opening_bracket) = tokens.next_if_opening_bracket() else {
+        return Err(Error {
+            _inner: unused(last_location.error("expected opening bracket")),
+            public: crate::error::InvalidFormatDescription::Expected {
+                what: "opening bracket",
+                index: last_location.byte as _,
+            },
+        });
+    };
+    let items = parse_inner::<_, true, VERSION>(tokens).collect::<Result<_, _>>()?;
+    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
+        return Err(Error {
+            _inner: unused(opening_bracket.error("unclosed bracket")),
+            public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
+                index: opening_bracket.byte as _,
+            },
+        });
+    };
+    let trailing_whitespace = tokens.next_if_whitespace();
+
+    Ok(NestedFormatDescription {
+        _opening_bracket: unused(opening_bracket),
+        items,
+        _closing_bracket: unused(closing_bracket),
+        _trailing_whitespace: unused(trailing_whitespace),
+    })
+}
diff --git a/time/src/format_description/parse/format_item.rs b/time/src/format_description/parse/format_item.rs
new file mode 100644
index 000000000..2e1ee6a74
--- /dev/null
+++ b/time/src/format_description/parse/format_item.rs
@@ -0,0 +1,541 @@
+//! Typed, validated representation of a parsed format description.
+
+use alloc::boxed::Box;
+use alloc::string::String;
+use core::num::NonZeroU16;
+use core::str::{self, FromStr};
+
+use super::{ast, unused, Error, Span, Spanned};
+use crate::internal_macros::bug;
+
+/// Parse an AST iterator into a sequence of format items.
+pub(super) fn parse<'a>(
+    ast_items: impl Iterator<Item = Result<ast::Item<'a>, Error>>,
+) -> impl Iterator<Item = Result<Item<'a>, Error>> {
+    ast_items.map(|ast_item| ast_item.and_then(Item::from_ast))
+}
+
+/// A description of how to format and parse one part of a type.
+pub(super) enum Item<'a> {
+    /// A literal string.
+    Literal(&'a [u8]),
+    /// Part of a type, along with its modifiers.
+    Component(Component),
+    /// A sequence of optional items.
+    Optional {
+        /// The items themselves.
+        value: Box<[Self]>,
+        /// The span of the full sequence.
+        span: Span,
+    },
+    /// The first matching parse of a sequence of format descriptions.
+    First {
+        /// The sequence of format descriptions.
+        value: Box<[Box<[Self]>]>,
+        /// The span of the full sequence.
+        span: Span,
+    },
+}
+
+impl Item<'_> {
+    /// Parse an AST item into a format item.
+    pub(super) fn from_ast(ast_item: ast::Item<'_>) -> Result<Item<'_>, Error> {
+        Ok(match ast_item {
+            ast::Item::Component {
+                _opening_bracket: _,
+                _leading_whitespace: _,
+                name,
+                modifiers,
+                _trailing_whitespace: _,
+                _closing_bracket: _,
+            } => Item::Component(component_from_ast(&name, &modifiers)?),
+            ast::Item::Literal(Spanned { value, span: _ }) => Item::Literal(value),
+            ast::Item::EscapedBracket {
+                _first: _,
+                _second: _,
+            } => Item::Literal(b"["),
+            ast::Item::Optional {
+                opening_bracket,
+                _leading_whitespace: _,
+                _optional_kw: _,
+                _whitespace: _,
+                nested_format_description,
+                closing_bracket,
+            } => {
+                let items = nested_format_description
+                    .items
+                    .into_vec()
+                    .into_iter()
+                    .map(Item::from_ast)
+                    .collect::<Result<_, _>>()?;
+                Item::Optional {
+                    value: items,
+                    span: opening_bracket.to(closing_bracket),
+                }
+            }
+            ast::Item::First {
+                opening_bracket,
+                _leading_whitespace: _,
+                _first_kw: _,
+                _whitespace: _,
+                nested_format_descriptions,
+                closing_bracket,
+            } => {
+                let items = nested_format_descriptions
+                    .into_vec()
+                    .into_iter()
+                    .map(|nested_format_description| {
+                        nested_format_description
+                            .items
+                            .into_vec()
+                            .into_iter()
+                            .map(Item::from_ast)
+                            .collect()
+                    })
+                    .collect::<Result<_, _>>()?;
+                Item::First {
+                    value: items,
+                    span: opening_bracket.to(closing_bracket),
+                }
+            }
+        })
+    }
+}
+
+impl<'a> TryFrom<Item<'a>> for crate::format_description::BorrowedFormatItem<'a> {
+    type Error = Error;
+
+    fn try_from(item: Item<'a>) -> Result<Self, Self::Error> {
+        match item {
+            Item::Literal(literal) => Ok(Self::Literal(literal)),
+            Item::Component(component) => Ok(Self::Component(component.into())),
+            Item::Optional { value: _, span } => Err(Error {
+                _inner: unused(span.error(
+                    "optional items are not supported in runtime-parsed format descriptions",
+                )),
+                public: crate::error::InvalidFormatDescription::NotSupported {
+                    what: "optional item",
+                    context: "runtime-parsed format descriptions",
+                    index: span.start.byte as _,
+                },
+            }),
+            Item::First { value: _, span } => Err(Error {
+                _inner: unused(span.error(
+                    "'first' items are not supported in runtime-parsed format descriptions",
+                )),
+                public: crate::error::InvalidFormatDescription::NotSupported {
+                    what: "'first' item",
+                    context: "runtime-parsed format descriptions",
+                    index: span.start.byte as _,
+                },
+            }),
+        }
+    }
+}
+
+impl From<Item<'_>> for crate::format_description::OwnedFormatItem {
+    fn from(item: Item<'_>) -> Self {
+        match item {
+            Item::Literal(literal) => Self::Literal(literal.to_vec().into_boxed_slice()),
+            Item::Component(component) => Self::Component(component.into()),
+            Item::Optional { value, span: _ } => Self::Optional(Box::new(value.into())),
+            Item::First { value, span: _ } => {
+                Self::First(value.into_vec().into_iter().map(Into::into).collect())
+            }
+        }
+    }
+}
+
+impl<'a> From<Box<[Item<'a>]>> for crate::format_description::OwnedFormatItem {
+    fn from(items: Box<[Item<'a>]>) -> Self {
+        let items = items.into_vec();
+        match <[_; 1]>::try_from(items) {
+            Ok([item]) => item.into(),
+            Err(vec) => Self::Compound(vec.into_iter().map(Into::into).collect()),
+        }
+    }
+}
+
+/// Declare the `Component` struct.
+macro_rules! component_definition {
+    (@if_required required then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($then)* };
+    (@if_required then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($($else)*)? };
+    (@if_from_str from_str then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($then)* };
+    (@if_from_str then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($($else)*)? };
+
+    ($vis:vis enum $name:ident {
+        $($variant:ident = $parse_variant:literal {$(
+            $(#[$required:tt])?
+            $field:ident = $parse_field:literal:
+            Option<$(#[$from_str:tt])? $field_type:ty>
+            => $target_field:ident
+        ),* $(,)?}),* $(,)?
+    }) => {
+        $vis enum $name {
+            $($variant($variant),)*
+        }
+
+        $($vis struct $variant {
+            $($field: Option<$field_type>),*
+        })*
+
+        $(impl $variant {
+            /// Parse the component from the AST, given its modifiers.
+            fn with_modifiers(
+                modifiers: &[ast::Modifier<'_>],
+                _component_span: Span,
+            ) -> Result<Self, Error>
+            {
+                // rustc will complain if the modifier is empty.
+                #[allow(unused_mut)]
+                let mut this = Self {
+                    $($field: None),*
+                };
+
+                for modifier in modifiers {
+                    $(#[allow(clippy::string_lit_as_bytes)]
+                    if modifier.key.eq_ignore_ascii_case($parse_field.as_bytes()) {
+                        this.$field = component_definition!(@if_from_str $($from_str)?
+                            then {
+                                parse_from_modifier_value::<$field_type>(&modifier.value)?
+                            } else {
+                                <$field_type>::from_modifier_value(&modifier.value)?
+                            });
+                        continue;
+                    })*
+                    return Err(Error {
+                        _inner: unused(modifier.key.span.error("invalid modifier key")),
+                        public: crate::error::InvalidFormatDescription::InvalidModifier {
+                            value: String::from_utf8_lossy(*modifier.key).into_owned(),
+                            index: modifier.key.span.start.byte as _,
+                        }
+                    });
+                }
+
+                $(component_definition! { @if_required $($required)? then {
+                    if this.$field.is_none() {
+                        return Err(Error {
+                            _inner: unused(_component_span.error("missing required modifier")),
+                            public:
+                                crate::error::InvalidFormatDescription::MissingRequiredModifier {
+                                    name: $parse_field,
+                                    index: _component_span.start.byte as _,
+                                }
+                        });
+                    }
+                }})*
+
+                Ok(this)
+            }
+        })*
+
+        impl From<$name> for crate::format_description::Component {
+            fn from(component: $name) -> Self {
+                match component {$(
+                    $name::$variant($variant { $($field),* }) => {
+                        $crate::format_description::component::Component::$variant(
+                            $crate::format_description::modifier::$variant {$(
+                                $target_field: component_definition! { @if_required $($required)?
+                                    then {
+                                        match $field {
+                                            Some(value) => value.into(),
+                                            None => bug!("required modifier was not set"),
+                                        }
+                                    } else {
+                                        $field.unwrap_or_default().into()
+                                    }
+                                }
+                            ),*}
+                        )
+                    }
+                )*}
+            }
+        }
+
+        /// Parse a component from the AST, given its name and modifiers.
+        fn component_from_ast(
+            name: &Spanned<&[u8]>,
+            modifiers: &[ast::Modifier<'_>],
+        ) -> Result<Component, Error> {
+            $(#[allow(clippy::string_lit_as_bytes)]
+            if name.eq_ignore_ascii_case($parse_variant.as_bytes()) {
+                return Ok(Component::$variant($variant::with_modifiers(&modifiers, name.span)?,));
+            })*
+            Err(Error {
+                _inner: unused(name.span.error("invalid component")),
+                public: crate::error::InvalidFormatDescription::InvalidComponentName {
+                    name: String::from_utf8_lossy(name).into_owned(),
+                    index: name.span.start.byte as _,
+                },
+            })
+        }
+    }
+}
+
+// Keep in alphabetical order.
+component_definition! {
+    pub(super) enum Component {
+        Day = "day" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        End = "end" {},
+        Hour = "hour" {
+            padding = "padding": Option<Padding> => padding,
+            base = "repr": Option<HourBase> => is_12_hour_clock,
+        },
+        Ignore = "ignore" {
+            #[required]
+            count = "count": Option<#[from_str] NonZeroU16> => count,
+        },
+        Minute = "minute" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Month = "month" {
+            padding = "padding": Option<Padding> => padding,
+            repr = "repr": Option<MonthRepr> => repr,
+            case_sensitive = "case_sensitive": Option<MonthCaseSensitive> => case_sensitive,
+        },
+        OffsetHour = "offset_hour" {
+            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
+            padding = "padding": Option<Padding> => padding,
+        },
+        OffsetMinute = "offset_minute" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        OffsetSecond = "offset_second" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Ordinal = "ordinal" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Period = "period" {
+            case = "case": Option<PeriodCase> => is_uppercase,
+            case_sensitive = "case_sensitive": Option<PeriodCaseSensitive> => case_sensitive,
+        },
+        Second = "second" {
+            padding = "padding": Option<Padding> => padding,
+        },
+        Subsecond = "subsecond" {
+            digits = "digits": Option<SubsecondDigits> => digits,
+        },
+        UnixTimestamp = "unix_timestamp" {
+            precision = "precision": Option<UnixTimestampPrecision> => precision,
+            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
+        },
+        Weekday = "weekday" {
+            repr = "repr": Option<WeekdayRepr> => repr,
+            one_indexed = "one_indexed": Option<WeekdayOneIndexed> => one_indexed,
+            case_sensitive = "case_sensitive": Option<WeekdayCaseSensitive> => case_sensitive,
+        },
+        WeekNumber = "week_number" {
+            padding = "padding": Option<Padding> => padding,
+            repr = "repr": Option<WeekNumberRepr> => repr,
+        },
+        Year = "year" {
+            padding = "padding": Option<Padding> => padding,
+            repr = "repr": Option<YearRepr> => repr,
+            base = "base": Option<YearBase> => iso_week_based,
+            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
+        },
+    }
+}
+
+/// Get the target type for a given enum.
+macro_rules! target_ty {
+    ($name:ident $type:ty) => {
+        $type
+    };
+    ($name:ident) => {
+        $crate::format_description::modifier::$name
+    };
+}
+
+/// Get the target value for a given enum.
+macro_rules! target_value {
+    ($name:ident $variant:ident $value:expr) => {
+        $value
+    };
+    ($name:ident $variant:ident) => {
+        $crate::format_description::modifier::$name::$variant
+    };
+}
+
+/// Declare the various modifiers.
+///
+/// For the general case, ordinary syntax can be used. Note that you _must_ declare a default
+/// variant. The only significant change is that the string representation of the variant must be
+/// provided after the variant name. For example, `Numerical = b"numerical"` declares a variant
+/// named `Numerical` with the string representation `b"numerical"`. This is the value that will be
+/// used when parsing the modifier. The value is not case sensitive.
+///
+/// If the type in the public API does not have the same name as the type in the internal
+/// representation, then the former must be specified in parenthesis after the internal name. For
+/// example, `HourBase(bool)` has an internal name "HourBase", but is represented as a boolean in
+/// the public API.
+///
+/// By default, the internal variant name is assumed to be the same as the public variant name. If
+/// this is not the case, the qualified path to the variant must be specified in parenthesis after
+/// the internal variant name. For example, `Twelve(true)` has an internal variant name "Twelve",
+/// but is represented as `true` in the public API.
+macro_rules! modifier {
+    ($(
+        enum $name:ident $(($target_ty:ty))? {
+            $(
+                $(#[$attr:meta])?
+                $variant:ident $(($target_value:expr))? = $parse_variant:literal
+            ),* $(,)?
+        }
+    )+) => {$(
+        #[derive(Default)]
+        enum $name {
+            $($(#[$attr])? $variant),*
+        }
+
+        impl $name {
+            /// Parse the modifier from its string representation.
+            fn from_modifier_value(value: &Spanned<&[u8]>) -> Result<Option<Self>, Error> {
+                $(if value.eq_ignore_ascii_case($parse_variant) {
+                    return Ok(Some(Self::$variant));
+                })*
+                Err(Error {
+                    _inner: unused(value.span.error("invalid modifier value")),
+                    public: crate::error::InvalidFormatDescription::InvalidModifier {
+                        value: String::from_utf8_lossy(value).into_owned(),
+                        index: value.span.start.byte as _,
+                    },
+                })
+            }
+        }
+
+        impl From<$name> for target_ty!($name $($target_ty)?) {
+            fn from(modifier: $name) -> Self {
+                match modifier {
+                    $($name::$variant => target_value!($name $variant $($target_value)?)),*
+                }
+            }
+        }
+    )+};
+}
+
+// Keep in alphabetical order.
+modifier! {
+    enum HourBase(bool) {
+        Twelve(true) = b"12",
+        #[default]
+        TwentyFour(false) = b"24",
+    }
+
+    enum MonthCaseSensitive(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum MonthRepr {
+        #[default]
+        Numerical = b"numerical",
+        Long = b"long",
+        Short = b"short",
+    }
+
+    enum Padding {
+        Space = b"space",
+        #[default]
+        Zero = b"zero",
+        None = b"none",
+    }
+
+    enum PeriodCase(bool) {
+        Lower(false) = b"lower",
+        #[default]
+        Upper(true) = b"upper",
+    }
+
+    enum PeriodCaseSensitive(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum SignBehavior(bool) {
+        #[default]
+        Automatic(false) = b"automatic",
+        Mandatory(true) = b"mandatory",
+    }
+
+    enum SubsecondDigits {
+        One = b"1",
+        Two = b"2",
+        Three = b"3",
+        Four = b"4",
+        Five = b"5",
+        Six = b"6",
+        Seven = b"7",
+        Eight = b"8",
+        Nine = b"9",
+        #[default]
+        OneOrMore = b"1+",
+    }
+
+    enum UnixTimestampPrecision {
+        #[default]
+        Second = b"second",
+        Millisecond = b"millisecond",
+        Microsecond = b"microsecond",
+        Nanosecond = b"nanosecond",
+    }
+
+    enum WeekNumberRepr {
+        #[default]
+        Iso = b"iso",
+        Sunday = b"sunday",
+        Monday = b"monday",
+    }
+
+    enum WeekdayCaseSensitive(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum WeekdayOneIndexed(bool) {
+        False(false) = b"false",
+        #[default]
+        True(true) = b"true",
+    }
+
+    enum WeekdayRepr {
+        Short = b"short",
+        #[default]
+        Long = b"long",
+        Sunday = b"sunday",
+        Monday = b"monday",
+    }
+
+    enum YearBase(bool) {
+        #[default]
+        Calendar(false) = b"calendar",
+        IsoWeek(true) = b"iso_week",
+    }
+
+    enum YearRepr {
+        #[default]
+        Full = b"full",
+        LastTwo = b"last_two",
+    }
+}
+
+/// Parse a modifier value using `FromStr`. Requires the modifier value to be valid UTF-8.
+fn parse_from_modifier_value<T: FromStr>(value: &Spanned<&[u8]>) -> Result<Option<T>, Error> {
+    str::from_utf8(value)
+        .ok()
+        .and_then(|val| val.parse::<T>().ok())
+        .map(|val| Some(val))
+        .ok_or_else(|| Error {
+            _inner: unused(value.span.error("invalid modifier value")),
+            public: crate::error::InvalidFormatDescription::InvalidModifier {
+                value: String::from_utf8_lossy(value).into_owned(),
+                index: value.span.start.byte as _,
+            },
+        })
+}
diff --git a/time/src/format_description/parse/lexer.rs b/time/src/format_description/parse/lexer.rs
new file mode 100644
index 000000000..2979fff9e
--- /dev/null
+++ b/time/src/format_description/parse/lexer.rs
@@ -0,0 +1,299 @@
+//! Lexer for parsing format descriptions.
+
+use core::iter;
+
+use super::{unused, Error, Location, Spanned, SpannedValue};
+
+/// An iterator over the lexed tokens.
+pub(super) struct Lexed<I: Iterator> {
+    /// The internal iterator.
+    iter: iter::Peekable<I>,
+}
+
+impl<I: Iterator> Iterator for Lexed<I> {
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+}
+
+impl<'iter, 'token: 'iter, I: Iterator<Item = Result<Token<'token>, Error>> + 'iter> Lexed<I> {
+    /// Peek at the next item in the iterator.
+    pub(super) fn peek(&mut self) -> Option<&I::Item> {
+        self.iter.peek()
+    }
+
+    /// Consume the next token if it is whitespace.
+    pub(super) fn next_if_whitespace(&mut self) -> Option<Spanned<&'token [u8]>> {
+        if let Some(&Ok(Token::ComponentPart {
+            kind: ComponentKind::Whitespace,
+            value,
+        })) = self.peek()
+        {
+            self.next(); // consume
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    /// Consume the next token if it is a component item that is not whitespace.
+    pub(super) fn next_if_not_whitespace(&mut self) -> Option<Spanned<&'token [u8]>> {
+        if let Some(&Ok(Token::ComponentPart {
+            kind: ComponentKind::NotWhitespace,
+            value,
+        })) = self.peek()
+        {
+            self.next(); // consume
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    /// Consume the next token if it is an opening bracket.
+    pub(super) fn next_if_opening_bracket(&mut self) -> Option<Location> {
+        if let Some(&Ok(Token::Bracket {
+            kind: BracketKind::Opening,
+            location,
+        })) = self.peek()
+        {
+            self.next(); // consume
+            Some(location)
+        } else {
+            None
+        }
+    }
+
+    /// Peek at the next token if it is a closing bracket.
+    pub(super) fn peek_closing_bracket(&'iter mut self) -> Option<&'iter Location> {
+        if let Some(Ok(Token::Bracket {
+            kind: BracketKind::Closing,
+            location,
+        })) = self.peek()
+        {
+            Some(location)
+        } else {
+            None
+        }
+    }
+
+    /// Consume the next token if it is a closing bracket.
+    pub(super) fn next_if_closing_bracket(&mut self) -> Option<Location> {
+        if let Some(&Ok(Token::Bracket {
+            kind: BracketKind::Closing,
+            location,
+        })) = self.peek()
+        {
+            self.next(); // consume
+            Some(location)
+        } else {
+            None
+        }
+    }
+}
+
+/// A token emitted by the lexer. There is no semantic meaning at this stage.
+pub(super) enum Token<'a> {
+    /// A literal string, formatted and parsed as-is.
+    Literal(Spanned<&'a [u8]>),
+    /// An opening or closing bracket. May or may not be the start or end of a component.
+    Bracket {
+        /// Whether the bracket is opening or closing.
+        kind: BracketKind,
+        /// Where the bracket was in the format string.
+        location: Location,
+    },
+    /// One part of a component. This could be its name, a modifier, or whitespace.
+    ComponentPart {
+        /// Whether the part is whitespace or not.
+        kind: ComponentKind,
+        /// The part itself.
+        value: Spanned<&'a [u8]>,
+    },
+}
+
+/// What type of bracket is present.
+pub(super) enum BracketKind {
+    /// An opening bracket: `[`
+    Opening,
+    /// A closing bracket: `]`
+    Closing,
+}
+
+/// Indicates whether the component is whitespace or not.
+pub(super) enum ComponentKind {
+    #[allow(clippy::missing_docs_in_private_items)]
+    Whitespace,
+    #[allow(clippy::missing_docs_in_private_items)]
+    NotWhitespace,
+}
+
+/// Attach [`Location`] information to each byte in the iterator.
+fn attach_location<'item>(
+    iter: impl Iterator<Item = &'item u8>,
+) -> impl Iterator<Item = (&'item u8, Location)> {
+    let mut byte_pos = 0;
+
+    iter.map(move |byte| {
+        let location = Location { byte: byte_pos };
+        byte_pos += 1;
+        (byte, location)
+    })
+}
+
+/// Parse the string into a series of [`Token`]s.
+///
+/// `VERSION` controls the version of the format description that is being parsed. Currently, this
+/// must be 1 or 2.
+///
+/// - When `VERSION` is 1, `[[` is the only escape sequence, resulting in a literal `[`.
+/// - When `VERSION` is 2, all escape sequences begin with `\`. The only characters that may
+///   currently follow are `\`, `[`, and `]`, all of which result in the literal character. All
+///   other characters result in a lex error.
+pub(super) fn lex<const VERSION: usize>(
+    mut input: &[u8],
+) -> Lexed<impl Iterator<Item = Result<Token<'_>, Error>>> {
+    validate_version!(VERSION);
+
+    let mut depth: u8 = 0;
+    let mut iter = attach_location(input.iter()).peekable();
+    let mut second_bracket_location = None;
+
+    let iter = iter::from_fn(move || {
+        // The flag is only set when version is zero.
+        if version!(..=1) {
+            // There is a flag set to emit the second half of an escaped bracket pair.
+            if let Some(location) = second_bracket_location.take() {
+                return Some(Ok(Token::Bracket {
+                    kind: BracketKind::Opening,
+                    location,
+                }));
+            }
+        }
+
+        Some(Ok(match iter.next()? {
+            // possible escape sequence
+            (b'\\', backslash_loc) if version!(2..) => {
+                match iter.next() {
+                    Some((b'\\' | b'[' | b']', char_loc)) => {
+                        // The escaped character is emitted as-is.
+                        let char = &input[1..2];
+                        input = &input[2..];
+                        if depth == 0 {
+                            Token::Literal(char.spanned(backslash_loc.to(char_loc)))
+                        } else {
+                            Token::ComponentPart {
+                                kind: ComponentKind::NotWhitespace,
+                                value: char.spanned(backslash_loc.to(char_loc)),
+                            }
+                        }
+                    }
+                    Some((_, loc)) => {
+                        return Some(Err(Error {
+                            _inner: unused(loc.error("invalid escape sequence")),
+                            public: crate::error::InvalidFormatDescription::Expected {
+                                what: "valid escape sequence",
+                                index: loc.byte as _,
+                            },
+                        }));
+                    }
+                    None => {
+                        return Some(Err(Error {
+                            _inner: unused(backslash_loc.error("unexpected end of input")),
+                            public: crate::error::InvalidFormatDescription::Expected {
+                                what: "valid escape sequence",
+                                index: backslash_loc.byte as _,
+                            },
+                        }));
+                    }
+                }
+            }
+            // potentially escaped opening bracket
+            (b'[', location) if version!(..=1) => {
+                if let Some((_, second_location)) = iter.next_if(|&(&byte, _)| byte == b'[') {
+                    // Escaped bracket. Store the location of the second so we can emit it later.
+                    second_bracket_location = Some(second_location);
+                    input = &input[2..];
+                } else {
+                    // opening bracket
+                    depth += 1;
+                    input = &input[1..];
+                }
+
+                Token::Bracket {
+                    kind: BracketKind::Opening,
+                    location,
+                }
+            }
+            // opening bracket
+            (b'[', location) => {
+                depth += 1;
+                input = &input[1..];
+
+                Token::Bracket {
+                    kind: BracketKind::Opening,
+                    location,
+                }
+            }
+            // closing bracket
+            (b']', location) if depth > 0 => {
+                depth -= 1;
+                input = &input[1..];
+
+                Token::Bracket {
+                    kind: BracketKind::Closing,
+                    location,
+                }
+            }
+            // literal
+            (_, start_location) if depth == 0 => {
+                let mut bytes = 1;
+                let mut end_location = start_location;
+
+                while let Some((_, location)) =
+                    iter.next_if(|&(&byte, _)| !((version!(2..) && byte == b'\\') || byte == b'['))
+                {
+                    end_location = location;
+                    bytes += 1;
+                }
+
+                let value = &input[..bytes];
+                input = &input[bytes..];
+
+                Token::Literal(value.spanned(start_location.to(end_location)))
+            }
+            // component part
+            (byte, start_location) => {
+                let mut bytes = 1;
+                let mut end_location = start_location;
+                let is_whitespace = byte.is_ascii_whitespace();
+
+                while let Some((_, location)) = iter.next_if(|&(byte, _)| {
+                    !matches!(byte, b'\\' | b'[' | b']')
+                        && is_whitespace == byte.is_ascii_whitespace()
+                }) {
+                    end_location = location;
+                    bytes += 1;
+                }
+
+                let value = &input[..bytes];
+                input = &input[bytes..];
+
+                Token::ComponentPart {
+                    kind: if is_whitespace {
+                        ComponentKind::Whitespace
+                    } else {
+                        ComponentKind::NotWhitespace
+                    },
+                    value: value.spanned(start_location.to(end_location)),
+                }
+            }
+        }))
+    });
+
+    Lexed {
+        iter: iter.peekable(),
+    }
+}
diff --git a/time/src/format_description/parse/mod.rs b/time/src/format_description/parse/mod.rs
new file mode 100644
index 000000000..702ba90d3
--- /dev/null
+++ b/time/src/format_description/parse/mod.rs
@@ -0,0 +1,245 @@
+//! Parser for format descriptions.
+
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+
+use crate::{error, format_description};
+
+/// A helper macro to make version restrictions simpler to read and write.
+macro_rules! version {
+    ($range:expr) => {
+        $range.contains(&VERSION)
+    };
+}
+
+/// A helper macro to statically validate the version (when used as a const parameter).
+macro_rules! validate_version {
+    ($version:ident) => {
+        #[allow(clippy::let_unit_value)]
+        let _ = $crate::format_description::parse::Version::<$version>::IS_VALID;
+    };
+}
+
+mod ast;
+mod format_item;
+mod lexer;
+
+/// A struct that is used to ensure that the version is valid.
+struct Version<const N: usize>;
+impl<const N: usize> Version<N> {
+    /// A constant that panics if the version is not valid. This results in a post-monomorphization
+    /// error.
+    const IS_VALID: () = assert!(N >= 1 && N <= 2);
+}
+
+/// Parse a sequence of items from the format description.
+///
+/// The syntax for the format description can be found in [the
+/// book](https://time-rs.github.io/book/api/format-description.html).
+///
+/// This function exists for backward compatibility reasons. It is equivalent to calling
+/// `parse_borrowed::<1>(s)`. In the future, this function will be deprecated in favor of
+/// `parse_borrowed`.
+pub fn parse(
+    s: &str,
+) -> Result<Vec<format_description::BorrowedFormatItem<'_>>, error::InvalidFormatDescription> {
+    parse_borrowed::<1>(s)
+}
+
+/// Parse a sequence of items from the format description.
+///
+/// The syntax for the format description can be found in [the
+/// book](https://time-rs.github.io/book/api/format-description.html). The version of the format
+/// description is provided as the const parameter. **It is recommended to use version 2.**
+pub fn parse_borrowed<const VERSION: usize>(
+    s: &str,
+) -> Result<Vec<format_description::BorrowedFormatItem<'_>>, error::InvalidFormatDescription> {
+    validate_version!(VERSION);
+    let mut lexed = lexer::lex::<VERSION>(s.as_bytes());
+    let ast = ast::parse::<_, VERSION>(&mut lexed);
+    let format_items = format_item::parse(ast);
+    Ok(format_items
+        .map(|res| res.and_then(TryInto::try_into))
+        .collect::<Result<_, _>>()?)
+}
+
+/// Parse a sequence of items from the format description.
+///
+/// The syntax for the format description can be found in [the
+/// book](https://time-rs.github.io/book/api/format-description.html). The version of the format
+/// description is provided as the const parameter.
+///
+/// Unlike [`parse`], this function returns [`OwnedFormatItem`], which owns its contents. This means
+/// that there is no lifetime that needs to be handled. **It is recommended to use version 2.**
+///
+/// [`OwnedFormatItem`]: crate::format_description::OwnedFormatItem
+pub fn parse_owned<const VERSION: usize>(
+    s: &str,
+) -> Result<crate::format_description::OwnedFormatItem, crate::error::InvalidFormatDescription> {
+    validate_version!(VERSION);
+    let mut lexed = lexer::lex::<VERSION>(s.as_bytes());
+    let ast = ast::parse::<_, VERSION>(&mut lexed);
+    let format_items = format_item::parse(ast);
+    let items: Box<[format_item::Item<'_>]> = format_items
+        .map(|res| res.map(Into::into))
+        .collect::<Result<Vec<_>, _>>()?
+        .into_boxed_slice();  // Convert Vec into a boxed slice
+    Ok(items.into())
+}
+
+/// A location within a string.
+#[derive(Clone, Copy)]
+struct Location {
+    /// The zero-indexed byte of the string.
+    byte: u32,
+}
+
+impl Location {
+    /// Create a new [`Span`] from `self` to `other`.
+    const fn to(self, end: Self) -> Span {
+        Span { start: self, end }
+    }
+
+    /// Offset the location by the provided amount.
+    ///
+    /// Note that this assumes the resulting location is on the same line as the original location.
+    #[must_use = "this does not modify the original value"]
+    const fn offset(&self, offset: u32) -> Self {
+        Self {
+            byte: self.byte + offset,
+        }
+    }
+
+    /// Create an error with the provided message at this location.
+    const fn error(self, message: &'static str) -> ErrorInner {
+        ErrorInner {
+            _message: message,
+            _span: Span {
+                start: self,
+                end: self,
+            },
+        }
+    }
+}
+
+/// A start and end point within a string.
+#[derive(Clone, Copy)]
+struct Span {
+    #[allow(clippy::missing_docs_in_private_items)]
+    start: Location,
+    #[allow(clippy::missing_docs_in_private_items)]
+    end: Location,
+}
+
+impl Span {
+    /// Obtain a `Span` pointing at the start of the pre-existing span.
+    #[must_use = "this does not modify the original value"]
+    const fn shrink_to_start(&self) -> Self {
+        Self {
+            start: self.start,
+            end: self.start,
+        }
+    }
+
+    /// Obtain a `Span` pointing at the end of the pre-existing span.
+    #[must_use = "this does not modify the original value"]
+    const fn shrink_to_end(&self) -> Self {
+        Self {
+            start: self.end,
+            end: self.end,
+        }
+    }
+
+    /// Obtain a `Span` that ends before the provided position of the pre-existing span.
+    #[must_use = "this does not modify the original value"]
+    const fn shrink_to_before(&self, pos: u32) -> Self {
+        Self {
+            start: self.start,
+            end: Location {
+                byte: self.start.byte + pos - 1,
+            },
+        }
+    }
+
+    /// Obtain a `Span` that starts after provided position to the end of the pre-existing span.
+    #[must_use = "this does not modify the original value"]
+    const fn shrink_to_after(&self, pos: u32) -> Self {
+        Self {
+            start: Location {
+                byte: self.start.byte + pos + 1,
+            },
+            end: self.end,
+        }
+    }
+
+    /// Create an error with the provided message at this span.
+    const fn error(self, message: &'static str) -> ErrorInner {
+        ErrorInner {
+            _message: message,
+            _span: self,
+        }
+    }
+}
+
+/// A value with an associated [`Span`].
+#[derive(Clone, Copy)]
+struct Spanned<T> {
+    /// The value.
+    value: T,
+    /// Where the value was in the format string.
+    span: Span,
+}
+
+impl<T> core::ops::Deref for Spanned<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+/// Helper trait to attach a [`Span`] to a value.
+trait SpannedValue: Sized {
+    /// Attach a [`Span`] to a value.
+    fn spanned(self, span: Span) -> Spanned<Self>;
+}
+
+impl<T> SpannedValue for T {
+    fn spanned(self, span: Span) -> Spanned<Self> {
+        Spanned { value: self, span }
+    }
+}
+
+/// The internal error type.
+struct ErrorInner {
+    /// The message displayed to the user.
+    _message: &'static str,
+    /// Where the error originated.
+    _span: Span,
+}
+
+/// A complete error description.
+struct Error {
+    /// The internal error.
+    _inner: Unused<ErrorInner>,
+    /// The error needed for interoperability with the rest of `time`.
+    public: error::InvalidFormatDescription,
+}
+
+impl From<Error> for error::InvalidFormatDescription {
+    fn from(error: Error) -> Self {
+        error.public
+    }
+}
+
+/// A value that may be used in the future, but currently is not.
+///
+/// This struct exists so that data can semantically be passed around without _actually_ passing it
+/// around. This way the data still exists if it is needed in the future.
+// `PhantomData` is not used directly because we don't want to introduce any trait implementations.
+struct Unused<T>(core::marker::PhantomData<T>);
+
+/// Indicate that a value is currently unused.
+fn unused<T>(_: T) -> Unused<T> {
+    Unused(core::marker::PhantomData)
+}
diff --git a/time/src/format_description/well_known/iso8601.rs b/time/src/format_description/well_known/iso8601.rs
new file mode 100644
index 000000000..6b8ff2ab6
--- /dev/null
+++ b/time/src/format_description/well_known/iso8601.rs
@@ -0,0 +1,257 @@
+//! The format described in ISO 8601.
+
+mod adt_hack;
+
+use core::num::NonZeroU8;
+
+#[doc(hidden, no_inline)]
+pub use self::adt_hack::DoNotRelyOnWhatThisIs;
+pub use self::adt_hack::EncodedConfig;
+
+/// The format described in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html).
+///
+/// This implementation is of ISO 8601-1:2019. It may not be compatible with other versions.
+///
+/// The const parameter `CONFIG` **must** be a value that was returned by [`Config::encode`].
+/// Passing any other value is **unspecified behavior**.
+///
+/// Example: 1997-11-21T09:55:06.000000000-06:00
+///
+/// # Examples
+#[cfg_attr(feature = "formatting", doc = "```rust")]
+#[cfg_attr(not(feature = "formatting"), doc = "```rust,ignore")]
+/// # use time::format_description::well_known::Iso8601;
+/// # use time_macros::datetime;
+/// assert_eq!(
+///     datetime!(1997-11-12 9:55:06 -6:00).format(&Iso8601::DEFAULT)?,
+///     "1997-11-12T09:55:06.000000000-06:00"
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct Iso8601<const CONFIG: EncodedConfig = { Config::DEFAULT.encode() }>;
+
+impl<const CONFIG: EncodedConfig> core::fmt::Debug for Iso8601<CONFIG> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Iso8601")
+            .field("config", &Config::decode(CONFIG))
+            .finish()
+    }
+}
+
+/// Define associated constants for `Iso8601`.
+macro_rules! define_assoc_consts {
+    ($($(#[$doc:meta])* $vis:vis const $const_name:ident = $format:expr;)*) => {$(
+        const $const_name: EncodedConfig = $format.encode();
+        impl Iso8601<$const_name> {
+            $(#[$doc])*
+            $vis const $const_name: Self = Self;
+        }
+    )*};
+}
+
+define_assoc_consts! {
+    /// An [`Iso8601`] with the default configuration.
+    ///
+    /// The following is the default behavior:
+    ///
+    /// - The configuration can be used for both formatting and parsing.
+    /// - The date, time, and UTC offset are all formatted.
+    /// - Separators (such as `-` and `:`) are included.
+    /// - The year contains four digits, such that the year must be between 0 and 9999.
+    /// - The date uses the calendar format.
+    /// - The time has precision to the second and nine decimal digits.
+    /// - The UTC offset has precision to the minute.
+    ///
+    /// If you need different behavior, use another associated constant. For full customization, use
+    /// [`Config::DEFAULT`] and [`Config`]'s methods to create a custom configuration.
+    pub const DEFAULT = Config::DEFAULT;
+    /// An [`Iso8601`] that can only be used for parsing. Using this to format a value is
+    /// unspecified behavior.
+    pub const PARSING = Config::PARSING;
+    /// An [`Iso8601`] that handles only the date, but is otherwise the same as [`Config::DEFAULT`].
+    pub const DATE = Config::DEFAULT.set_formatted_components(FormattedComponents::Date);
+    /// An [`Iso8601`] that handles only the time, but is otherwise the same as [`Config::DEFAULT`].
+    pub const TIME = Config::DEFAULT.set_formatted_components(FormattedComponents::Time);
+    /// An [`Iso8601`] that handles only the UTC offset, but is otherwise the same as
+    /// [`Config::DEFAULT`].
+    pub const OFFSET = Config::DEFAULT.set_formatted_components(FormattedComponents::Offset);
+    /// An [`Iso8601`] that handles the date and time, but is otherwise the same as
+    /// [`Config::DEFAULT`].
+    pub const DATE_TIME = Config::DEFAULT.set_formatted_components(FormattedComponents::DateTime);
+    /// An [`Iso8601`] that handles the date, time, and UTC offset. This is the same as
+    /// [`Config::DEFAULT`].
+    pub const DATE_TIME_OFFSET = Config::DEFAULT;
+    /// An [`Iso8601`] that handles the time and UTC offset, but is otherwise the same as
+    /// [`Config::DEFAULT`].
+    pub const TIME_OFFSET = Config::DEFAULT
+        .set_formatted_components(FormattedComponents::TimeOffset);
+}
+
+/// Which components to format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum FormattedComponents {
+    /// The configuration can only be used for parsing. Using this to format a value is
+    /// unspecified behavior.
+    None,
+    /// Format only the date.
+    Date,
+    /// Format only the time.
+    Time,
+    /// Format only the UTC offset.
+    Offset,
+    /// Format the date and time.
+    DateTime,
+    /// Format the date, time, and UTC offset.
+    DateTimeOffset,
+    /// Format the time and UTC offset.
+    TimeOffset,
+}
+
+/// Which format to use for the date.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DateKind {
+    /// Use the year-month-day format.
+    Calendar,
+    /// Use the year-week-weekday format.
+    Week,
+    /// Use the week-ordinal format.
+    Ordinal,
+}
+
+/// The precision and number of decimal digits present for the time.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TimePrecision {
+    /// Format the hour only. Minutes, seconds, and nanoseconds will be represented with the
+    /// specified number of decimal digits, if any.
+    Hour {
+        #[allow(missing_docs)]
+        decimal_digits: Option<NonZeroU8>,
+    },
+    /// Format the hour and minute. Seconds and nanoseconds will be represented with the specified
+    /// number of decimal digits, if any.
+    Minute {
+        #[allow(missing_docs)]
+        decimal_digits: Option<NonZeroU8>,
+    },
+    /// Format the hour, minute, and second. Nanoseconds will be represented with the specified
+    /// number of decimal digits, if any.
+    Second {
+        #[allow(missing_docs)]
+        decimal_digits: Option<NonZeroU8>,
+    },
+}
+
+/// The precision for the UTC offset.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OffsetPrecision {
+    /// Format only the offset hour. Requires the offset minute to be zero.
+    Hour,
+    /// Format both the offset hour and minute.
+    Minute,
+}
+
+/// Configuration for [`Iso8601`].
+// This is only used as a const generic, so there's no need to have a number of implementations on
+// it.
+#[allow(missing_copy_implementations)]
+#[doc(alias = "EncodedConfig")] // People will likely search for `EncodedConfig`, so show them this.
+#[derive(Debug)]
+pub struct Config {
+    /// Which components, if any, will be formatted.
+    pub(crate) formatted_components: FormattedComponents,
+    /// Whether the format contains separators (such as `-` or `:`).
+    pub(crate) use_separators: bool,
+    /// Whether the year is six digits.
+    pub(crate) year_is_six_digits: bool,
+    /// The format used for the date.
+    pub(crate) date_kind: DateKind,
+    /// The precision and number of decimal digits present for the time.
+    pub(crate) time_precision: TimePrecision,
+    /// The precision for the UTC offset.
+    pub(crate) offset_precision: OffsetPrecision,
+}
+
+impl Config {
+    /// A configuration for the [`Iso8601`] format.
+    ///
+    /// The following is the default behavior:
+    ///
+    /// - The configuration can be used for both formatting and parsing.
+    /// - The date, time, and UTC offset are all formatted.
+    /// - Separators (such as `-` and `:`) are included.
+    /// - The year contains four digits, such that the year must be between 0 and 9999.
+    /// - The date uses the calendar format.
+    /// - The time has precision to the second and nine decimal digits.
+    /// - The UTC offset has precision to the minute.
+    ///
+    /// If you need different behavior, use the setter methods on this struct.
+    pub const DEFAULT: Self = Self {
+        formatted_components: FormattedComponents::DateTimeOffset,
+        use_separators: true,
+        year_is_six_digits: false,
+        date_kind: DateKind::Calendar,
+        time_precision: TimePrecision::Second {
+            decimal_digits: NonZeroU8::new(9),
+        },
+        offset_precision: OffsetPrecision::Minute,
+    };
+
+    /// A configuration that can only be used for parsing. Using this to format a value is
+    /// unspecified behavior.
+    const PARSING: Self = Self {
+        formatted_components: FormattedComponents::None,
+        use_separators: false,
+        year_is_six_digits: false,
+        date_kind: DateKind::Calendar,
+        time_precision: TimePrecision::Hour {
+            decimal_digits: None,
+        },
+        offset_precision: OffsetPrecision::Hour,
+    };
+
+    /// Set whether the format the date, time, and/or UTC offset.
+    pub const fn set_formatted_components(self, formatted_components: FormattedComponents) -> Self {
+        Self {
+            formatted_components,
+            ..self
+        }
+    }
+
+    /// Set whether the format contains separators (such as `-` or `:`).
+    pub const fn set_use_separators(self, use_separators: bool) -> Self {
+        Self {
+            use_separators,
+            ..self
+        }
+    }
+
+    /// Set whether the year is six digits.
+    pub const fn set_year_is_six_digits(self, year_is_six_digits: bool) -> Self {
+        Self {
+            year_is_six_digits,
+            ..self
+        }
+    }
+
+    /// Set the format used for the date.
+    pub const fn set_date_kind(self, date_kind: DateKind) -> Self {
+        Self { date_kind, ..self }
+    }
+
+    /// Set the precision and number of decimal digits present for the time.
+    pub const fn set_time_precision(self, time_precision: TimePrecision) -> Self {
+        Self {
+            time_precision,
+            ..self
+        }
+    }
+
+    /// Set the precision for the UTC offset.
+    pub const fn set_offset_precision(self, offset_precision: OffsetPrecision) -> Self {
+        Self {
+            offset_precision,
+            ..self
+        }
+    }
+}
diff --git a/time/src/format_description/well_known/iso8601/adt_hack.rs b/time/src/format_description/well_known/iso8601/adt_hack.rs
new file mode 100644
index 000000000..12b1c725f
--- /dev/null
+++ b/time/src/format_description/well_known/iso8601/adt_hack.rs
@@ -0,0 +1,249 @@
+//! Hackery to work around not being able to use ADTs in const generics on stable.
+
+use core::num::NonZeroU8;
+
+#[cfg(feature = "formatting")]
+use super::Iso8601;
+use super::{Config, DateKind, FormattedComponents as FC, OffsetPrecision, TimePrecision};
+
+// This provides a way to include `EncodedConfig` in documentation without displaying the type it is
+// aliased to.
+#[doc(hidden)]
+pub type DoNotRelyOnWhatThisIs = u128;
+
+/// An encoded [`Config`] that can be used as a const parameter to [`Iso8601`](super::Iso8601).
+///
+/// The type this is aliased to must not be relied upon. It can change in any release without
+/// notice.
+pub type EncodedConfig = DoNotRelyOnWhatThisIs;
+
+#[cfg(feature = "formatting")]
+impl<const CONFIG: EncodedConfig> Iso8601<CONFIG> {
+    /// The user-provided configuration for the ISO 8601 format.
+    const CONFIG: Config = Config::decode(CONFIG);
+    /// Whether the date should be formatted.
+    pub(crate) const FORMAT_DATE: bool = matches!(
+        Self::CONFIG.formatted_components,
+        FC::Date | FC::DateTime | FC::DateTimeOffset
+    );
+    /// Whether the time should be formatted.
+    pub(crate) const FORMAT_TIME: bool = matches!(
+        Self::CONFIG.formatted_components,
+        FC::Time | FC::DateTime | FC::DateTimeOffset | FC::TimeOffset
+    );
+    /// Whether the UTC offset should be formatted.
+    pub(crate) const FORMAT_OFFSET: bool = matches!(
+        Self::CONFIG.formatted_components,
+        FC::Offset | FC::DateTimeOffset | FC::TimeOffset
+    );
+    /// Whether the year is six digits.
+    pub(crate) const YEAR_IS_SIX_DIGITS: bool = Self::CONFIG.year_is_six_digits;
+    /// Whether the format contains separators (such as `-` or `:`).
+    pub(crate) const USE_SEPARATORS: bool = Self::CONFIG.use_separators;
+    /// Which format to use for the date.
+    pub(crate) const DATE_KIND: DateKind = Self::CONFIG.date_kind;
+    /// The precision and number of decimal digits to use for the time.
+    pub(crate) const TIME_PRECISION: TimePrecision = Self::CONFIG.time_precision;
+    /// The precision for the UTC offset.
+    pub(crate) const OFFSET_PRECISION: OffsetPrecision = Self::CONFIG.offset_precision;
+}
+
+impl Config {
+    /// Encode the configuration, permitting it to be used as a const parameter of [`Iso8601`].
+    ///
+    /// The value returned by this method must only be used as a const parameter to [`Iso8601`]. Any
+    /// other usage is unspecified behavior.
+    pub const fn encode(&self) -> EncodedConfig {
+        let mut bytes = [0; EncodedConfig::BITS as usize / 8];
+
+        bytes[0] = match self.formatted_components {
+            FC::None => 0,
+            FC::Date => 1,
+            FC::Time => 2,
+            FC::Offset => 3,
+            FC::DateTime => 4,
+            FC::DateTimeOffset => 5,
+            FC::TimeOffset => 6,
+        };
+        bytes[1] = self.use_separators as _;
+        bytes[2] = self.year_is_six_digits as _;
+        bytes[3] = match self.date_kind {
+            DateKind::Calendar => 0,
+            DateKind::Week => 1,
+            DateKind::Ordinal => 2,
+        };
+        bytes[4] = match self.time_precision {
+            TimePrecision::Hour { .. } => 0,
+            TimePrecision::Minute { .. } => 1,
+            TimePrecision::Second { .. } => 2,
+        };
+        bytes[5] = match self.time_precision {
+            TimePrecision::Hour { decimal_digits }
+            | TimePrecision::Minute { decimal_digits }
+            | TimePrecision::Second { decimal_digits } => match decimal_digits {
+                None => 0,
+                Some(decimal_digits) => decimal_digits.get(),
+            },
+        };
+        bytes[6] = match self.offset_precision {
+            OffsetPrecision::Hour => 0,
+            OffsetPrecision::Minute => 1,
+        };
+
+        EncodedConfig::from_be_bytes(bytes)
+    }
+
+    /// Decode the configuration. The configuration must have been generated from
+    /// [`Config::encode`].
+    pub(super) const fn decode(encoded: EncodedConfig) -> Self {
+        let bytes = encoded.to_be_bytes();
+
+        let formatted_components = match bytes[0] {
+            0 => FC::None,
+            1 => FC::Date,
+            2 => FC::Time,
+            3 => FC::Offset,
+            4 => FC::DateTime,
+            5 => FC::DateTimeOffset,
+            6 => FC::TimeOffset,
+            _ => panic!("invalid configuration"),
+        };
+        let use_separators = match bytes[1] {
+            0 => false,
+            1 => true,
+            _ => panic!("invalid configuration"),
+        };
+        let year_is_six_digits = match bytes[2] {
+            0 => false,
+            1 => true,
+            _ => panic!("invalid configuration"),
+        };
+        let date_kind = match bytes[3] {
+            0 => DateKind::Calendar,
+            1 => DateKind::Week,
+            2 => DateKind::Ordinal,
+            _ => panic!("invalid configuration"),
+        };
+        let time_precision = match bytes[4] {
+            0 => TimePrecision::Hour {
+                decimal_digits: NonZeroU8::new(bytes[5]),
+            },
+            1 => TimePrecision::Minute {
+                decimal_digits: NonZeroU8::new(bytes[5]),
+            },
+            2 => TimePrecision::Second {
+                decimal_digits: NonZeroU8::new(bytes[5]),
+            },
+            _ => panic!("invalid configuration"),
+        };
+        let offset_precision = match bytes[6] {
+            0 => OffsetPrecision::Hour,
+            1 => OffsetPrecision::Minute,
+            _ => panic!("invalid configuration"),
+        };
+
+        // No `for` loops in `const fn`.
+        let mut idx = 7; // first unused byte
+        while idx < EncodedConfig::BITS as usize / 8 {
+            assert!(bytes[idx] == 0, "invalid configuration");
+            idx += 1;
+        }
+
+        Self {
+            formatted_components,
+            use_separators,
+            year_is_six_digits,
+            date_kind,
+            time_precision,
+            offset_precision,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    macro_rules! eq {
+        ($a:expr, $b:expr) => {{
+            let a = $a;
+            let b = $b;
+            a.formatted_components == b.formatted_components
+                && a.use_separators == b.use_separators
+                && a.year_is_six_digits == b.year_is_six_digits
+                && a.date_kind == b.date_kind
+                && a.time_precision == b.time_precision
+                && a.offset_precision == b.offset_precision
+        }};
+    }
+
+    #[test]
+    fn encoding_roundtrip() {
+        macro_rules! assert_roundtrip {
+            ($config:expr) => {
+                let config = $config;
+                let encoded = config.encode();
+                let decoded = Config::decode(encoded);
+                assert!(eq!(config, decoded));
+            };
+        }
+
+        assert_roundtrip!(Config::DEFAULT);
+        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::None));
+        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::Date));
+        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::Time));
+        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::Offset));
+        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::DateTime));
+        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::DateTimeOffset));
+        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::TimeOffset));
+        assert_roundtrip!(Config::DEFAULT.set_use_separators(false));
+        assert_roundtrip!(Config::DEFAULT.set_use_separators(true));
+        assert_roundtrip!(Config::DEFAULT.set_year_is_six_digits(false));
+        assert_roundtrip!(Config::DEFAULT.set_year_is_six_digits(true));
+        assert_roundtrip!(Config::DEFAULT.set_date_kind(DateKind::Calendar));
+        assert_roundtrip!(Config::DEFAULT.set_date_kind(DateKind::Week));
+        assert_roundtrip!(Config::DEFAULT.set_date_kind(DateKind::Ordinal));
+        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Hour {
+            decimal_digits: None,
+        }));
+        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Minute {
+            decimal_digits: None,
+        }));
+        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Second {
+            decimal_digits: None,
+        }));
+        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Hour {
+            decimal_digits: NonZeroU8::new(1),
+        }));
+        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Minute {
+            decimal_digits: NonZeroU8::new(1),
+        }));
+        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Second {
+            decimal_digits: NonZeroU8::new(1),
+        }));
+        assert_roundtrip!(Config::DEFAULT.set_offset_precision(OffsetPrecision::Hour));
+        assert_roundtrip!(Config::DEFAULT.set_offset_precision(OffsetPrecision::Minute));
+    }
+
+    macro_rules! assert_decode_fail {
+        ($encoding:expr) => {
+            assert!(
+                std::panic::catch_unwind(|| {
+                    Config::decode($encoding);
+                })
+                .is_err()
+            );
+        };
+    }
+
+    #[test]
+    fn decode_fail() {
+        assert_decode_fail!(0x07_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00);
+        assert_decode_fail!(0x00_02_00_00_00_00_00_00_00_00_00_00_00_00_00_00);
+        assert_decode_fail!(0x00_00_02_00_00_00_00_00_00_00_00_00_00_00_00_00);
+        assert_decode_fail!(0x00_00_00_03_00_00_00_00_00_00_00_00_00_00_00_00);
+        assert_decode_fail!(0x00_00_00_00_03_00_00_00_00_00_00_00_00_00_00_00);
+        assert_decode_fail!(0x00_00_00_00_00_00_02_00_00_00_00_00_00_00_00_00);
+        assert_decode_fail!(0x00_00_00_00_00_00_00_01_00_00_00_00_00_00_00_00);
+    }
+}
diff --git a/time/src/format_description/well_known/rfc2822.rs b/time/src/format_description/well_known/rfc2822.rs
new file mode 100644
index 000000000..3c890ab10
--- /dev/null
+++ b/time/src/format_description/well_known/rfc2822.rs
@@ -0,0 +1,30 @@
+//! The format described in RFC 2822.
+
+/// The format described in [RFC 2822](https://tools.ietf.org/html/rfc2822#section-3.3).
+///
+/// Example: Fri, 21 Nov 1997 09:55:06 -0600
+///
+/// # Examples
+#[cfg_attr(feature = "parsing", doc = "```rust")]
+#[cfg_attr(not(feature = "parsing"), doc = "```rust,ignore")]
+/// # use time::{format_description::well_known::Rfc2822, OffsetDateTime};
+/// use time_macros::datetime;
+/// assert_eq!(
+///     OffsetDateTime::parse("Sat, 12 Jun 1993 13:25:19 GMT", &Rfc2822)?,
+///     datetime!(1993-06-12 13:25:19 +00:00)
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+///
+#[cfg_attr(feature = "formatting", doc = "```rust")]
+#[cfg_attr(not(feature = "formatting"), doc = "```rust,ignore")]
+/// # use time::format_description::well_known::Rfc2822;
+/// # use time_macros::datetime;
+/// assert_eq!(
+///     datetime!(1997-11-21 09:55:06 -06:00).format(&Rfc2822)?,
+///     "Fri, 21 Nov 1997 09:55:06 -0600"
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Rfc2822;
diff --git a/time/src/format_description/well_known/rfc3339.rs b/time/src/format_description/well_known/rfc3339.rs
new file mode 100644
index 000000000..f0873cbac
--- /dev/null
+++ b/time/src/format_description/well_known/rfc3339.rs
@@ -0,0 +1,30 @@
+//! The format described in RFC 3339.
+
+/// The format described in [RFC 3339](https://tools.ietf.org/html/rfc3339#section-5.6).
+///
+/// Format example: 1985-04-12T23:20:50.52Z
+///
+/// # Examples
+#[cfg_attr(feature = "parsing", doc = "```rust")]
+#[cfg_attr(not(feature = "parsing"), doc = "```rust,ignore")]
+/// # use time::{format_description::well_known::Rfc3339, OffsetDateTime};
+/// # use time_macros::datetime;
+/// assert_eq!(
+///     OffsetDateTime::parse("1985-04-12T23:20:50.52Z", &Rfc3339)?,
+///     datetime!(1985-04-12 23:20:50.52 +00:00)
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+///
+#[cfg_attr(feature = "formatting", doc = "```rust")]
+#[cfg_attr(not(feature = "formatting"), doc = "```rust,ignore")]
+/// # use time::format_description::well_known::Rfc3339;
+/// # use time_macros::datetime;
+/// assert_eq!(
+///     datetime!(1985-04-12 23:20:50.52 +00:00).format(&Rfc3339)?,
+///     "1985-04-12T23:20:50.52Z"
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Rfc3339;
diff --git a/time/src/formatting/formattable.rs b/time/src/formatting/formattable.rs
new file mode 100644
index 000000000..7cfa9301e
--- /dev/null
+++ b/time/src/formatting/formattable.rs
@@ -0,0 +1,317 @@
+//! A trait that can be used to format an item from its components.
+
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::ops::Deref;
+use std::io;
+
+use num_conv::prelude::*;
+
+use crate::format_description::well_known::iso8601::EncodedConfig;
+use crate::format_description::well_known::{Iso8601, Rfc2822, Rfc3339};
+use crate::format_description::{BorrowedFormatItem, OwnedFormatItem};
+use crate::formatting::{
+    format_component, format_number_pad_zero, iso8601, write, MONTH_NAMES, WEEKDAY_NAMES,
+};
+use crate::{error, Date, Time, UtcOffset};
+
+/// A type that describes a format.
+///
+/// Implementors of [`Formattable`] are [format descriptions](crate::format_description).
+///
+/// [`Date::format`] and [`Time::format`] each use a format description to generate
+/// a String from their data. See the respective methods for usage examples.
+#[cfg_attr(docsrs, doc(notable_trait))]
+pub trait Formattable: sealed::Sealed {}
+impl Formattable for BorrowedFormatItem<'_> {}
+impl Formattable for [BorrowedFormatItem<'_>] {}
+impl Formattable for OwnedFormatItem {}
+impl Formattable for [OwnedFormatItem] {}
+impl Formattable for Rfc3339 {}
+impl Formattable for Rfc2822 {}
+impl<const CONFIG: EncodedConfig> Formattable for Iso8601<CONFIG> {}
+impl<T: Deref> Formattable for T where T::Target: Formattable {}
+
+/// Seal the trait to prevent downstream users from implementing it.
+mod sealed {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Format the item using a format description, the intended output, and the various components.
+    pub trait Sealed {
+        /// Format the item into the provided output, returning the number of bytes written.
+        fn format_into(
+            &self,
+            output: &mut impl io::Write,
+            date: Option<Date>,
+            time: Option<Time>,
+            offset: Option<UtcOffset>,
+        ) -> Result<usize, error::Format>;
+
+        /// Format the item directly to a `String`.
+        fn format(
+            &self,
+            date: Option<Date>,
+            time: Option<Time>,
+            offset: Option<UtcOffset>,
+        ) -> Result<String, error::Format> {
+            let mut buf = Vec::new();
+            self.format_into(&mut buf, date, time, offset)?;
+            Ok(String::from_utf8_lossy(&buf).into_owned())
+        }
+    }
+}
+
+// region: custom formats
+impl sealed::Sealed for BorrowedFormatItem<'_> {
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        Ok(match *self {
+            Self::Literal(literal) => write(output, literal)?,
+            Self::Component(component) => format_component(output, component, date, time, offset)?,
+            Self::Compound(items) => items.format_into(output, date, time, offset)?,
+            Self::Optional(item) => item.format_into(output, date, time, offset)?,
+            Self::First(items) => match items {
+                [] => 0,
+                [item, ..] => item.format_into(output, date, time, offset)?,
+            },
+        })
+    }
+}
+
+impl sealed::Sealed for [BorrowedFormatItem<'_>] {
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        let mut bytes = 0;
+        for item in self.iter() {
+            bytes += item.format_into(output, date, time, offset)?;
+        }
+        Ok(bytes)
+    }
+}
+
+impl sealed::Sealed for OwnedFormatItem {
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        match self {
+            Self::Literal(literal) => Ok(write(output, literal)?),
+            Self::Component(component) => format_component(output, *component, date, time, offset),
+            Self::Compound(items) => items.format_into(output, date, time, offset),
+            Self::Optional(item) => item.format_into(output, date, time, offset),
+            Self::First(items) => match &**items {
+                [] => Ok(0),
+                [item, ..] => item.format_into(output, date, time, offset),
+            },
+        }
+    }
+}
+
+impl sealed::Sealed for [OwnedFormatItem] {
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        let mut bytes = 0;
+        for item in self.iter() {
+            bytes += item.format_into(output, date, time, offset)?;
+        }
+        Ok(bytes)
+    }
+}
+
+impl<T: Deref> sealed::Sealed for T
+where
+    T::Target: sealed::Sealed,
+{
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        self.deref().format_into(output, date, time, offset)
+    }
+}
+// endregion custom formats
+
+// region: well-known formats
+impl sealed::Sealed for Rfc2822 {
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        let date = date.ok_or(error::Format::InsufficientTypeInformation)?;
+        let time = time.ok_or(error::Format::InsufficientTypeInformation)?;
+        let offset = offset.ok_or(error::Format::InsufficientTypeInformation)?;
+
+        let mut bytes = 0;
+
+        let (year, month, day) = date.to_calendar_date();
+
+        if year < 1900 {
+            return Err(error::Format::InvalidComponent("year"));
+        }
+        if offset.seconds_past_minute() != 0 {
+            return Err(error::Format::InvalidComponent("offset_second"));
+        }
+
+        bytes += write(
+            output,
+            &WEEKDAY_NAMES[date.weekday().number_days_from_monday().extend::<usize>()][..3],
+        )?;
+        bytes += write(output, b", ")?;
+        bytes += format_number_pad_zero::<2>(output, day)?;
+        bytes += write(output, b" ")?;
+        bytes += write(
+            output,
+            &MONTH_NAMES[u8::from(month).extend::<usize>() - 1][..3],
+        )?;
+        bytes += write(output, b" ")?;
+        bytes += format_number_pad_zero::<4>(output, year.cast_unsigned())?;
+        bytes += write(output, b" ")?;
+        bytes += format_number_pad_zero::<2>(output, time.hour())?;
+        bytes += write(output, b":")?;
+        bytes += format_number_pad_zero::<2>(output, time.minute())?;
+        bytes += write(output, b":")?;
+        bytes += format_number_pad_zero::<2>(output, time.second())?;
+        bytes += write(output, b" ")?;
+        bytes += write(output, if offset.is_negative() { b"-" } else { b"+" })?;
+        bytes += format_number_pad_zero::<2>(output, offset.whole_hours().unsigned_abs())?;
+        bytes += format_number_pad_zero::<2>(output, offset.minutes_past_hour().unsigned_abs())?;
+
+        Ok(bytes)
+    }
+}
+
+impl sealed::Sealed for Rfc3339 {
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        let date = date.ok_or(error::Format::InsufficientTypeInformation)?;
+        let time = time.ok_or(error::Format::InsufficientTypeInformation)?;
+        let offset = offset.ok_or(error::Format::InsufficientTypeInformation)?;
+
+        let mut bytes = 0;
+
+        let year = date.year();
+
+        if !(0..10_000).contains(&year) {
+            return Err(error::Format::InvalidComponent("year"));
+        }
+        if offset.whole_hours().unsigned_abs() > 23 {
+            return Err(error::Format::InvalidComponent("offset_hour"));
+        }
+        if offset.seconds_past_minute() != 0 {
+            return Err(error::Format::InvalidComponent("offset_second"));
+        }
+
+        bytes += format_number_pad_zero::<4>(output, year.cast_unsigned())?;
+        bytes += write(output, b"-")?;
+        bytes += format_number_pad_zero::<2>(output, u8::from(date.month()))?;
+        bytes += write(output, b"-")?;
+        bytes += format_number_pad_zero::<2>(output, date.day())?;
+        bytes += write(output, b"T")?;
+        bytes += format_number_pad_zero::<2>(output, time.hour())?;
+        bytes += write(output, b":")?;
+        bytes += format_number_pad_zero::<2>(output, time.minute())?;
+        bytes += write(output, b":")?;
+        bytes += format_number_pad_zero::<2>(output, time.second())?;
+
+        #[allow(clippy::if_not_else)]
+        if time.nanosecond() != 0 {
+            let nanos = time.nanosecond();
+            bytes += write(output, b".")?;
+            bytes += if nanos % 10 != 0 {
+                format_number_pad_zero::<9>(output, nanos)
+            } else if (nanos / 10) % 10 != 0 {
+                format_number_pad_zero::<8>(output, nanos / 10)
+            } else if (nanos / 100) % 10 != 0 {
+                format_number_pad_zero::<7>(output, nanos / 100)
+            } else if (nanos / 1_000) % 10 != 0 {
+                format_number_pad_zero::<6>(output, nanos / 1_000)
+            } else if (nanos / 10_000) % 10 != 0 {
+                format_number_pad_zero::<5>(output, nanos / 10_000)
+            } else if (nanos / 100_000) % 10 != 0 {
+                format_number_pad_zero::<4>(output, nanos / 100_000)
+            } else if (nanos / 1_000_000) % 10 != 0 {
+                format_number_pad_zero::<3>(output, nanos / 1_000_000)
+            } else if (nanos / 10_000_000) % 10 != 0 {
+                format_number_pad_zero::<2>(output, nanos / 10_000_000)
+            } else {
+                format_number_pad_zero::<1>(output, nanos / 100_000_000)
+            }?;
+        }
+
+        if offset == UtcOffset::UTC {
+            bytes += write(output, b"Z")?;
+            return Ok(bytes);
+        }
+
+        bytes += write(output, if offset.is_negative() { b"-" } else { b"+" })?;
+        bytes += format_number_pad_zero::<2>(output, offset.whole_hours().unsigned_abs())?;
+        bytes += write(output, b":")?;
+        bytes += format_number_pad_zero::<2>(output, offset.minutes_past_hour().unsigned_abs())?;
+
+        Ok(bytes)
+    }
+}
+
+impl<const CONFIG: EncodedConfig> sealed::Sealed for Iso8601<CONFIG> {
+    fn format_into(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        let mut bytes = 0;
+
+        if Self::FORMAT_DATE {
+            let date = date.ok_or(error::Format::InsufficientTypeInformation)?;
+            bytes += iso8601::format_date::<CONFIG>(output, date)?;
+        }
+        if Self::FORMAT_TIME {
+            let time = time.ok_or(error::Format::InsufficientTypeInformation)?;
+            bytes += iso8601::format_time::<CONFIG>(output, time)?;
+        }
+        if Self::FORMAT_OFFSET {
+            let offset = offset.ok_or(error::Format::InsufficientTypeInformation)?;
+            bytes += iso8601::format_offset::<CONFIG>(output, offset)?;
+        }
+
+        if bytes == 0 {
+            // The only reason there would be no bytes written is if the format was only for
+            // parsing.
+            panic!("attempted to format a parsing-only format description");
+        }
+
+        Ok(bytes)
+    }
+}
+// endregion well-known formats
diff --git a/time/src/formatting/iso8601.rs b/time/src/formatting/iso8601.rs
new file mode 100644
index 000000000..ee49d7d89
--- /dev/null
+++ b/time/src/formatting/iso8601.rs
@@ -0,0 +1,142 @@
+//! Helpers for implementing formatting for ISO 8601.
+
+use std::io;
+
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::format_description::well_known::iso8601::{
+    DateKind, EncodedConfig, OffsetPrecision, TimePrecision,
+};
+use crate::format_description::well_known::Iso8601;
+use crate::formatting::{format_float, format_number_pad_zero, write, write_if, write_if_else};
+use crate::{error, Date, Time, UtcOffset};
+
+/// Format the date portion of ISO 8601.
+pub(super) fn format_date<const CONFIG: EncodedConfig>(
+    output: &mut impl io::Write,
+    date: Date,
+) -> Result<usize, error::Format> {
+    let mut bytes = 0;
+
+    match Iso8601::<CONFIG>::DATE_KIND {
+        DateKind::Calendar => {
+            let (year, month, day) = date.to_calendar_date();
+            if Iso8601::<CONFIG>::YEAR_IS_SIX_DIGITS {
+                bytes += write_if_else(output, year < 0, b"-", b"+")?;
+                bytes += format_number_pad_zero::<6>(output, year.unsigned_abs())?;
+            } else if !(0..=9999).contains(&year) {
+                return Err(error::Format::InvalidComponent("year"));
+            } else {
+                bytes += format_number_pad_zero::<4>(output, year.cast_unsigned())?;
+            }
+            bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b"-")?;
+            bytes += format_number_pad_zero::<2>(output, u8::from(month))?;
+            bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b"-")?;
+            bytes += format_number_pad_zero::<2>(output, day)?;
+        }
+        DateKind::Week => {
+            let (year, week, day) = date.to_iso_week_date();
+            if Iso8601::<CONFIG>::YEAR_IS_SIX_DIGITS {
+                bytes += write_if_else(output, year < 0, b"-", b"+")?;
+                bytes += format_number_pad_zero::<6>(output, year.unsigned_abs())?;
+            } else if !(0..=9999).contains(&year) {
+                return Err(error::Format::InvalidComponent("year"));
+            } else {
+                bytes += format_number_pad_zero::<4>(output, year.cast_unsigned())?;
+            }
+            bytes += write_if_else(output, Iso8601::<CONFIG>::USE_SEPARATORS, b"-W", b"W")?;
+            bytes += format_number_pad_zero::<2>(output, week)?;
+            bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b"-")?;
+            bytes += format_number_pad_zero::<1>(output, day.number_from_monday())?;
+        }
+        DateKind::Ordinal => {
+            let (year, day) = date.to_ordinal_date();
+            if Iso8601::<CONFIG>::YEAR_IS_SIX_DIGITS {
+                bytes += write_if_else(output, year < 0, b"-", b"+")?;
+                bytes += format_number_pad_zero::<6>(output, year.unsigned_abs())?;
+            } else if !(0..=9999).contains(&year) {
+                return Err(error::Format::InvalidComponent("year"));
+            } else {
+                bytes += format_number_pad_zero::<4>(output, year.cast_unsigned())?;
+            }
+            bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b"-")?;
+            bytes += format_number_pad_zero::<3>(output, day)?;
+        }
+    }
+
+    Ok(bytes)
+}
+
+/// Format the time portion of ISO 8601.
+pub(super) fn format_time<const CONFIG: EncodedConfig>(
+    output: &mut impl io::Write,
+    time: Time,
+) -> Result<usize, error::Format> {
+    let mut bytes = 0;
+
+    // The "T" can only be omitted in extended format where there is no date being formatted.
+    bytes += write_if(
+        output,
+        Iso8601::<CONFIG>::USE_SEPARATORS || Iso8601::<CONFIG>::FORMAT_DATE,
+        b"T",
+    )?;
+
+    let (hours, minutes, seconds, nanoseconds) = time.as_hms_nano();
+
+    match Iso8601::<CONFIG>::TIME_PRECISION {
+        TimePrecision::Hour { decimal_digits } => {
+            let hours = (hours as f64)
+                + (minutes as f64) / Minute::per(Hour) as f64
+                + (seconds as f64) / Second::per(Hour) as f64
+                + (nanoseconds as f64) / Nanosecond::per(Hour) as f64;
+            format_float(output, hours, 2, decimal_digits)?;
+        }
+        TimePrecision::Minute { decimal_digits } => {
+            bytes += format_number_pad_zero::<2>(output, hours)?;
+            bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b":")?;
+            let minutes = (minutes as f64)
+                + (seconds as f64) / Second::per(Minute) as f64
+                + (nanoseconds as f64) / Nanosecond::per(Minute) as f64;
+            bytes += format_float(output, minutes, 2, decimal_digits)?;
+        }
+        TimePrecision::Second { decimal_digits } => {
+            bytes += format_number_pad_zero::<2>(output, hours)?;
+            bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b":")?;
+            bytes += format_number_pad_zero::<2>(output, minutes)?;
+            bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b":")?;
+            let seconds = (seconds as f64) + (nanoseconds as f64) / Nanosecond::per(Second) as f64;
+            bytes += format_float(output, seconds, 2, decimal_digits)?;
+        }
+    }
+
+    Ok(bytes)
+}
+
+/// Format the UTC offset portion of ISO 8601.
+pub(super) fn format_offset<const CONFIG: EncodedConfig>(
+    output: &mut impl io::Write,
+    offset: UtcOffset,
+) -> Result<usize, error::Format> {
+    if Iso8601::<CONFIG>::FORMAT_TIME && offset.is_utc() {
+        return Ok(write(output, b"Z")?);
+    }
+
+    let mut bytes = 0;
+
+    let (hours, minutes, seconds) = offset.as_hms();
+    if seconds != 0 {
+        return Err(error::Format::InvalidComponent("offset_second"));
+    }
+    bytes += write_if_else(output, offset.is_negative(), b"-", b"+")?;
+    bytes += format_number_pad_zero::<2>(output, hours.unsigned_abs())?;
+
+    if Iso8601::<CONFIG>::OFFSET_PRECISION == OffsetPrecision::Hour && minutes != 0 {
+        return Err(error::Format::InvalidComponent("offset_minute"));
+    } else if Iso8601::<CONFIG>::OFFSET_PRECISION == OffsetPrecision::Minute {
+        bytes += write_if(output, Iso8601::<CONFIG>::USE_SEPARATORS, b":")?;
+        bytes += format_number_pad_zero::<2>(output, minutes.unsigned_abs())?;
+    }
+
+    Ok(bytes)
+}
diff --git a/time/src/formatting/mod.rs b/time/src/formatting/mod.rs
new file mode 100644
index 000000000..f5a6de58e
--- /dev/null
+++ b/time/src/formatting/mod.rs
@@ -0,0 +1,493 @@
+//! Formatting for various types.
+
+pub(crate) mod formattable;
+mod iso8601;
+
+use core::num::NonZeroU8;
+use std::io;
+
+use num_conv::prelude::*;
+
+pub use self::formattable::Formattable;
+use crate::convert::*;
+use crate::ext::DigitCount;
+use crate::format_description::{modifier, Component};
+use crate::{error, Date, OffsetDateTime, Time, UtcOffset};
+
+#[allow(clippy::missing_docs_in_private_items)]
+const MONTH_NAMES: [&[u8]; 12] = [
+    b"January",
+    b"February",
+    b"March",
+    b"April",
+    b"May",
+    b"June",
+    b"July",
+    b"August",
+    b"September",
+    b"October",
+    b"November",
+    b"December",
+];
+
+#[allow(clippy::missing_docs_in_private_items)]
+const WEEKDAY_NAMES: [&[u8]; 7] = [
+    b"Monday",
+    b"Tuesday",
+    b"Wednesday",
+    b"Thursday",
+    b"Friday",
+    b"Saturday",
+    b"Sunday",
+];
+
+/// Write all bytes to the output, returning the number of bytes written.
+pub(crate) fn write(output: &mut impl io::Write, bytes: &[u8]) -> io::Result<usize> {
+    output.write_all(bytes)?;
+    Ok(bytes.len())
+}
+
+/// If `pred` is true, write all bytes to the output, returning the number of bytes written.
+pub(crate) fn write_if(output: &mut impl io::Write, pred: bool, bytes: &[u8]) -> io::Result<usize> {
+    if pred { write(output, bytes) } else { Ok(0) }
+}
+
+/// If `pred` is true, write `true_bytes` to the output. Otherwise, write `false_bytes`.
+pub(crate) fn write_if_else(
+    output: &mut impl io::Write,
+    pred: bool,
+    true_bytes: &[u8],
+    false_bytes: &[u8],
+) -> io::Result<usize> {
+    write(output, if pred { true_bytes } else { false_bytes })
+}
+
+/// Write the floating point number to the output, returning the number of bytes written.
+///
+/// This method accepts the number of digits before and after the decimal. The value will be padded
+/// with zeroes to the left if necessary.
+pub(crate) fn format_float(
+    output: &mut impl io::Write,
+    value: f64,
+    digits_before_decimal: u8,
+    digits_after_decimal: Option<NonZeroU8>,
+) -> io::Result<usize> {
+    match digits_after_decimal {
+        Some(digits_after_decimal) => {
+            // Truncate the decimal points up to the precision
+            let trunc_num = 10_f64.powi(digits_after_decimal.get().cast_signed().extend());
+            let value = f64::trunc(value * trunc_num) / trunc_num;
+
+            let digits_after_decimal = digits_after_decimal.get().extend();
+            let width = digits_before_decimal.extend::<usize>() + 1 + digits_after_decimal;
+            write!(output, "{value:0>width$.digits_after_decimal$}")?;
+            Ok(width)
+        }
+        None => {
+            let value = value.trunc() as u64;
+            let width = digits_before_decimal.extend();
+            write!(output, "{value:0>width$}")?;
+            Ok(width)
+        }
+    }
+}
+
+/// Format a number with the provided padding and width.
+///
+/// The sign must be written by the caller.
+pub(crate) fn format_number<const WIDTH: u8>(
+    output: &mut impl io::Write,
+    value: impl itoa::Integer + DigitCount + Copy,
+    padding: modifier::Padding,
+) -> Result<usize, io::Error> {
+    match padding {
+        modifier::Padding::Space => format_number_pad_space::<WIDTH>(output, value),
+        modifier::Padding::Zero => format_number_pad_zero::<WIDTH>(output, value),
+        modifier::Padding::None => format_number_pad_none(output, value),
+    }
+}
+
+/// Format a number with the provided width and spaces as padding.
+///
+/// The sign must be written by the caller.
+pub(crate) fn format_number_pad_space<const WIDTH: u8>(
+    output: &mut impl io::Write,
+    value: impl itoa::Integer + DigitCount + Copy,
+) -> Result<usize, io::Error> {
+    let mut bytes = 0;
+    for _ in 0..(WIDTH.saturating_sub(value.num_digits())) {
+        bytes += write(output, b" ")?;
+    }
+    bytes += write(output, itoa::Buffer::new().format(value).as_bytes())?;
+    Ok(bytes)
+}
+
+/// Format a number with the provided width and zeros as padding.
+///
+/// The sign must be written by the caller.
+pub(crate) fn format_number_pad_zero<const WIDTH: u8>(
+    output: &mut impl io::Write,
+    value: impl itoa::Integer + DigitCount + Copy,
+) -> Result<usize, io::Error> {
+    let mut bytes = 0;
+    for _ in 0..(WIDTH.saturating_sub(value.num_digits())) {
+        bytes += write(output, b"0")?;
+    }
+    bytes += write(output, itoa::Buffer::new().format(value).as_bytes())?;
+    Ok(bytes)
+}
+
+/// Format a number with no padding.
+///
+/// If the sign is mandatory, the sign must be written by the caller.
+pub(crate) fn format_number_pad_none(
+    output: &mut impl io::Write,
+    value: impl itoa::Integer + Copy,
+) -> Result<usize, io::Error> {
+    write(output, itoa::Buffer::new().format(value).as_bytes())
+}
+
+/// Format the provided component into the designated output. An `Err` will be returned if the
+/// component requires information that it does not provide or if the value cannot be output to the
+/// stream.
+pub(crate) fn format_component(
+    output: &mut impl io::Write,
+    component: Component,
+    date: Option<Date>,
+    time: Option<Time>,
+    offset: Option<UtcOffset>,
+) -> Result<usize, error::Format> {
+    use Component::*;
+    Ok(match (component, date, time, offset) {
+        (Day(modifier), Some(date), ..) => fmt_day(output, date, modifier)?,
+        (Month(modifier), Some(date), ..) => fmt_month(output, date, modifier)?,
+        (Ordinal(modifier), Some(date), ..) => fmt_ordinal(output, date, modifier)?,
+        (Weekday(modifier), Some(date), ..) => fmt_weekday(output, date, modifier)?,
+        (WeekNumber(modifier), Some(date), ..) => fmt_week_number(output, date, modifier)?,
+        (Year(modifier), Some(date), ..) => fmt_year(output, date, modifier)?,
+        (Hour(modifier), _, Some(time), _) => fmt_hour(output, time, modifier)?,
+        (Minute(modifier), _, Some(time), _) => fmt_minute(output, time, modifier)?,
+        (Period(modifier), _, Some(time), _) => fmt_period(output, time, modifier)?,
+        (Second(modifier), _, Some(time), _) => fmt_second(output, time, modifier)?,
+        (Subsecond(modifier), _, Some(time), _) => fmt_subsecond(output, time, modifier)?,
+        (OffsetHour(modifier), .., Some(offset)) => fmt_offset_hour(output, offset, modifier)?,
+        (OffsetMinute(modifier), .., Some(offset)) => fmt_offset_minute(output, offset, modifier)?,
+        (OffsetSecond(modifier), .., Some(offset)) => fmt_offset_second(output, offset, modifier)?,
+        (Ignore(_), ..) => 0,
+        (UnixTimestamp(modifier), Some(date), Some(time), Some(offset)) => {
+            fmt_unix_timestamp(output, date, time, offset, modifier)?
+        }
+        (End(modifier::End {}), ..) => 0,
+
+        // This is functionally the same as a wildcard arm, but it will cause an error if a new
+        // component is added. This is to avoid a bug where a new component, the code compiles, and
+        // formatting fails.
+        // Allow unreachable patterns because some branches may be fully matched above.
+        #[allow(unreachable_patterns)]
+        (
+            Day(_) | Month(_) | Ordinal(_) | Weekday(_) | WeekNumber(_) | Year(_) | Hour(_)
+            | Minute(_) | Period(_) | Second(_) | Subsecond(_) | OffsetHour(_) | OffsetMinute(_)
+            | OffsetSecond(_) | Ignore(_) | UnixTimestamp(_) | End(_),
+            ..,
+        ) => return Err(error::Format::InsufficientTypeInformation),
+    })
+}
+
+// region: date formatters
+/// Format the day into the designated output.
+fn fmt_day(
+    output: &mut impl io::Write,
+    date: Date,
+    modifier::Day { padding }: modifier::Day,
+) -> Result<usize, io::Error> {
+    format_number::<2>(output, date.day(), padding)
+}
+
+/// Format the month into the designated output.
+fn fmt_month(
+    output: &mut impl io::Write,
+    date: Date,
+    modifier::Month {
+        padding,
+        repr,
+        case_sensitive: _, // no effect on formatting
+    }: modifier::Month,
+) -> Result<usize, io::Error> {
+    match repr {
+        modifier::MonthRepr::Numerical => {
+            format_number::<2>(output, u8::from(date.month()), padding)
+        }
+        modifier::MonthRepr::Long => write(
+            output,
+            MONTH_NAMES[u8::from(date.month()).extend::<usize>() - 1],
+        ),
+        modifier::MonthRepr::Short => write(
+            output,
+            &MONTH_NAMES[u8::from(date.month()).extend::<usize>() - 1][..3],
+        ),
+    }
+}
+
+/// Format the ordinal into the designated output.
+fn fmt_ordinal(
+    output: &mut impl io::Write,
+    date: Date,
+    modifier::Ordinal { padding }: modifier::Ordinal,
+) -> Result<usize, io::Error> {
+    format_number::<3>(output, date.ordinal(), padding)
+}
+
+/// Format the weekday into the designated output.
+fn fmt_weekday(
+    output: &mut impl io::Write,
+    date: Date,
+    modifier::Weekday {
+        repr,
+        one_indexed,
+        case_sensitive: _, // no effect on formatting
+    }: modifier::Weekday,
+) -> Result<usize, io::Error> {
+    match repr {
+        modifier::WeekdayRepr::Short => write(
+            output,
+            &WEEKDAY_NAMES[date.weekday().number_days_from_monday().extend::<usize>()][..3],
+        ),
+        modifier::WeekdayRepr::Long => write(
+            output,
+            WEEKDAY_NAMES[date.weekday().number_days_from_monday().extend::<usize>()],
+        ),
+        modifier::WeekdayRepr::Sunday => format_number::<1>(
+            output,
+            date.weekday().number_days_from_sunday() + u8::from(one_indexed),
+            modifier::Padding::None,
+        ),
+        modifier::WeekdayRepr::Monday => format_number::<1>(
+            output,
+            date.weekday().number_days_from_monday() + u8::from(one_indexed),
+            modifier::Padding::None,
+        ),
+    }
+}
+
+/// Format the week number into the designated output.
+fn fmt_week_number(
+    output: &mut impl io::Write,
+    date: Date,
+    modifier::WeekNumber { padding, repr }: modifier::WeekNumber,
+) -> Result<usize, io::Error> {
+    format_number::<2>(
+        output,
+        match repr {
+            modifier::WeekNumberRepr::Iso => date.iso_week(),
+            modifier::WeekNumberRepr::Sunday => date.sunday_based_week(),
+            modifier::WeekNumberRepr::Monday => date.monday_based_week(),
+        },
+        padding,
+    )
+}
+
+/// Format the year into the designated output.
+fn fmt_year(
+    output: &mut impl io::Write,
+    date: Date,
+    modifier::Year {
+        padding,
+        repr,
+        iso_week_based,
+        sign_is_mandatory,
+    }: modifier::Year,
+) -> Result<usize, io::Error> {
+    let full_year = if iso_week_based {
+        date.iso_year_week().0
+    } else {
+        date.year()
+    };
+    let value = match repr {
+        modifier::YearRepr::Full => full_year,
+        modifier::YearRepr::LastTwo => (full_year % 100).abs(),
+    };
+    let format_number = match repr {
+        #[cfg(feature = "large-dates")]
+        modifier::YearRepr::Full if value.abs() >= 100_000 => format_number::<6>,
+        #[cfg(feature = "large-dates")]
+        modifier::YearRepr::Full if value.abs() >= 10_000 => format_number::<5>,
+        modifier::YearRepr::Full => format_number::<4>,
+        modifier::YearRepr::LastTwo => format_number::<2>,
+    };
+    let mut bytes = 0;
+    if repr != modifier::YearRepr::LastTwo {
+        if full_year < 0 {
+            bytes += write(output, b"-")?;
+        } else if sign_is_mandatory || cfg!(feature = "large-dates") && full_year >= 10_000 {
+            bytes += write(output, b"+")?;
+        }
+    }
+    bytes += format_number(output, value.unsigned_abs(), padding)?;
+    Ok(bytes)
+}
+// endregion date formatters
+
+// region: time formatters
+/// Format the hour into the designated output.
+fn fmt_hour(
+    output: &mut impl io::Write,
+    time: Time,
+    modifier::Hour {
+        padding,
+        is_12_hour_clock,
+    }: modifier::Hour,
+) -> Result<usize, io::Error> {
+    let value = match (time.hour(), is_12_hour_clock) {
+        (hour, false) => hour,
+        (0 | 12, true) => 12,
+        (hour, true) if hour < 12 => hour,
+        (hour, true) => hour - 12,
+    };
+    format_number::<2>(output, value, padding)
+}
+
+/// Format the minute into the designated output.
+fn fmt_minute(
+    output: &mut impl io::Write,
+    time: Time,
+    modifier::Minute { padding }: modifier::Minute,
+) -> Result<usize, io::Error> {
+    format_number::<2>(output, time.minute(), padding)
+}
+
+/// Format the period into the designated output.
+fn fmt_period(
+    output: &mut impl io::Write,
+    time: Time,
+    modifier::Period {
+        is_uppercase,
+        case_sensitive: _, // no effect on formatting
+    }: modifier::Period,
+) -> Result<usize, io::Error> {
+    match (time.hour() >= 12, is_uppercase) {
+        (false, false) => write(output, b"am"),
+        (false, true) => write(output, b"AM"),
+        (true, false) => write(output, b"pm"),
+        (true, true) => write(output, b"PM"),
+    }
+}
+
+/// Format the second into the designated output.
+fn fmt_second(
+    output: &mut impl io::Write,
+    time: Time,
+    modifier::Second { padding }: modifier::Second,
+) -> Result<usize, io::Error> {
+    format_number::<2>(output, time.second(), padding)
+}
+
+/// Format the subsecond into the designated output.
+fn fmt_subsecond<W: io::Write>(
+    output: &mut W,
+    time: Time,
+    modifier::Subsecond { digits }: modifier::Subsecond,
+) -> Result<usize, io::Error> {
+    use modifier::SubsecondDigits::*;
+    let nanos = time.nanosecond();
+
+    if digits == Nine || (digits == OneOrMore && nanos % 10 != 0) {
+        format_number_pad_zero::<9>(output, nanos)
+    } else if digits == Eight || (digits == OneOrMore && (nanos / 10) % 10 != 0) {
+        format_number_pad_zero::<8>(output, nanos / 10)
+    } else if digits == Seven || (digits == OneOrMore && (nanos / 100) % 10 != 0) {
+        format_number_pad_zero::<7>(output, nanos / 100)
+    } else if digits == Six || (digits == OneOrMore && (nanos / 1_000) % 10 != 0) {
+        format_number_pad_zero::<6>(output, nanos / 1_000)
+    } else if digits == Five || (digits == OneOrMore && (nanos / 10_000) % 10 != 0) {
+        format_number_pad_zero::<5>(output, nanos / 10_000)
+    } else if digits == Four || (digits == OneOrMore && (nanos / 100_000) % 10 != 0) {
+        format_number_pad_zero::<4>(output, nanos / 100_000)
+    } else if digits == Three || (digits == OneOrMore && (nanos / 1_000_000) % 10 != 0) {
+        format_number_pad_zero::<3>(output, nanos / 1_000_000)
+    } else if digits == Two || (digits == OneOrMore && (nanos / 10_000_000) % 10 != 0) {
+        format_number_pad_zero::<2>(output, nanos / 10_000_000)
+    } else {
+        format_number_pad_zero::<1>(output, nanos / 100_000_000)
+    }
+}
+// endregion time formatters
+
+// region: offset formatters
+/// Format the offset hour into the designated output.
+fn fmt_offset_hour(
+    output: &mut impl io::Write,
+    offset: UtcOffset,
+    modifier::OffsetHour {
+        padding,
+        sign_is_mandatory,
+    }: modifier::OffsetHour,
+) -> Result<usize, io::Error> {
+    let mut bytes = 0;
+    if offset.is_negative() {
+        bytes += write(output, b"-")?;
+    } else if sign_is_mandatory {
+        bytes += write(output, b"+")?;
+    }
+    bytes += format_number::<2>(output, offset.whole_hours().unsigned_abs(), padding)?;
+    Ok(bytes)
+}
+
+/// Format the offset minute into the designated output.
+fn fmt_offset_minute(
+    output: &mut impl io::Write,
+    offset: UtcOffset,
+    modifier::OffsetMinute { padding }: modifier::OffsetMinute,
+) -> Result<usize, io::Error> {
+    format_number::<2>(output, offset.minutes_past_hour().unsigned_abs(), padding)
+}
+
+/// Format the offset second into the designated output.
+fn fmt_offset_second(
+    output: &mut impl io::Write,
+    offset: UtcOffset,
+    modifier::OffsetSecond { padding }: modifier::OffsetSecond,
+) -> Result<usize, io::Error> {
+    format_number::<2>(output, offset.seconds_past_minute().unsigned_abs(), padding)
+}
+// endregion offset formatters
+
+/// Format the Unix timestamp into the designated output.
+fn fmt_unix_timestamp(
+    output: &mut impl io::Write,
+    date: Date,
+    time: Time,
+    offset: UtcOffset,
+    modifier::UnixTimestamp {
+        precision,
+        sign_is_mandatory,
+    }: modifier::UnixTimestamp,
+) -> Result<usize, io::Error> {
+    let date_time = OffsetDateTime::new_in_offset(date, time, offset).to_offset(UtcOffset::UTC);
+
+    if date_time < OffsetDateTime::UNIX_EPOCH {
+        write(output, b"-")?;
+    } else if sign_is_mandatory {
+        write(output, b"+")?;
+    }
+
+    match precision {
+        modifier::UnixTimestampPrecision::Second => {
+            format_number_pad_none(output, date_time.unix_timestamp().unsigned_abs())
+        }
+        modifier::UnixTimestampPrecision::Millisecond => format_number_pad_none(
+            output,
+            (date_time.unix_timestamp_nanos()
+                / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
+            .unsigned_abs(),
+        ),
+        modifier::UnixTimestampPrecision::Microsecond => format_number_pad_none(
+            output,
+            (date_time.unix_timestamp_nanos()
+                / Nanosecond::per(Microsecond).cast_signed().extend::<i128>())
+            .unsigned_abs(),
+        ),
+        modifier::UnixTimestampPrecision::Nanosecond => {
+            format_number_pad_none(output, date_time.unix_timestamp_nanos().unsigned_abs())
+        }
+    }
+}
diff --git a/time/src/instant.rs b/time/src/instant.rs
new file mode 100644
index 000000000..9f71070aa
--- /dev/null
+++ b/time/src/instant.rs
@@ -0,0 +1,292 @@
+//! The [`Instant`] struct and its associated `impl`s.
+
+#![allow(deprecated)]
+
+use core::borrow::Borrow;
+use core::cmp::{Ord, Ordering, PartialEq, PartialOrd};
+use core::ops::{Add, Sub};
+use core::time::Duration as StdDuration;
+use std::time::Instant as StdInstant;
+
+use crate::internal_macros::{impl_add_assign, impl_sub_assign};
+use crate::Duration;
+
+/// A measurement of a monotonically non-decreasing clock. Opaque and useful only with [`Duration`].
+///
+/// Instants are always guaranteed to be no less than any previously measured instant when created,
+/// and are often useful for tasks such as measuring benchmarks or timing how long an operation
+/// takes.
+///
+/// Note, however, that instants are not guaranteed to be **steady**. In other words, each tick of
+/// the underlying clock may not be the same length (e.g. some seconds may be longer than others).
+/// An instant may jump forwards or experience time dilation (slow down or speed up), but it will
+/// never go backwards.
+///
+/// Instants are opaque types that can only be compared to one another. There is no method to get
+/// "the number of seconds" from an instant. Instead, it only allows measuring the duration between
+/// two instants (or comparing two instants).
+///
+/// This implementation allows for operations with signed [`Duration`]s, but is otherwise identical
+/// to [`std::time::Instant`].
+#[deprecated(
+    since = "0.3.35",
+    note = "import `std::time::Instant` and `time::ext::InstantExt` instead"
+)]
+#[repr(transparent)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Instant(pub StdInstant);
+
+impl Instant {
+    // region: delegation
+    /// Returns an `Instant` corresponding to "now".
+    ///
+    /// ```rust
+    /// # #![allow(deprecated)]
+    /// # use time::Instant;
+    /// println!("{:?}", Instant::now());
+    /// ```
+    pub fn now() -> Self {
+        Self(StdInstant::now())
+    }
+
+    /// Returns the amount of time elapsed since this instant was created. The duration will always
+    /// be nonnegative if the instant is not synthetically created.
+    ///
+    /// ```rust
+    /// # #![allow(deprecated)]
+    /// # use time::{Instant, ext::{NumericalStdDuration, NumericalDuration}};
+    /// # use std::thread;
+    /// let instant = Instant::now();
+    /// thread::sleep(1.std_milliseconds());
+    /// assert!(instant.elapsed() >= 1.milliseconds());
+    /// ```
+    pub fn elapsed(self) -> Duration {
+        Self::now() - self
+    }
+    // endregion delegation
+
+    // region: checked arithmetic
+    /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
+    /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
+    /// otherwise.
+    ///
+    /// ```rust
+    /// # #![allow(deprecated)]
+    /// # use time::{Instant, ext::NumericalDuration};
+    /// let now = Instant::now();
+    /// assert_eq!(now.checked_add(5.seconds()), Some(now + 5.seconds()));
+    /// assert_eq!(now.checked_add((-5).seconds()), Some(now + (-5).seconds()));
+    /// ```
+    pub fn checked_add(self, duration: Duration) -> Option<Self> {
+        if duration.is_zero() {
+            Some(self)
+        } else if duration.is_positive() {
+            self.0.checked_add(duration.unsigned_abs()).map(Self)
+        } else {
+            debug_assert!(duration.is_negative());
+            self.0.checked_sub(duration.unsigned_abs()).map(Self)
+        }
+    }
+
+    /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
+    /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
+    /// otherwise.
+    ///
+    /// ```rust
+    /// # #![allow(deprecated)]
+    /// # use time::{Instant, ext::NumericalDuration};
+    /// let now = Instant::now();
+    /// assert_eq!(now.checked_sub(5.seconds()), Some(now - 5.seconds()));
+    /// assert_eq!(now.checked_sub((-5).seconds()), Some(now - (-5).seconds()));
+    /// ```
+    pub fn checked_sub(self, duration: Duration) -> Option<Self> {
+        if duration.is_zero() {
+            Some(self)
+        } else if duration.is_positive() {
+            self.0.checked_sub(duration.unsigned_abs()).map(Self)
+        } else {
+            debug_assert!(duration.is_negative());
+            self.0.checked_add(duration.unsigned_abs()).map(Self)
+        }
+    }
+    // endregion checked arithmetic
+
+    /// Obtain the inner [`std::time::Instant`].
+    ///
+    /// ```rust
+    /// # #![allow(deprecated)]
+    /// # use time::Instant;
+    /// let now = Instant::now();
+    /// assert_eq!(now.into_inner(), now.0);
+    /// ```
+    pub const fn into_inner(self) -> StdInstant {
+        self.0
+    }
+}
+
+// region: trait impls
+impl From<StdInstant> for Instant {
+    fn from(instant: StdInstant) -> Self {
+        Self(instant)
+    }
+}
+
+impl From<Instant> for StdInstant {
+    fn from(instant: Instant) -> Self {
+        instant.0
+    }
+}
+
+impl Sub for Instant {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, other: Self) -> Self::Output {
+        match self.0.cmp(&other.0) {
+            Ordering::Equal => Duration::ZERO,
+            Ordering::Greater => (self.0 - other.0)
+                .try_into()
+                .expect("overflow converting `std::time::Duration` to `time::Duration`"),
+            Ordering::Less => -Duration::try_from(other.0 - self.0)
+                .expect("overflow converting `std::time::Duration` to `time::Duration`"),
+        }
+    }
+}
+
+impl Sub<StdInstant> for Instant {
+    type Output = Duration;
+
+    fn sub(self, other: StdInstant) -> Self::Output {
+        self - Self(other)
+    }
+}
+
+impl Sub<Instant> for StdInstant {
+    type Output = Duration;
+
+    fn sub(self, other: Instant) -> Self::Output {
+        Instant(self) - other
+    }
+}
+
+impl Add<Duration> for Instant {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This function may panic if the resulting point in time cannot be represented by the
+    /// underlying data structure.
+    fn add(self, duration: Duration) -> Self::Output {
+        if duration.is_positive() {
+            Self(self.0 + duration.unsigned_abs())
+        } else if duration.is_negative() {
+            #[allow(clippy::unchecked_duration_subtraction)]
+            Self(self.0 - duration.unsigned_abs())
+        } else {
+            debug_assert!(duration.is_zero());
+            self
+        }
+    }
+}
+
+impl Add<Duration> for StdInstant {
+    type Output = Self;
+
+    fn add(self, duration: Duration) -> Self::Output {
+        (Instant(self) + duration).0
+    }
+}
+
+impl Add<StdDuration> for Instant {
+    type Output = Self;
+
+    fn add(self, duration: StdDuration) -> Self::Output {
+        Self(self.0 + duration)
+    }
+}
+
+impl_add_assign!(Instant: Duration, StdDuration);
+impl_add_assign!(StdInstant: Duration);
+
+impl Sub<Duration> for Instant {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This function may panic if the resulting point in time cannot be represented by the
+    /// underlying data structure.
+    fn sub(self, duration: Duration) -> Self::Output {
+        if duration.is_positive() {
+            #[allow(clippy::unchecked_duration_subtraction)]
+            Self(self.0 - duration.unsigned_abs())
+        } else if duration.is_negative() {
+            Self(self.0 + duration.unsigned_abs())
+        } else {
+            debug_assert!(duration.is_zero());
+            self
+        }
+    }
+}
+
+impl Sub<Duration> for StdInstant {
+    type Output = Self;
+
+    fn sub(self, duration: Duration) -> Self::Output {
+        (Instant(self) - duration).0
+    }
+}
+
+impl Sub<StdDuration> for Instant {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This function may panic if the resulting point in time cannot be represented by the
+    /// underlying data structure.
+    fn sub(self, duration: StdDuration) -> Self::Output {
+        #[allow(clippy::unchecked_duration_subtraction)]
+        Self(self.0 - duration)
+    }
+}
+
+impl_sub_assign!(Instant: Duration, StdDuration);
+impl_sub_assign!(StdInstant: Duration);
+
+impl PartialEq<StdInstant> for Instant {
+    fn eq(&self, rhs: &StdInstant) -> bool {
+        self.0.eq(rhs)
+    }
+}
+
+impl PartialEq<Instant> for StdInstant {
+    fn eq(&self, rhs: &Instant) -> bool {
+        self.eq(&rhs.0)
+    }
+}
+
+impl PartialOrd<StdInstant> for Instant {
+    fn partial_cmp(&self, rhs: &StdInstant) -> Option<Ordering> {
+        self.0.partial_cmp(rhs)
+    }
+}
+
+impl PartialOrd<Instant> for StdInstant {
+    fn partial_cmp(&self, rhs: &Instant) -> Option<Ordering> {
+        self.partial_cmp(&rhs.0)
+    }
+}
+
+impl AsRef<StdInstant> for Instant {
+    fn as_ref(&self) -> &StdInstant {
+        &self.0
+    }
+}
+
+impl Borrow<StdInstant> for Instant {
+    fn borrow(&self) -> &StdInstant {
+        &self.0
+    }
+}
+// endregion trait impls
diff --git a/time/src/internal_macros.rs b/time/src/internal_macros.rs
new file mode 100644
index 000000000..e210573ec
--- /dev/null
+++ b/time/src/internal_macros.rs
@@ -0,0 +1,200 @@
+//! Macros for use within the library. They are not publicly available.
+
+/// Helper macro for easily implementing `OpAssign`.
+macro_rules! __impl_assign {
+    ($sym:tt $op:ident $fn:ident $target:ty : $($(#[$attr:meta])* $t:ty),+) => {$(
+        #[allow(unused_qualifications)]
+        $(#[$attr])*
+        impl core::ops::$op<$t> for $target {
+            fn $fn(&mut self, rhs: $t) {
+                *self = *self $sym rhs;
+            }
+        }
+    )+};
+}
+
+/// Implement `AddAssign` for the provided types.
+macro_rules! impl_add_assign {
+    ($target:ty : $($(#[$attr:meta])* $t:ty),+ $(,)?) => {
+        $crate::internal_macros::__impl_assign!(
+            + AddAssign add_assign $target : $($(#[$attr])* $t),+
+        );
+    };
+}
+
+/// Implement `SubAssign` for the provided types.
+macro_rules! impl_sub_assign {
+    ($target:ty : $($(#[$attr:meta])* $t:ty),+ $(,)?) => {
+        $crate::internal_macros::__impl_assign!(
+            - SubAssign sub_assign $target : $($(#[$attr])* $t),+
+        );
+    };
+}
+
+/// Implement `MulAssign` for the provided types.
+macro_rules! impl_mul_assign {
+    ($target:ty : $($(#[$attr:meta])* $t:ty),+ $(,)?) => {
+        $crate::internal_macros::__impl_assign!(
+            * MulAssign mul_assign $target : $($(#[$attr])* $t),+
+        );
+    };
+}
+
+/// Implement `DivAssign` for the provided types.
+macro_rules! impl_div_assign {
+    ($target:ty : $($(#[$attr:meta])* $t:ty),+ $(,)?) => {
+        $crate::internal_macros::__impl_assign!(
+            / DivAssign div_assign $target : $($(#[$attr])* $t),+
+        );
+    };
+}
+
+/// Division of integers, rounding the resulting value towards negative infinity.
+macro_rules! div_floor {
+    ($a:expr, $b:expr) => {{
+        let _a = $a;
+        let _b = $b;
+
+        let (_quotient, _remainder) = (_a / _b, _a % _b);
+
+        if (_remainder > 0 && _b < 0) || (_remainder < 0 && _b > 0) {
+            _quotient - 1
+        } else {
+            _quotient
+        }
+    }};
+}
+
+/// Cascade an out-of-bounds value.
+macro_rules! cascade {
+    (@ordinal ordinal) => {};
+    (@year year) => {};
+
+    // Cascade an out-of-bounds value from "from" to "to".
+    ($from:ident in $min:literal.. $max:expr => $to:tt) => {
+        #[allow(unused_comparisons, unused_assignments)]
+        let min = $min;
+        let max = $max;
+        if $from >= max {
+            $from -= max - min;
+            $to += 1;
+        } else if $from < min {
+            $from += max - min;
+            $to -= 1;
+        }
+    };
+
+    // Special case the ordinal-to-year cascade, as it has different behavior.
+    ($ordinal:ident => $year:ident) => {
+        // We need to actually capture the idents. Without this, macro hygiene causes errors.
+        cascade!(@ordinal $ordinal);
+        cascade!(@year $year);
+        #[allow(unused_assignments)]
+        if $ordinal > crate::util::days_in_year($year) as i16 {
+            $ordinal -= crate::util::days_in_year($year) as i16;
+            $year += 1;
+        } else if $ordinal < 1 {
+            $year -= 1;
+            $ordinal += crate::util::days_in_year($year) as i16;
+        }
+    };
+}
+
+/// Constructs a ranged integer, returning a `ComponentRange` error if the value is out of range.
+macro_rules! ensure_ranged {
+    ($type:ident : $value:ident) => {
+        match $type::new($value) {
+            Some(val) => val,
+            None => {
+                #[allow(trivial_numeric_casts)]
+                return Err(crate::error::ComponentRange {
+                    name: stringify!($value),
+                    minimum: $type::MIN.get() as _,
+                    maximum: $type::MAX.get() as _,
+                    value: $value as _,
+                    conditional_range: false,
+                });
+            }
+        }
+    };
+
+    ($type:ident : $value:ident $(as $as_type:ident)? * $factor:expr) => {
+        match ($value $(as $as_type)?).checked_mul($factor) {
+            Some(val) => match $type::new(val) {
+                Some(val) => val,
+                None => {
+                    #[allow(trivial_numeric_casts)]
+                    return Err(crate::error::ComponentRange {
+                        name: stringify!($value),
+                        minimum: $type::MIN.get() as i64 / $factor as i64,
+                        maximum: $type::MAX.get() as i64 / $factor as i64,
+                        value: $value as _,
+                        conditional_range: false,
+                    });
+                }
+            },
+            None => {
+                return Err(crate::error::ComponentRange {
+                    name: stringify!($value),
+                    minimum: $type::MIN.get() as i64 / $factor as i64,
+                    maximum: $type::MAX.get() as i64 / $factor as i64,
+                    value: $value as _,
+                    conditional_range: false,
+                });
+            }
+        }
+    };
+}
+
+/// Try to unwrap an expression, returning if not possible.
+///
+/// This is similar to the `?` operator, but does not perform `.into()`. Because of this, it is
+/// usable in `const` contexts.
+macro_rules! const_try {
+    ($e:expr) => {
+        match $e {
+            Ok(value) => value,
+            Err(error) => return Err(error),
+        }
+    };
+}
+
+/// Try to unwrap an expression, returning if not possible.
+///
+/// This is similar to the `?` operator, but is usable in `const` contexts.
+macro_rules! const_try_opt {
+    ($e:expr) => {
+        match $e {
+            Some(value) => value,
+            None => return None,
+        }
+    };
+}
+
+/// Try to unwrap an expression, panicking if not possible.
+///
+/// This is similar to `$e.expect($message)`, but is usable in `const` contexts.
+macro_rules! expect_opt {
+    ($e:expr, $message:literal) => {
+        match $e {
+            Some(value) => value,
+            None => crate::expect_failed($message),
+        }
+    };
+}
+
+/// `unreachable!()`, but better.
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+macro_rules! bug {
+    () => { compile_error!("provide an error message to help fix a possible bug") };
+    ($descr:literal $($rest:tt)?) => {
+        panic!(concat!("internal error: ", $descr) $($rest)?)
+    }
+}
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+pub(crate) use bug;
+pub(crate) use {
+    __impl_assign, cascade, const_try, const_try_opt, div_floor, ensure_ranged, expect_opt,
+    impl_add_assign, impl_div_assign, impl_mul_assign, impl_sub_assign,
+};
diff --git a/time/src/lib.rs b/time/src/lib.rs
new file mode 100644
index 000000000..05fbdafdd
--- /dev/null
+++ b/time/src/lib.rs
@@ -0,0 +1,140 @@
+//! # Feature flags
+//!
+//! This crate exposes a number of features. These can be enabled or disabled as shown
+//! [in Cargo's documentation](https://doc.rust-lang.org/cargo/reference/features.html). Features
+//! are _disabled_ by default unless otherwise noted.
+//!
+//! Reliance on a given feature is always indicated alongside the item definition.
+//!
+//! - `std` (_enabled by default, implicitly enables `alloc`_)
+//!
+//!   This enables a number of features that depend on the standard library.
+//!
+//! - `alloc` (_enabled by default via `std`_)
+//!
+//!   Enables a number of features that require the ability to dynamically allocate memory.
+//!
+//! - `macros`
+//!
+//!   Enables macros that provide compile-time verification of values and intuitive syntax.
+//!
+//! - `formatting` (_implicitly enables `std`_)
+//!
+//!   Enables formatting of most structs.
+//!
+//! - `parsing`
+//!
+//!   Enables parsing of most structs.
+//!
+//! - `local-offset` (_implicitly enables `std`_)
+//!
+//!   This feature enables a number of methods that allow obtaining the system's UTC offset.
+//!
+//! - `large-dates`
+//!
+//!   By default, only years within the ±9999 range (inclusive) are supported. If you need support
+//!   for years outside this range, consider enabling this feature; the supported range will be
+//!   increased to ±999,999.
+//!
+//!   Note that enabling this feature has some costs, as it means forgoing some optimizations.
+//!   Ambiguities may be introduced when parsing that would not otherwise exist.
+//!
+//! - `serde`
+//!
+//!   Enables [serde](https://docs.rs/serde) support for all types except [`Instant`].
+//!
+//! - `serde-human-readable` (_implicitly enables `serde`, `formatting`, and `parsing`_)
+//!
+//!   Allows serde representations to use a human-readable format. This is determined by the
+//!   serializer, not the user. If this feature is not enabled or if the serializer requests a
+//!   non-human-readable format, a format optimized for binary representation will be used.
+//!
+//!   Libraries should never enable this feature, as the decision of what format to use should be up
+//!   to the user.
+//!
+//! - `rand`
+//!
+//!   Enables [rand](https://docs.rs/rand) support for all types.
+//!
+//! - `quickcheck` (_implicitly enables `alloc`_)
+//!
+//!   Enables [quickcheck](https://docs.rs/quickcheck) support for all types except [`Instant`].
+//!
+//! - `wasm-bindgen`
+//!
+//!   Enables [wasm-bindgen](https://github.com/rustwasm/wasm-bindgen) support for converting
+//!   [JavaScript dates](https://rustwasm.github.io/wasm-bindgen/api/js_sys/struct.Date.html), as
+//!   well as obtaining the UTC offset from JavaScript.
+
+#![doc(html_playground_url = "https://play.rust-lang.org")]
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_notable_trait))]
+#![no_std]
+#![doc(html_favicon_url = "https://avatars0.githubusercontent.com/u/55999857")]
+#![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/55999857")]
+#![doc(test(attr(deny(warnings))))]
+
+#[allow(unused_extern_crates)]
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+mod date;
+mod duration;
+pub mod error;
+pub mod ext;
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+pub mod format_description;
+#[cfg(feature = "formatting")]
+pub mod formatting;
+#[cfg(feature = "std")]
+mod instant;
+mod internal_macros;
+#[cfg(feature = "macros")]
+pub mod macros;
+mod month;
+mod offset_date_time;
+#[cfg(feature = "parsing")]
+pub mod parsing;
+mod primitive_date_time;
+#[cfg(feature = "quickcheck")]
+mod quickcheck;
+#[cfg(feature = "rand")]
+mod rand;
+#[cfg(feature = "serde")]
+#[allow(missing_copy_implementations, missing_debug_implementations)]
+pub mod serde;
+mod sys;
+#[cfg(test)]
+mod tests;
+mod time;
+mod utc_offset;
+pub mod util;
+mod weekday;
+
+pub use time_core::convert;
+
+pub use crate::date::Date;
+pub use crate::duration::Duration;
+pub use crate::error::Error;
+#[cfg(feature = "std")]
+#[allow(deprecated)]
+pub use crate::instant::Instant;
+pub use crate::month::Month;
+pub use crate::offset_date_time::OffsetDateTime;
+pub use crate::primitive_date_time::PrimitiveDateTime;
+pub use crate::time::Time;
+pub use crate::utc_offset::UtcOffset;
+pub use crate::weekday::Weekday;
+
+/// An alias for [`std::result::Result`] with a generic error from the time crate.
+pub type Result<T> = core::result::Result<T, Error>;
+
+/// This is a separate function to reduce the code size of `expect_opt!`.
+#[inline(never)]
+#[cold]
+#[track_caller]
+const fn expect_failed(message: &str) -> ! {
+    panic!("{}", message)
+}
diff --git a/time/src/macros.rs b/time/src/macros.rs
new file mode 100644
index 000000000..d78864568
--- /dev/null
+++ b/time/src/macros.rs
@@ -0,0 +1,132 @@
+//! Macros to construct statically known values.
+
+/// Construct a [`Date`](crate::Date) with a statically known value.
+///
+/// The resulting expression can be used in `const` or `static` declarations.
+///
+/// Three formats are supported: year-week-weekday, year-ordinal, and year-month-day.
+///
+/// ```rust
+/// # use time::{Date, Weekday::*, Month, macros::date};
+/// assert_eq!(
+///     date!(2020 - W 01 - 3),
+///     Date::from_iso_week_date(2020, 1, Wednesday)?
+/// );
+/// assert_eq!(date!(2020 - 001), Date::from_ordinal_date(2020, 1)?);
+/// assert_eq!(
+///     date!(2020 - 01 - 01),
+///     Date::from_calendar_date(2020, Month::January, 1)?
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+pub use time_macros::date;
+/// Construct a [`PrimitiveDateTime`] or [`OffsetDateTime`] with a statically known value.
+///
+/// The resulting expression can be used in `const` or `static` declarations.
+///
+/// The syntax accepted by this macro is the same as [`date!`] and [`time!`], with an optional
+/// [`offset!`], all space-separated. If an [`offset!`] is provided, the resulting value will
+/// be an [`OffsetDateTime`]; otherwise it will be a [`PrimitiveDateTime`].
+///
+/// [`OffsetDateTime`]: crate::OffsetDateTime
+/// [`PrimitiveDateTime`]: crate::PrimitiveDateTime
+///
+/// ```rust
+/// # use time::{Date, Month, macros::datetime, UtcOffset};
+/// assert_eq!(
+///     datetime!(2020-01-01 0:00),
+///     Date::from_calendar_date(2020, Month::January, 1)?.midnight()
+/// );
+/// assert_eq!(
+///     datetime!(2020-01-01 0:00 UTC),
+///     Date::from_calendar_date(2020, Month::January, 1)?.midnight().assume_utc()
+/// );
+/// assert_eq!(
+///     datetime!(2020-01-01 0:00 -1),
+///     Date::from_calendar_date(2020, Month::January, 1)?.midnight()
+///         .assume_offset(UtcOffset::from_hms(-1, 0, 0)?)
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+pub use time_macros::datetime;
+/// Equivalent of performing [`format_description::parse()`] at compile time.
+///
+/// Using the macro instead of the function results in a static slice rather than a
+/// [`Vec`](alloc::vec::Vec), such that it can be used in `#![no_alloc]` situations.
+///
+/// The resulting expression can be used in `const` or `static` declarations, and implements
+/// the sealed traits required for both formatting and parsing.
+#[cfg_attr(feature = "alloc", doc = "```rust")]
+#[cfg_attr(not(feature = "alloc"), doc = "```rust,ignore")]
+/// # use time::{format_description, macros::format_description};
+/// assert_eq!(
+///     format_description!("[hour]:[minute]:[second]"),
+///     format_description::parse("[hour]:[minute]:[second]")?
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+/// 
+/// The syntax accepted by this macro is the same as [`format_description::parse()`], which can
+/// be found in [the book](https://time-rs.github.io/book/api/format-description.html).
+///
+/// [`format_description::parse()`]: crate::format_description::parse()
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+pub use time_macros::format_description;
+/// Construct a [`UtcOffset`](crate::UtcOffset) with a statically known value.
+///
+/// The resulting expression can be used in `const` or `static` declarations.
+///
+/// A sign and the hour must be provided; minutes and seconds default to zero. `UTC` (both
+/// uppercase and lowercase) is also allowed.
+///
+/// ```rust
+/// # use time::{UtcOffset, macros::offset};
+/// assert_eq!(offset!(UTC), UtcOffset::from_hms(0, 0, 0)?);
+/// assert_eq!(offset!(utc), UtcOffset::from_hms(0, 0, 0)?);
+/// assert_eq!(offset!(+0), UtcOffset::from_hms(0, 0, 0)?);
+/// assert_eq!(offset!(+1), UtcOffset::from_hms(1, 0, 0)?);
+/// assert_eq!(offset!(-1), UtcOffset::from_hms(-1, 0, 0)?);
+/// assert_eq!(offset!(+1:30), UtcOffset::from_hms(1, 30, 0)?);
+/// assert_eq!(offset!(-1:30), UtcOffset::from_hms(-1, -30, 0)?);
+/// assert_eq!(offset!(+1:30:59), UtcOffset::from_hms(1, 30, 59)?);
+/// assert_eq!(offset!(-1:30:59), UtcOffset::from_hms(-1, -30, -59)?);
+/// assert_eq!(offset!(+23:59:59), UtcOffset::from_hms(23, 59, 59)?);
+/// assert_eq!(offset!(-23:59:59), UtcOffset::from_hms(-23, -59, -59)?);
+/// # Ok::<_, time::Error>(())
+/// ```
+pub use time_macros::offset;
+/// Construct a [`Time`](crate::Time) with a statically known value.
+///
+/// The resulting expression can be used in `const` or `static` declarations.
+///
+/// Hours and minutes must be provided, while seconds defaults to zero. AM/PM is allowed
+/// (either uppercase or lowercase). Any number of subsecond digits may be provided (though any
+/// past nine will be discarded).
+///
+/// All components are validated at compile-time. An error will be raised if any value is
+/// invalid.
+///
+/// ```rust
+/// # use time::{Time, macros::time};
+/// assert_eq!(time!(0:00), Time::from_hms(0, 0, 0)?);
+/// assert_eq!(time!(1:02:03), Time::from_hms(1, 2, 3)?);
+/// assert_eq!(
+///     time!(1:02:03.004_005_006),
+///     Time::from_hms_nano(1, 2, 3, 4_005_006)?
+/// );
+/// assert_eq!(time!(12:00 am), Time::from_hms(0, 0, 0)?);
+/// assert_eq!(time!(1:02:03 am), Time::from_hms(1, 2, 3)?);
+/// assert_eq!(
+///     time!(1:02:03.004_005_006 am),
+///     Time::from_hms_nano(1, 2, 3, 4_005_006)?
+/// );
+/// assert_eq!(time!(12 pm), Time::from_hms(12, 0, 0)?);
+/// assert_eq!(time!(12:00 pm), Time::from_hms(12, 0, 0)?);
+/// assert_eq!(time!(1:02:03 pm), Time::from_hms(13, 2, 3)?);
+/// assert_eq!(
+///     time!(1:02:03.004_005_006 pm),
+///     Time::from_hms_nano(13, 2, 3, 4_005_006)?
+/// );
+/// # Ok::<_, time::Error>(())
+/// ```
+pub use time_macros::time;
diff --git a/time/src/month.rs b/time/src/month.rs
new file mode 100644
index 000000000..55e53b4b8
--- /dev/null
+++ b/time/src/month.rs
@@ -0,0 +1,263 @@
+//! The `Month` enum and its associated `impl`s.
+
+use core::fmt;
+use core::num::NonZeroU8;
+use core::str::FromStr;
+
+use powerfmt::smart_display::{FormatterOptions, Metadata, SmartDisplay};
+
+use self::Month::*;
+use crate::error;
+
+/// Months of the year.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Month {
+    #[allow(missing_docs)]
+    January = 1,
+    #[allow(missing_docs)]
+    February = 2,
+    #[allow(missing_docs)]
+    March = 3,
+    #[allow(missing_docs)]
+    April = 4,
+    #[allow(missing_docs)]
+    May = 5,
+    #[allow(missing_docs)]
+    June = 6,
+    #[allow(missing_docs)]
+    July = 7,
+    #[allow(missing_docs)]
+    August = 8,
+    #[allow(missing_docs)]
+    September = 9,
+    #[allow(missing_docs)]
+    October = 10,
+    #[allow(missing_docs)]
+    November = 11,
+    #[allow(missing_docs)]
+    December = 12,
+}
+
+impl Month {
+    /// Create a `Month` from its numerical value.
+    pub(crate) const fn from_number(n: NonZeroU8) -> Result<Self, error::ComponentRange> {
+        match n.get() {
+            1 => Ok(January),
+            2 => Ok(February),
+            3 => Ok(March),
+            4 => Ok(April),
+            5 => Ok(May),
+            6 => Ok(June),
+            7 => Ok(July),
+            8 => Ok(August),
+            9 => Ok(September),
+            10 => Ok(October),
+            11 => Ok(November),
+            12 => Ok(December),
+            n => Err(error::ComponentRange {
+                name: "month",
+                minimum: 1,
+                maximum: 12,
+                value: n as _,
+                conditional_range: false,
+            }),
+        }
+    }
+
+    /// Get the previous month.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// assert_eq!(Month::January.previous(), Month::December);
+    /// ```
+    pub const fn previous(self) -> Self {
+        match self {
+            January => December,
+            February => January,
+            March => February,
+            April => March,
+            May => April,
+            June => May,
+            July => June,
+            August => July,
+            September => August,
+            October => September,
+            November => October,
+            December => November,
+        }
+    }
+
+    /// Get the next month.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// assert_eq!(Month::January.next(), Month::February);
+    /// ```
+    pub const fn next(self) -> Self {
+        match self {
+            January => February,
+            February => March,
+            March => April,
+            April => May,
+            May => June,
+            June => July,
+            July => August,
+            August => September,
+            September => October,
+            October => November,
+            November => December,
+            December => January,
+        }
+    }
+
+    /// Get n-th next month.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// assert_eq!(Month::January.nth_next(4), Month::May);
+    /// assert_eq!(Month::July.nth_next(9), Month::April);
+    /// ```
+    pub const fn nth_next(self, n: u8) -> Self {
+        match (self as u8 - 1 + n % 12) % 12 {
+            0 => January,
+            1 => February,
+            2 => March,
+            3 => April,
+            4 => May,
+            5 => June,
+            6 => July,
+            7 => August,
+            8 => September,
+            9 => October,
+            10 => November,
+            val => {
+                debug_assert!(val == 11);
+                December
+            }
+        }
+    }
+
+    /// Get n-th previous month.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// assert_eq!(Month::January.nth_prev(4), Month::September);
+    /// assert_eq!(Month::July.nth_prev(9), Month::October);
+    /// ```
+    pub const fn nth_prev(self, n: u8) -> Self {
+        match self as i8 - 1 - (n % 12) as i8 {
+            1 | -11 => February,
+            2 | -10 => March,
+            3 | -9 => April,
+            4 | -8 => May,
+            5 | -7 => June,
+            6 | -6 => July,
+            7 | -5 => August,
+            8 | -4 => September,
+            9 | -3 => October,
+            10 | -2 => November,
+            11 | -1 => December,
+            val => {
+                debug_assert!(val == 0);
+                January
+            }
+        }
+    }
+}
+
+mod private {
+    #[non_exhaustive]
+    #[derive(Debug, Clone, Copy)]
+    pub struct MonthMetadata;
+}
+use private::MonthMetadata;
+
+impl SmartDisplay for Month {
+    type Metadata = MonthMetadata;
+
+    fn metadata(&self, _: FormatterOptions) -> Metadata<Self> {
+        match self {
+            January => Metadata::new(7, self, MonthMetadata),
+            February => Metadata::new(8, self, MonthMetadata),
+            March => Metadata::new(5, self, MonthMetadata),
+            April => Metadata::new(5, self, MonthMetadata),
+            May => Metadata::new(3, self, MonthMetadata),
+            June => Metadata::new(4, self, MonthMetadata),
+            July => Metadata::new(4, self, MonthMetadata),
+            August => Metadata::new(6, self, MonthMetadata),
+            September => Metadata::new(9, self, MonthMetadata),
+            October => Metadata::new(7, self, MonthMetadata),
+            November => Metadata::new(8, self, MonthMetadata),
+            December => Metadata::new(8, self, MonthMetadata),
+        }
+    }
+
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad(match self {
+            January => "January",
+            February => "February",
+            March => "March",
+            April => "April",
+            May => "May",
+            June => "June",
+            July => "July",
+            August => "August",
+            September => "September",
+            October => "October",
+            November => "November",
+            December => "December",
+        })
+    }
+}
+
+impl fmt::Display for Month {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        SmartDisplay::fmt(self, f)
+    }
+}
+
+impl FromStr for Month {
+    type Err = error::InvalidVariant;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "January" => Ok(January),
+            "February" => Ok(February),
+            "March" => Ok(March),
+            "April" => Ok(April),
+            "May" => Ok(May),
+            "June" => Ok(June),
+            "July" => Ok(July),
+            "August" => Ok(August),
+            "September" => Ok(September),
+            "October" => Ok(October),
+            "November" => Ok(November),
+            "December" => Ok(December),
+            _ => Err(error::InvalidVariant),
+        }
+    }
+}
+
+impl From<Month> for u8 {
+    fn from(month: Month) -> Self {
+        month as _
+    }
+}
+
+impl TryFrom<u8> for Month {
+    type Error = error::ComponentRange;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match NonZeroU8::new(value) {
+            Some(value) => Self::from_number(value),
+            None => Err(error::ComponentRange {
+                name: "month",
+                minimum: 1,
+                maximum: 12,
+                value: 0,
+                conditional_range: false,
+            }),
+        }
+    }
+}
diff --git a/time/src/offset_date_time.rs b/time/src/offset_date_time.rs
new file mode 100644
index 000000000..52f179985
--- /dev/null
+++ b/time/src/offset_date_time.rs
@@ -0,0 +1,1618 @@
+//! The [`OffsetDateTime`] struct and its associated `impl`s.
+
+#[cfg(feature = "formatting")]
+use alloc::string::String;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::Hash;
+use core::ops::{Add, AddAssign, Sub, SubAssign};
+use core::time::Duration as StdDuration;
+#[cfg(feature = "formatting")]
+use std::io;
+#[cfg(feature = "std")]
+use std::time::SystemTime;
+
+use deranged::RangedI64;
+use num_conv::prelude::*;
+use powerfmt::ext::FormatterExt as _;
+use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
+use time_core::convert::*;
+
+use crate::date::{MAX_YEAR, MIN_YEAR};
+#[cfg(feature = "formatting")]
+use crate::formatting::Formattable;
+use crate::internal_macros::{
+    cascade, const_try, const_try_opt, div_floor, ensure_ranged, expect_opt,
+};
+#[cfg(feature = "parsing")]
+use crate::parsing::Parsable;
+use crate::{error, util, Date, Duration, Month, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+/// The Julian day of the Unix epoch.
+// Safety: `ordinal` is not zero.
+#[allow(clippy::undocumented_unsafe_blocks)]
+const UNIX_EPOCH_JULIAN_DAY: i32 =
+    unsafe { Date::__from_ordinal_date_unchecked(1970, 1) }.to_julian_day();
+
+/// A [`PrimitiveDateTime`] with a [`UtcOffset`].
+///
+/// All comparisons are performed using the UTC time.
+#[derive(Clone, Copy, Eq)]
+pub struct OffsetDateTime {
+    local_date_time: PrimitiveDateTime,
+    offset: UtcOffset,
+}
+
+impl PartialEq for OffsetDateTime {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_offset_raw(UtcOffset::UTC) == other.to_offset_raw(UtcOffset::UTC)
+    }
+}
+
+impl PartialOrd for OffsetDateTime {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for OffsetDateTime {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.to_offset_raw(UtcOffset::UTC)
+            .cmp(&other.to_offset_raw(UtcOffset::UTC))
+    }
+}
+
+impl Hash for OffsetDateTime {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.to_offset_raw(UtcOffset::UTC).hash(state);
+    }
+}
+
+impl OffsetDateTime {
+    /// Midnight, 1 January, 1970 (UTC).
+    ///
+    /// ```rust
+    /// # use time::OffsetDateTime;
+    /// # use time_macros::datetime;
+    /// assert_eq!(OffsetDateTime::UNIX_EPOCH, datetime!(1970-01-01 0:00 UTC),);
+    /// ```
+    pub const UNIX_EPOCH: Self = Self::new_in_offset(
+        // Safety: `ordinal` is not zero.
+        unsafe { Date::__from_ordinal_date_unchecked(1970, 1) },
+        Time::MIDNIGHT,
+        UtcOffset::UTC,
+    );
+
+    // region: now
+    /// Create a new `OffsetDateTime` with the current date and time in UTC.
+    ///
+    /// ```rust
+    /// # use time::OffsetDateTime;
+    /// # use time_macros::offset;
+    /// assert!(OffsetDateTime::now_utc().year() >= 2019);
+    /// assert_eq!(OffsetDateTime::now_utc().offset(), offset!(UTC));
+    /// ```
+    #[cfg(feature = "std")]
+    pub fn now_utc() -> Self {
+        #[cfg(all(
+            target_family = "wasm",
+            not(any(target_os = "emscripten", target_os = "wasi")),
+            feature = "wasm-bindgen"
+        ))]
+        {
+            js_sys::Date::new_0().into()
+        }
+
+        #[cfg(not(all(
+            target_family = "wasm",
+            not(any(target_os = "emscripten", target_os = "wasi")),
+            feature = "wasm-bindgen"
+        )))]
+        SystemTime::now().into()
+    }
+
+    /// Attempt to create a new `OffsetDateTime` with the current date and time in the local offset.
+    /// If the offset cannot be determined, an error is returned.
+    ///
+    /// ```rust
+    /// # use time::OffsetDateTime;
+    /// # if false {
+    /// assert!(OffsetDateTime::now_local().is_ok());
+    /// # }
+    /// ```
+    #[cfg(feature = "local-offset")]
+    pub fn now_local() -> Result<Self, error::IndeterminateOffset> {
+        let t = Self::now_utc();
+        Ok(t.to_offset(UtcOffset::local_offset_at(t)?))
+    }
+    // endregion now
+
+    /// Create a new `OffsetDateTime` with the given [`Date`], [`Time`], and [`UtcOffset`].
+    ///
+    /// ```
+    /// # use time::{Date, Month, OffsetDateTime, Time, UtcOffset};
+    /// # use time_macros::datetime;
+    /// let dt = OffsetDateTime::new_in_offset(
+    ///     Date::from_calendar_date(2024, Month::January, 1)?,
+    ///     Time::from_hms_nano(12, 59, 59, 500_000_000)?,
+    ///     UtcOffset::from_hms(-5, 0, 0)?,
+    /// );
+    /// assert_eq!(dt, datetime!(2024-01-01 12:59:59.5 -5));
+    /// # Ok::<_, time::error::Error>(())
+    /// ```
+    pub const fn new_in_offset(date: Date, time: Time, offset: UtcOffset) -> Self {
+        Self {
+            local_date_time: date.with_time(time),
+            offset,
+        }
+    }
+
+    /// Create a new `OffsetDateTime` with the given [`Date`] and [`Time`] in the UTC timezone.
+    ///
+    /// ```
+    /// # use time::{Date, Month, OffsetDateTime, Time};
+    /// # use time_macros::datetime;
+    /// let dt = OffsetDateTime::new_utc(
+    ///     Date::from_calendar_date(2024, Month::January, 1)?,
+    ///     Time::from_hms_nano(12, 59, 59, 500_000_000)?,
+    /// );
+    /// assert_eq!(dt, datetime!(2024-01-01 12:59:59.5 UTC));
+    /// # Ok::<_, time::error::Error>(())
+    /// ```
+    pub const fn new_utc(date: Date, time: Time) -> Self {
+        PrimitiveDateTime::new(date, time).assume_utc()
+    }
+
+    /// Convert the `OffsetDateTime` from the current [`UtcOffset`] to the provided [`UtcOffset`].
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(
+    ///     datetime!(2000-01-01 0:00 UTC)
+    ///         .to_offset(offset!(-1))
+    ///         .year(),
+    ///     1999,
+    /// );
+    ///
+    /// // Let's see what time Sydney's new year's celebration is in New York and Los Angeles.
+    ///
+    /// // Construct midnight on new year's in Sydney.
+    /// let sydney = datetime!(2000-01-01 0:00 +11);
+    /// let new_york = sydney.to_offset(offset!(-5));
+    /// let los_angeles = sydney.to_offset(offset!(-8));
+    /// assert_eq!(sydney.hour(), 0);
+    /// assert_eq!(new_york.hour(), 8);
+    /// assert_eq!(los_angeles.hour(), 5);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This method panics if the local date-time in the new offset is outside the supported range.
+    pub const fn to_offset(self, offset: UtcOffset) -> Self {
+        expect_opt!(
+            self.checked_to_offset(offset),
+            "local datetime out of valid range"
+        )
+    }
+
+    /// Convert the `OffsetDateTime` from the current [`UtcOffset`] to the provided [`UtcOffset`],
+    /// returning `None` if the date-time in the resulting offset is invalid.
+    ///
+    /// ```rust
+    /// # use time::PrimitiveDateTime;
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(
+    ///     datetime!(2000-01-01 0:00 UTC)
+    ///         .checked_to_offset(offset!(-1))
+    ///         .unwrap()
+    ///         .year(),
+    ///     1999,
+    /// );
+    /// assert_eq!(
+    ///     PrimitiveDateTime::MAX
+    ///         .assume_utc()
+    ///         .checked_to_offset(offset!(+1)),
+    ///     None,
+    /// );
+    /// ```
+    pub const fn checked_to_offset(self, offset: UtcOffset) -> Option<Self> {
+        if self.offset.whole_hours() == offset.whole_hours()
+            && self.offset.minutes_past_hour() == offset.minutes_past_hour()
+            && self.offset.seconds_past_minute() == offset.seconds_past_minute()
+        {
+            return Some(self.replace_offset(offset));
+        }
+
+        let (year, ordinal, time) = self.to_offset_raw(offset);
+
+        if year > MAX_YEAR || year < MIN_YEAR {
+            return None;
+        }
+
+        Some(Self::new_in_offset(
+            // Safety: `ordinal` is not zero.
+            unsafe { Date::__from_ordinal_date_unchecked(year, ordinal) },
+            time,
+            offset,
+        ))
+    }
+
+    /// Equivalent to `.to_offset(UtcOffset::UTC)`, but returning the year, ordinal, and time. This
+    /// avoids constructing an invalid [`Date`] if the new value is out of range.
+    pub(crate) const fn to_offset_raw(self, offset: UtcOffset) -> (i32, u16, Time) {
+        let from = self.offset;
+        let to = offset;
+
+        // Fast path for when no conversion is necessary.
+        if from.whole_hours() == to.whole_hours()
+            && from.minutes_past_hour() == to.minutes_past_hour()
+            && from.seconds_past_minute() == to.seconds_past_minute()
+        {
+            return (self.year(), self.ordinal(), self.time());
+        }
+
+        let mut second = self.second() as i16 - from.seconds_past_minute() as i16
+            + to.seconds_past_minute() as i16;
+        let mut minute =
+            self.minute() as i16 - from.minutes_past_hour() as i16 + to.minutes_past_hour() as i16;
+        let mut hour = self.hour() as i8 - from.whole_hours() + to.whole_hours();
+        let (mut year, ordinal) = self.to_ordinal_date();
+        let mut ordinal = ordinal as i16;
+
+        // Cascade the values twice. This is needed because the values are adjusted twice above.
+        cascade!(second in 0..Second::per(Minute) as i16 => minute);
+        cascade!(second in 0..Second::per(Minute) as i16 => minute);
+        cascade!(minute in 0..Minute::per(Hour) as i16 => hour);
+        cascade!(minute in 0..Minute::per(Hour) as i16 => hour);
+        cascade!(hour in 0..Hour::per(Day) as i8 => ordinal);
+        cascade!(hour in 0..Hour::per(Day) as i8 => ordinal);
+        cascade!(ordinal => year);
+
+        debug_assert!(ordinal > 0);
+        debug_assert!(ordinal <= util::days_in_year(year) as i16);
+
+        (
+            year,
+            ordinal as _,
+            // Safety: The cascades above ensure the values are in range.
+            unsafe {
+                Time::__from_hms_nanos_unchecked(
+                    hour as _,
+                    minute as _,
+                    second as _,
+                    self.nanosecond(),
+                )
+            },
+        )
+    }
+
+    // region: constructors
+    /// Create an `OffsetDateTime` from the provided Unix timestamp. Calling `.offset()` on the
+    /// resulting value is guaranteed to return UTC.
+    ///
+    /// ```rust
+    /// # use time::OffsetDateTime;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     OffsetDateTime::from_unix_timestamp(0),
+    ///     Ok(OffsetDateTime::UNIX_EPOCH),
+    /// );
+    /// assert_eq!(
+    ///     OffsetDateTime::from_unix_timestamp(1_546_300_800),
+    ///     Ok(datetime!(2019-01-01 0:00 UTC)),
+    /// );
+    /// ```
+    ///
+    /// If you have a timestamp-nanosecond pair, you can use something along the lines of the
+    /// following:
+    ///
+    /// ```rust
+    /// # use time::{Duration, OffsetDateTime, ext::NumericalDuration};
+    /// let (timestamp, nanos) = (1, 500_000_000);
+    /// assert_eq!(
+    ///     OffsetDateTime::from_unix_timestamp(timestamp)? + Duration::nanoseconds(nanos),
+    ///     OffsetDateTime::UNIX_EPOCH + 1.5.seconds()
+    /// );
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub const fn from_unix_timestamp(timestamp: i64) -> Result<Self, error::ComponentRange> {
+        type Timestamp = RangedI64<
+            {
+                OffsetDateTime::new_in_offset(Date::MIN, Time::MIDNIGHT, UtcOffset::UTC)
+                    .unix_timestamp()
+            },
+            {
+                OffsetDateTime::new_in_offset(Date::MAX, Time::MAX, UtcOffset::UTC).unix_timestamp()
+            },
+        >;
+        ensure_ranged!(Timestamp: timestamp);
+
+        // Use the unchecked method here, as the input validity has already been verified.
+        let date = Date::from_julian_day_unchecked(
+            UNIX_EPOCH_JULIAN_DAY + div_floor!(timestamp, Second::per(Day) as i64) as i32,
+        );
+
+        let seconds_within_day = timestamp.rem_euclid(Second::per(Day) as _);
+        // Safety: All values are in range.
+        let time = unsafe {
+            Time::__from_hms_nanos_unchecked(
+                (seconds_within_day / Second::per(Hour) as i64) as _,
+                ((seconds_within_day % Second::per(Hour) as i64) / Minute::per(Hour) as i64) as _,
+                (seconds_within_day % Second::per(Minute) as i64) as _,
+                0,
+            )
+        };
+
+        Ok(Self::new_in_offset(date, time, UtcOffset::UTC))
+    }
+
+    /// Construct an `OffsetDateTime` from the provided Unix timestamp (in nanoseconds). Calling
+    /// `.offset()` on the resulting value is guaranteed to return UTC.
+    ///
+    /// ```rust
+    /// # use time::OffsetDateTime;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     OffsetDateTime::from_unix_timestamp_nanos(0),
+    ///     Ok(OffsetDateTime::UNIX_EPOCH),
+    /// );
+    /// assert_eq!(
+    ///     OffsetDateTime::from_unix_timestamp_nanos(1_546_300_800_000_000_000),
+    ///     Ok(datetime!(2019-01-01 0:00 UTC)),
+    /// );
+    /// ```
+    pub const fn from_unix_timestamp_nanos(timestamp: i128) -> Result<Self, error::ComponentRange> {
+        let datetime = const_try!(Self::from_unix_timestamp(div_floor!(
+            timestamp,
+            Nanosecond::per(Second) as i128
+        ) as i64));
+
+        Ok(Self::new_in_offset(
+            datetime.date(),
+            // Safety: `nanosecond` is in range due to `rem_euclid`.
+            unsafe {
+                Time::__from_hms_nanos_unchecked(
+                    datetime.hour(),
+                    datetime.minute(),
+                    datetime.second(),
+                    timestamp.rem_euclid(Nanosecond::per(Second) as _) as u32,
+                )
+            },
+            UtcOffset::UTC,
+        ))
+    }
+    // endregion constructors
+
+    // region: getters
+    /// Get the [`UtcOffset`].
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).offset(), offset!(UTC));
+    /// assert_eq!(datetime!(2019-01-01 0:00 +1).offset(), offset!(+1));
+    /// ```
+    pub const fn offset(self) -> UtcOffset {
+        self.offset
+    }
+
+    /// Get the [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time).
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(1970-01-01 0:00 UTC).unix_timestamp(), 0);
+    /// assert_eq!(datetime!(1970-01-01 0:00 -1).unix_timestamp(), 3_600);
+    /// ```
+    pub const fn unix_timestamp(self) -> i64 {
+        let days =
+            (self.to_julian_day() as i64 - UNIX_EPOCH_JULIAN_DAY as i64) * Second::per(Day) as i64;
+        let hours = self.hour() as i64 * Second::per(Hour) as i64;
+        let minutes = self.minute() as i64 * Second::per(Minute) as i64;
+        let seconds = self.second() as i64;
+        let offset_seconds = self.offset.whole_seconds() as i64;
+        days + hours + minutes + seconds - offset_seconds
+    }
+
+    /// Get the Unix timestamp in nanoseconds.
+    ///
+    /// ```rust
+    /// use time_macros::datetime;
+    /// assert_eq!(datetime!(1970-01-01 0:00 UTC).unix_timestamp_nanos(), 0);
+    /// assert_eq!(
+    ///     datetime!(1970-01-01 0:00 -1).unix_timestamp_nanos(),
+    ///     3_600_000_000_000,
+    /// );
+    /// ```
+    pub const fn unix_timestamp_nanos(self) -> i128 {
+        self.unix_timestamp() as i128 * Nanosecond::per(Second) as i128 + self.nanosecond() as i128
+    }
+
+    /// Get the [`PrimitiveDateTime`] in the stored offset.
+    const fn date_time(self) -> PrimitiveDateTime {
+        self.local_date_time
+    }
+
+    /// Get the [`Date`] in the stored offset.
+    ///
+    /// ```rust
+    /// # use time_macros::{date, datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).date(), date!(2019-01-01));
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00 UTC)
+    ///         .to_offset(offset!(-1))
+    ///         .date(),
+    ///     date!(2018-12-31),
+    /// );
+    /// ```
+    pub const fn date(self) -> Date {
+        self.date_time().date()
+    }
+
+    /// Get the [`Time`] in the stored offset.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset, time};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).time(), time!(0:00));
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00 UTC)
+    ///         .to_offset(offset!(-1))
+    ///         .time(),
+    ///     time!(23:00)
+    /// );
+    /// ```
+    pub const fn time(self) -> Time {
+        self.date_time().time()
+    }
+
+    // region: date getters
+    /// Get the year of the date in the stored offset.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).year(), 2019);
+    /// assert_eq!(
+    ///     datetime!(2019-12-31 23:00 UTC)
+    ///         .to_offset(offset!(+1))
+    ///         .year(),
+    ///     2020,
+    /// );
+    /// assert_eq!(datetime!(2020-01-01 0:00 UTC).year(), 2020);
+    /// ```
+    pub const fn year(self) -> i32 {
+        self.date().year()
+    }
+
+    /// Get the month of the date in the stored offset.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).month(), Month::January);
+    /// assert_eq!(
+    ///     datetime!(2019-12-31 23:00 UTC)
+    ///         .to_offset(offset!(+1))
+    ///         .month(),
+    ///     Month::January,
+    /// );
+    /// ```
+    pub const fn month(self) -> Month {
+        self.date().month()
+    }
+
+    /// Get the day of the date in the stored offset.
+    ///
+    /// The returned value will always be in the range `1..=31`.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).day(), 1);
+    /// assert_eq!(
+    ///     datetime!(2019-12-31 23:00 UTC)
+    ///         .to_offset(offset!(+1))
+    ///         .day(),
+    ///     1,
+    /// );
+    /// ```
+    pub const fn day(self) -> u8 {
+        self.date().day()
+    }
+
+    /// Get the day of the year of the date in the stored offset.
+    ///
+    /// The returned value will always be in the range `1..=366`.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).ordinal(), 1);
+    /// assert_eq!(
+    ///     datetime!(2019-12-31 23:00 UTC)
+    ///         .to_offset(offset!(+1))
+    ///         .ordinal(),
+    ///     1,
+    /// );
+    /// ```
+    pub const fn ordinal(self) -> u16 {
+        self.date().ordinal()
+    }
+
+    /// Get the ISO week number of the date in the stored offset.
+    ///
+    /// The returned value will always be in the range `1..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).iso_week(), 1);
+    /// assert_eq!(datetime!(2020-01-01 0:00 UTC).iso_week(), 1);
+    /// assert_eq!(datetime!(2020-12-31 0:00 UTC).iso_week(), 53);
+    /// assert_eq!(datetime!(2021-01-01 0:00 UTC).iso_week(), 53);
+    /// ```
+    pub const fn iso_week(self) -> u8 {
+        self.date().iso_week()
+    }
+
+    /// Get the week number where week 1 begins on the first Sunday.
+    ///
+    /// The returned value will always be in the range `0..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).sunday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-01-01 0:00 UTC).sunday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-12-31 0:00 UTC).sunday_based_week(), 52);
+    /// assert_eq!(datetime!(2021-01-01 0:00 UTC).sunday_based_week(), 0);
+    /// ```
+    pub const fn sunday_based_week(self) -> u8 {
+        self.date().sunday_based_week()
+    }
+
+    /// Get the week number where week 1 begins on the first Monday.
+    ///
+    /// The returned value will always be in the range `0..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).monday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-01-01 0:00 UTC).monday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-12-31 0:00 UTC).monday_based_week(), 52);
+    /// assert_eq!(datetime!(2021-01-01 0:00 UTC).monday_based_week(), 0);
+    /// ```
+    pub const fn monday_based_week(self) -> u8 {
+        self.date().monday_based_week()
+    }
+
+    /// Get the year, month, and day.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00 UTC).to_calendar_date(),
+    ///     (2019, Month::January, 1)
+    /// );
+    /// ```
+    pub const fn to_calendar_date(self) -> (i32, Month, u8) {
+        self.date().to_calendar_date()
+    }
+
+    /// Get the year and ordinal day number.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00 UTC).to_ordinal_date(),
+    ///     (2019, 1)
+    /// );
+    /// ```
+    pub const fn to_ordinal_date(self) -> (i32, u16) {
+        self.date().to_ordinal_date()
+    }
+
+    /// Get the ISO 8601 year, week number, and weekday.
+    ///
+    /// ```rust
+    /// # use time::Weekday::*;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00 UTC).to_iso_week_date(),
+    ///     (2019, 1, Tuesday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2019-10-04 0:00 UTC).to_iso_week_date(),
+    ///     (2019, 40, Friday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00 UTC).to_iso_week_date(),
+    ///     (2020, 1, Wednesday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-12-31 0:00 UTC).to_iso_week_date(),
+    ///     (2020, 53, Thursday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2021-01-01 0:00 UTC).to_iso_week_date(),
+    ///     (2020, 53, Friday)
+    /// );
+    /// ```
+    pub const fn to_iso_week_date(self) -> (i32, u8, Weekday) {
+        self.date().to_iso_week_date()
+    }
+
+    /// Get the weekday of the date in the stored offset.
+    ///
+    /// ```rust
+    /// # use time::Weekday::*;
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).weekday(), Tuesday);
+    /// assert_eq!(datetime!(2019-02-01 0:00 UTC).weekday(), Friday);
+    /// assert_eq!(datetime!(2019-03-01 0:00 UTC).weekday(), Friday);
+    /// ```
+    pub const fn weekday(self) -> Weekday {
+        self.date().weekday()
+    }
+
+    /// Get the Julian day for the date. The time is not taken into account for this calculation.
+    ///
+    /// The algorithm to perform this conversion is derived from one provided by Peter Baum; it is
+    /// freely available [here](https://www.researchgate.net/publication/316558298_Date_Algorithms).
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(-4713-11-24 0:00 UTC).to_julian_day(), 0);
+    /// assert_eq!(datetime!(2000-01-01 0:00 UTC).to_julian_day(), 2_451_545);
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).to_julian_day(), 2_458_485);
+    /// assert_eq!(datetime!(2019-12-31 0:00 UTC).to_julian_day(), 2_458_849);
+    /// ```
+    pub const fn to_julian_day(self) -> i32 {
+        self.date().to_julian_day()
+    }
+    // endregion date getters
+
+    // region: time getters
+    /// Get the clock hour, minute, and second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2020-01-01 0:00:00 UTC).to_hms(), (0, 0, 0));
+    /// assert_eq!(datetime!(2020-01-01 23:59:59 UTC).to_hms(), (23, 59, 59));
+    /// ```
+    pub const fn to_hms(self) -> (u8, u8, u8) {
+        self.time().as_hms()
+    }
+
+    /// Get the clock hour, minute, second, and millisecond.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00:00 UTC).to_hms_milli(),
+    ///     (0, 0, 0, 0)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 23:59:59.999 UTC).to_hms_milli(),
+    ///     (23, 59, 59, 999)
+    /// );
+    /// ```
+    pub const fn to_hms_milli(self) -> (u8, u8, u8, u16) {
+        self.time().as_hms_milli()
+    }
+
+    /// Get the clock hour, minute, second, and microsecond.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00:00 UTC).to_hms_micro(),
+    ///     (0, 0, 0, 0)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 23:59:59.999_999 UTC).to_hms_micro(),
+    ///     (23, 59, 59, 999_999)
+    /// );
+    /// ```
+    pub const fn to_hms_micro(self) -> (u8, u8, u8, u32) {
+        self.time().as_hms_micro()
+    }
+
+    /// Get the clock hour, minute, second, and nanosecond.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00:00 UTC).to_hms_nano(),
+    ///     (0, 0, 0, 0)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 23:59:59.999_999_999 UTC).to_hms_nano(),
+    ///     (23, 59, 59, 999_999_999)
+    /// );
+    /// ```
+    pub const fn to_hms_nano(self) -> (u8, u8, u8, u32) {
+        self.time().as_hms_nano()
+    }
+
+    /// Get the clock hour in the stored offset.
+    ///
+    /// The returned value will always be in the range `0..24`.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).hour(), 0);
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 23:59:59 UTC)
+    ///         .to_offset(offset!(-2))
+    ///         .hour(),
+    ///     21,
+    /// );
+    /// ```
+    pub const fn hour(self) -> u8 {
+        self.time().hour()
+    }
+
+    /// Get the minute within the hour in the stored offset.
+    ///
+    /// The returned value will always be in the range `0..60`.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).minute(), 0);
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 23:59:59 UTC)
+    ///         .to_offset(offset!(+0:30))
+    ///         .minute(),
+    ///     29,
+    /// );
+    /// ```
+    pub const fn minute(self) -> u8 {
+        self.time().minute()
+    }
+
+    /// Get the second within the minute in the stored offset.
+    ///
+    /// The returned value will always be in the range `0..60`.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).second(), 0);
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 23:59:59 UTC)
+    ///         .to_offset(offset!(+0:00:30))
+    ///         .second(),
+    ///     29,
+    /// );
+    /// ```
+    pub const fn second(self) -> u8 {
+        self.time().second()
+    }
+
+    // Because a `UtcOffset` is limited in resolution to one second, any subsecond value will not
+    // change when adjusting for the offset.
+
+    /// Get the milliseconds within the second in the stored offset.
+    ///
+    /// The returned value will always be in the range `0..1_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).millisecond(), 0);
+    /// assert_eq!(datetime!(2019-01-01 23:59:59.999 UTC).millisecond(), 999);
+    /// ```
+    pub const fn millisecond(self) -> u16 {
+        self.time().millisecond()
+    }
+
+    /// Get the microseconds within the second in the stored offset.
+    ///
+    /// The returned value will always be in the range `0..1_000_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).microsecond(), 0);
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 23:59:59.999_999 UTC).microsecond(),
+    ///     999_999,
+    /// );
+    /// ```
+    pub const fn microsecond(self) -> u32 {
+        self.time().microsecond()
+    }
+
+    /// Get the nanoseconds within the second in the stored offset.
+    ///
+    /// The returned value will always be in the range `0..1_000_000_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00 UTC).nanosecond(), 0);
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 23:59:59.999_999_999 UTC).nanosecond(),
+    ///     999_999_999,
+    /// );
+    /// ```
+    pub const fn nanosecond(self) -> u32 {
+        self.time().nanosecond()
+    }
+    // endregion time getters
+    // endregion getters
+
+    // region: checked arithmetic
+    /// Computes `self + duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::{datetime, offset};
+    /// let datetime = Date::MIN.midnight().assume_offset(offset!(+10));
+    /// assert_eq!(datetime.checked_add((-2).days()), None);
+    ///
+    /// let datetime = Date::MAX.midnight().assume_offset(offset!(+10));
+    /// assert_eq!(datetime.checked_add(2.days()), None);
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30 +10).checked_add(27.hours()),
+    ///     Some(datetime!(2019 - 11 - 26 18:30 +10))
+    /// );
+    /// ```
+    pub const fn checked_add(self, duration: Duration) -> Option<Self> {
+        Some(const_try_opt!(self.date_time().checked_add(duration)).assume_offset(self.offset()))
+    }
+
+    /// Computes `self - duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::{datetime, offset};
+    /// let datetime = Date::MIN.midnight().assume_offset(offset!(+10));
+    /// assert_eq!(datetime.checked_sub(2.days()), None);
+    ///
+    /// let datetime = Date::MAX.midnight().assume_offset(offset!(+10));
+    /// assert_eq!(datetime.checked_sub((-2).days()), None);
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30 +10).checked_sub(27.hours()),
+    ///     Some(datetime!(2019 - 11 - 24 12:30 +10))
+    /// );
+    /// ```
+    pub const fn checked_sub(self, duration: Duration) -> Option<Self> {
+        Some(const_try_opt!(self.date_time().checked_sub(duration)).assume_offset(self.offset()))
+    }
+    // endregion: checked arithmetic
+
+    // region: saturating arithmetic
+    /// Computes `self + duration`, saturating value on overflow.
+    ///
+    /// ```
+    /// # use time::ext::NumericalDuration;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "    datetime!(-999999-01-01 0:00 +10).saturating_add((-2).days()),"
+    )]
+    #[cfg_attr(feature = "large-dates", doc = "    datetime!(-999999-01-01 0:00 +10)")]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(-9999-01-01 0:00 +10).saturating_add((-2).days()),"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(-9999-01-01 0:00 +10)"
+    )]
+    /// );
+    ///
+    /// assert_eq!(
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "    datetime!(+999999-12-31 23:59:59.999_999_999 +10).saturating_add(2.days()),"
+    )]
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "    datetime!(+999999-12-31 23:59:59.999_999_999 +10)"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(+9999-12-31 23:59:59.999_999_999 +10).saturating_add(2.days()),"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(+9999-12-31 23:59:59.999_999_999 +10)"
+    )]
+    /// );
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30 +10).saturating_add(27.hours()),
+    ///     datetime!(2019 - 11 - 26 18:30 +10)
+    /// );
+    /// ```
+    pub const fn saturating_add(self, duration: Duration) -> Self {
+        if let Some(datetime) = self.checked_add(duration) {
+            datetime
+        } else if duration.is_negative() {
+            PrimitiveDateTime::MIN.assume_offset(self.offset())
+        } else {
+            PrimitiveDateTime::MAX.assume_offset(self.offset())
+        }
+    }
+
+    /// Computes `self - duration`, saturating value on overflow.
+    ///
+    /// ```
+    /// # use time::ext::NumericalDuration;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "    datetime!(-999999-01-01 0:00 +10).saturating_sub(2.days()),"
+    )]
+    #[cfg_attr(feature = "large-dates", doc = "    datetime!(-999999-01-01 0:00 +10)")]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(-9999-01-01 0:00 +10).saturating_sub(2.days()),"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(-9999-01-01 0:00 +10)"
+    )]
+    /// );
+    ///
+    /// assert_eq!(
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "    datetime!(+999999-12-31 23:59:59.999_999_999 +10).saturating_sub((-2).days()),"
+    )]
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "    datetime!(+999999-12-31 23:59:59.999_999_999 +10)"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(+9999-12-31 23:59:59.999_999_999 +10).saturating_sub((-2).days()),"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "    datetime!(+9999-12-31 23:59:59.999_999_999 +10)"
+    )]
+    /// );
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30 +10).saturating_sub(27.hours()),
+    ///     datetime!(2019 - 11 - 24 12:30 +10)
+    /// );
+    /// ```
+    pub const fn saturating_sub(self, duration: Duration) -> Self {
+        if let Some(datetime) = self.checked_sub(duration) {
+            datetime
+        } else if duration.is_negative() {
+            PrimitiveDateTime::MAX.assume_offset(self.offset())
+        } else {
+            PrimitiveDateTime::MIN.assume_offset(self.offset())
+        }
+    }
+    // endregion: saturating arithmetic
+}
+
+// region: replacement
+/// Methods that replace part of the `OffsetDateTime`.
+impl OffsetDateTime {
+    /// Replace the time, which is assumed to be in the stored offset. The date and offset
+    /// components are unchanged.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, time};
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 5:00 UTC).replace_time(time!(12:00)),
+    ///     datetime!(2020-01-01 12:00 UTC)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 12:00 -5).replace_time(time!(7:00)),
+    ///     datetime!(2020-01-01 7:00 -5)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00 +1).replace_time(time!(12:00)),
+    ///     datetime!(2020-01-01 12:00 +1)
+    /// );
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_time(self, time: Time) -> Self {
+        Self::new_in_offset(self.date(), time, self.offset())
+    }
+
+    /// Replace the date, which is assumed to be in the stored offset. The time and offset
+    /// components are unchanged.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, date};
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 12:00 UTC).replace_date(date!(2020-01-30)),
+    ///     datetime!(2020-01-30 12:00 UTC)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00 +1).replace_date(date!(2020-01-30)),
+    ///     datetime!(2020-01-30 0:00 +1)
+    /// );
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_date(self, date: Date) -> Self {
+        Self::new_in_offset(date, self.time(), self.offset())
+    }
+
+    /// Replace the date and time, which are assumed to be in the stored offset. The offset
+    /// component remains unchanged.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 12:00 UTC).replace_date_time(datetime!(2020-01-30 16:00)),
+    ///     datetime!(2020-01-30 16:00 UTC)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 12:00 +1).replace_date_time(datetime!(2020-01-30 0:00)),
+    ///     datetime!(2020-01-30 0:00 +1)
+    /// );
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_date_time(self, date_time: PrimitiveDateTime) -> Self {
+        date_time.assume_offset(self.offset())
+    }
+
+    /// Replace the offset. The date and time components remain unchanged.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)),
+    ///     datetime!(2020-01-01 0:00 -5)
+    /// );
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_offset(self, offset: UtcOffset) -> Self {
+        self.date_time().assume_offset(offset)
+    }
+
+    /// Replace the year. The month and day will be unchanged.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 12:00 +01).replace_year(2019),
+    ///     Ok(datetime!(2019 - 02 - 18 12:00 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year
+    /// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid year
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_year(self, year: i32) -> Result<Self, error::ComponentRange> {
+        Ok(const_try!(self.date_time().replace_year(year)).assume_offset(self.offset()))
+    }
+
+    /// Replace the month of the year.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// # use time::Month;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 12:00 +01).replace_month(Month::January),
+    ///     Ok(datetime!(2022 - 01 - 18 12:00 +01))
+    /// );
+    /// assert!(datetime!(2022 - 01 - 30 12:00 +01).replace_month(Month::February).is_err()); // 30 isn't a valid day in February
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_month(self, month: Month) -> Result<Self, error::ComponentRange> {
+        Ok(const_try!(self.date_time().replace_month(month)).assume_offset(self.offset()))
+    }
+
+    /// Replace the day of the month.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 12:00 +01).replace_day(1),
+    ///     Ok(datetime!(2022 - 02 - 01 12:00 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_day(0).is_err()); // 00 isn't a valid day
+    /// assert!(datetime!(2022 - 02 - 18 12:00 +01).replace_day(30).is_err()); // 30 isn't a valid day in February
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_day(self, day: u8) -> Result<Self, error::ComponentRange> {
+        Ok(const_try!(self.date_time().replace_day(day)).assume_offset(self.offset()))
+    }
+
+    /// Replace the day of the year.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2022-049 12:00 +01).replace_ordinal(1), Ok(datetime!(2022-001 12:00 +01)));
+    /// assert!(datetime!(2022-049 12:00 +01).replace_ordinal(0).is_err()); // 0 isn't a valid ordinal
+    /// assert!(datetime!(2022-049 12:00 +01).replace_ordinal(366).is_err()); // 2022 isn't a leap year
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_ordinal(self, ordinal: u16) -> Result<Self, error::ComponentRange> {
+        Ok(const_try!(self.date_time().replace_ordinal(ordinal)).assume_offset(self.offset()))
+    }
+
+    /// Replace the clock hour.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_hour(7),
+    ///     Ok(datetime!(2022 - 02 - 18 07:02:03.004_005_006 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_hour(24).is_err()); // 24 isn't a valid hour
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_hour(self, hour: u8) -> Result<Self, error::ComponentRange> {
+        Ok(const_try!(self.date_time().replace_hour(hour)).assume_offset(self.offset()))
+    }
+
+    /// Replace the minutes within the hour.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_minute(7),
+    ///     Ok(datetime!(2022 - 02 - 18 01:07:03.004_005_006 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_minute(60).is_err()); // 60 isn't a valid minute
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_minute(self, minute: u8) -> Result<Self, error::ComponentRange> {
+        Ok(const_try!(self.date_time().replace_minute(minute)).assume_offset(self.offset()))
+    }
+
+    /// Replace the seconds within the minute.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_second(7),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:07.004_005_006 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_second(60).is_err()); // 60 isn't a valid second
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_second(self, second: u8) -> Result<Self, error::ComponentRange> {
+        Ok(const_try!(self.date_time().replace_second(second)).assume_offset(self.offset()))
+    }
+
+    /// Replace the milliseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_millisecond(7),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:03.007 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_millisecond(1_000).is_err()); // 1_000 isn't a valid millisecond
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_millisecond(
+        self,
+        millisecond: u16,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(
+            const_try!(self.date_time().replace_millisecond(millisecond))
+                .assume_offset(self.offset()),
+        )
+    }
+
+    /// Replace the microseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_microsecond(7_008),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_microsecond(1_000_000).is_err()); // 1_000_000 isn't a valid microsecond
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_microsecond(
+        self,
+        microsecond: u32,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(
+            const_try!(self.date_time().replace_microsecond(microsecond))
+                .assume_offset(self.offset()),
+        )
+    }
+
+    /// Replace the nanoseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_nanosecond(7_008_009),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008_009 +01))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006 +01).replace_nanosecond(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond
+    /// ```
+    #[must_use = "This method does not mutate the original `OffsetDateTime`."]
+    pub const fn replace_nanosecond(self, nanosecond: u32) -> Result<Self, error::ComponentRange> {
+        Ok(
+            const_try!(self.date_time().replace_nanosecond(nanosecond))
+                .assume_offset(self.offset()),
+        )
+    }
+}
+// endregion replacement
+
+// region: formatting & parsing
+#[cfg(feature = "formatting")]
+impl OffsetDateTime {
+    /// Format the `OffsetDateTime` using the provided [format
+    /// description](crate::format_description).
+    pub fn format_into(
+        self,
+        output: &mut impl io::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<usize, error::Format> {
+        format.format_into(
+            output,
+            Some(self.date()),
+            Some(self.time()),
+            Some(self.offset()),
+        )
+    }
+
+    /// Format the `OffsetDateTime` using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::format_description;
+    /// # use time_macros::datetime;
+    /// let format = format_description::parse(
+    ///     "[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
+    ///          sign:mandatory]:[offset_minute]:[offset_second]",
+    /// )?;
+    /// assert_eq!(
+    ///     datetime!(2020-01-02 03:04:05 +06:07:08).format(&format)?,
+    ///     "2020-01-02 03:04:05 +06:07:08"
+    /// );
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format(self, format: &(impl Formattable + ?Sized)) -> Result<String, error::Format> {
+        format.format(Some(self.date()), Some(self.time()), Some(self.offset()))
+    }
+}
+
+#[cfg(feature = "parsing")]
+impl OffsetDateTime {
+    /// Parse an `OffsetDateTime` from the input using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::OffsetDateTime;
+    /// # use time_macros::{datetime, format_description};
+    /// let format = format_description!(
+    ///     "[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
+    ///          sign:mandatory]:[offset_minute]:[offset_second]"
+    /// );
+    /// assert_eq!(
+    ///     OffsetDateTime::parse("2020-01-02 03:04:05 +06:07:08", &format)?,
+    ///     datetime!(2020-01-02 03:04:05 +06:07:08)
+    /// );
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn parse(
+        input: &str,
+        description: &(impl Parsable + ?Sized),
+    ) -> Result<Self, error::Parse> {
+        description.parse_offset_date_time(input.as_bytes())
+    }
+
+    /// A helper method to check if the `OffsetDateTime` is a valid representation of a leap second.
+    /// Leap seconds, when parsed, are represented as the preceding nanosecond. However, leap
+    /// seconds can only occur as the last second of a month UTC.
+    #[cfg(feature = "parsing")]
+    pub(crate) const fn is_valid_leap_second_stand_in(self) -> bool {
+        // This comparison doesn't need to be adjusted for the stored offset, so check it first for
+        // speed.
+        if self.nanosecond() != 999_999_999 {
+            return false;
+        }
+
+        let (year, ordinal, time) = self.to_offset_raw(UtcOffset::UTC);
+        let Ok(date) = Date::from_ordinal_date(year, ordinal) else {
+            return false;
+        };
+
+        time.hour() == 23
+            && time.minute() == 59
+            && time.second() == 59
+            && date.day() == util::days_in_year_month(year, date.month())
+    }
+}
+
+impl SmartDisplay for OffsetDateTime {
+    type Metadata = ();
+
+    fn metadata(&self, _: FormatterOptions) -> Metadata<Self> {
+        let width =
+            smart_display::padded_width_of!(self.date(), " ", self.time(), " ", self.offset());
+        Metadata::new(width, self, ())
+    }
+
+    fn fmt_with_metadata(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        metadata: Metadata<Self>,
+    ) -> fmt::Result {
+        f.pad_with_width(
+            metadata.unpadded_width(),
+            format_args!("{} {} {}", self.date(), self.time(), self.offset()),
+        )
+    }
+}
+
+impl fmt::Display for OffsetDateTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        SmartDisplay::fmt(self, f)
+    }
+}
+
+impl fmt::Debug for OffsetDateTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+// endregion formatting & parsing
+
+// region: trait impls
+impl Add<Duration> for OffsetDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, duration: Duration) -> Self::Output {
+        self.checked_add(duration)
+            .expect("resulting value is out of range")
+    }
+}
+
+impl Add<StdDuration> for OffsetDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, duration: StdDuration) -> Self::Output {
+        let (is_next_day, time) = self.time().adjusting_add_std(duration);
+
+        Self::new_in_offset(
+            if is_next_day {
+                (self.date() + duration)
+                    .next_day()
+                    .expect("resulting value is out of range")
+            } else {
+                self.date() + duration
+            },
+            time,
+            self.offset,
+        )
+    }
+}
+
+impl AddAssign<Duration> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add_assign(&mut self, rhs: Duration) {
+        *self = *self + rhs;
+    }
+}
+
+impl AddAssign<StdDuration> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add_assign(&mut self, rhs: StdDuration) {
+        *self = *self + rhs;
+    }
+}
+
+impl Sub<Duration> for OffsetDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: Duration) -> Self::Output {
+        self.checked_sub(rhs)
+            .expect("resulting value is out of range")
+    }
+}
+
+impl Sub<StdDuration> for OffsetDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, duration: StdDuration) -> Self::Output {
+        let (is_previous_day, time) = self.time().adjusting_sub_std(duration);
+
+        Self::new_in_offset(
+            if is_previous_day {
+                (self.date() - duration)
+                    .previous_day()
+                    .expect("resulting value is out of range")
+            } else {
+                self.date() - duration
+            },
+            time,
+            self.offset,
+        )
+    }
+}
+
+impl SubAssign<Duration> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub_assign(&mut self, rhs: Duration) {
+        *self = *self - rhs;
+    }
+}
+
+impl SubAssign<StdDuration> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub_assign(&mut self, rhs: StdDuration) {
+        *self = *self - rhs;
+    }
+}
+
+impl Sub for OffsetDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: Self) -> Self::Output {
+        let base = self.date_time() - rhs.date_time();
+        let adjustment = Duration::seconds(
+            (self.offset.whole_seconds() - rhs.offset.whole_seconds()).extend::<i64>(),
+        );
+        base - adjustment
+    }
+}
+
+#[cfg(feature = "std")]
+impl Sub<SystemTime> for OffsetDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: SystemTime) -> Self::Output {
+        self - Self::from(rhs)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Sub<OffsetDateTime> for SystemTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: OffsetDateTime) -> Self::Output {
+        OffsetDateTime::from(self) - rhs
+    }
+}
+
+#[cfg(feature = "std")]
+impl Add<Duration> for SystemTime {
+    type Output = Self;
+
+    fn add(self, duration: Duration) -> Self::Output {
+        if duration.is_zero() {
+            self
+        } else if duration.is_positive() {
+            self + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            self - duration.unsigned_abs()
+        }
+    }
+}
+
+crate::internal_macros::impl_add_assign!(SystemTime: #[cfg(feature = "std")] Duration);
+
+#[cfg(feature = "std")]
+impl Sub<Duration> for SystemTime {
+    type Output = Self;
+
+    fn sub(self, duration: Duration) -> Self::Output {
+        (OffsetDateTime::from(self) - duration).into()
+    }
+}
+
+crate::internal_macros::impl_sub_assign!(SystemTime: #[cfg(feature = "std")] Duration);
+
+#[cfg(feature = "std")]
+impl PartialEq<SystemTime> for OffsetDateTime {
+    fn eq(&self, rhs: &SystemTime) -> bool {
+        self == &Self::from(*rhs)
+    }
+}
+
+#[cfg(feature = "std")]
+impl PartialEq<OffsetDateTime> for SystemTime {
+    fn eq(&self, rhs: &OffsetDateTime) -> bool {
+        &OffsetDateTime::from(*self) == rhs
+    }
+}
+
+#[cfg(feature = "std")]
+impl PartialOrd<SystemTime> for OffsetDateTime {
+    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
+        self.partial_cmp(&Self::from(*other))
+    }
+}
+
+#[cfg(feature = "std")]
+impl PartialOrd<OffsetDateTime> for SystemTime {
+    fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering> {
+        OffsetDateTime::from(*self).partial_cmp(other)
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<SystemTime> for OffsetDateTime {
+    fn from(system_time: SystemTime) -> Self {
+        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
+            Ok(duration) => Self::UNIX_EPOCH + duration,
+            Err(err) => Self::UNIX_EPOCH - err.duration(),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<OffsetDateTime> for SystemTime {
+    fn from(datetime: OffsetDateTime) -> Self {
+        let duration = datetime - OffsetDateTime::UNIX_EPOCH;
+
+        if duration.is_zero() {
+            Self::UNIX_EPOCH
+        } else if duration.is_positive() {
+            Self::UNIX_EPOCH + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            Self::UNIX_EPOCH - duration.unsigned_abs()
+        }
+    }
+}
+
+#[cfg(all(
+    target_family = "wasm",
+    not(any(target_os = "emscripten", target_os = "wasi")),
+    feature = "wasm-bindgen"
+))]
+impl From<js_sys::Date> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if the timestamp can not be represented.
+    fn from(js_date: js_sys::Date) -> Self {
+        // get_time() returns milliseconds
+        let timestamp_nanos = (js_date.get_time() * Nanosecond::per(Millisecond) as f64) as i128;
+        Self::from_unix_timestamp_nanos(timestamp_nanos)
+            .expect("invalid timestamp: Timestamp cannot fit in range")
+    }
+}
+
+#[cfg(all(
+    target_family = "wasm",
+    not(any(target_os = "emscripten", target_os = "wasi")),
+    feature = "wasm-bindgen"
+))]
+impl From<OffsetDateTime> for js_sys::Date {
+    fn from(datetime: OffsetDateTime) -> Self {
+        // new Date() takes milliseconds
+        let timestamp = (datetime.unix_timestamp_nanos()
+            / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
+            as f64;
+        Self::new(&timestamp.into())
+    }
+}
+// endregion trait impls
diff --git a/time/src/parsing/combinator/mod.rs b/time/src/parsing/combinator/mod.rs
new file mode 100644
index 000000000..e3e1df76c
--- /dev/null
+++ b/time/src/parsing/combinator/mod.rs
@@ -0,0 +1,194 @@
+//! Implementations of the low-level parser combinators.
+
+pub(crate) mod rfc;
+
+use num_conv::prelude::*;
+
+use crate::format_description::modifier::Padding;
+use crate::parsing::shim::{Integer, IntegerParseBytes};
+use crate::parsing::ParsedItem;
+
+/// Parse a "+" or "-" sign. Returns the ASCII byte representing the sign, if present.
+pub(crate) const fn sign(input: &[u8]) -> Option<ParsedItem<'_, u8>> {
+    match input {
+        [sign @ (b'-' | b'+'), remaining @ ..] => Some(ParsedItem(remaining, *sign)),
+        _ => None,
+    }
+}
+
+/// Consume the first matching item, returning its associated value.
+pub(crate) fn first_match<'a, T>(
+    options: impl IntoIterator<Item = (&'a [u8], T)>,
+    case_sensitive: bool,
+) -> impl FnMut(&'a [u8]) -> Option<ParsedItem<'a, T>> {
+    let mut options = options.into_iter();
+    move |input| {
+        options.find_map(|(expected, t)| {
+            if case_sensitive {
+                Some(ParsedItem(input.strip_prefix(expected)?, t))
+            } else {
+                let n = expected.len();
+                if n <= input.len() {
+                    let (head, tail) = input.split_at(n);
+                    if head.eq_ignore_ascii_case(expected) {
+                        return Some(ParsedItem(tail, t));
+                    }
+                }
+                None
+            }
+        })
+    }
+}
+
+/// Consume zero or more instances of the provided parser. The parser must return the unit value.
+pub(crate) fn zero_or_more<'a, P: Fn(&'a [u8]) -> Option<ParsedItem<'a, ()>>>(
+    parser: P,
+) -> impl FnMut(&'a [u8]) -> ParsedItem<'a, ()> {
+    move |mut input| {
+        while let Some(remaining) = parser(input) {
+            input = remaining.into_inner();
+        }
+        ParsedItem(input, ())
+    }
+}
+
+/// Consume one of or more instances of the provided parser. The parser must produce the unit value.
+pub(crate) fn one_or_more<'a, P: Fn(&'a [u8]) -> Option<ParsedItem<'a, ()>>>(
+    parser: P,
+) -> impl Fn(&'a [u8]) -> Option<ParsedItem<'a, ()>> {
+    move |mut input| {
+        input = parser(input)?.into_inner();
+        while let Some(remaining) = parser(input) {
+            input = remaining.into_inner();
+        }
+        Some(ParsedItem(input, ()))
+    }
+}
+
+/// Consume between `n` and `m` instances of the provided parser.
+pub(crate) fn n_to_m<
+    'a,
+    const N: u8,
+    const M: u8,
+    T,
+    P: Fn(&'a [u8]) -> Option<ParsedItem<'a, T>>,
+>(
+    parser: P,
+) -> impl Fn(&'a [u8]) -> Option<ParsedItem<'a, &'a [u8]>> {
+    debug_assert!(M >= N);
+    move |mut input| {
+        // We need to keep this to determine the total length eventually consumed.
+        let orig_input = input;
+
+        // Mandatory
+        for _ in 0..N {
+            input = parser(input)?.0;
+        }
+
+        // Optional
+        for _ in N..M {
+            match parser(input) {
+                Some(parsed) => input = parsed.0,
+                None => break,
+            }
+        }
+
+        Some(ParsedItem(
+            input,
+            &orig_input[..(orig_input.len() - input.len())],
+        ))
+    }
+}
+
+/// Consume between `n` and `m` digits, returning the numerical value.
+pub(crate) fn n_to_m_digits<const N: u8, const M: u8, T: Integer>(
+    input: &[u8],
+) -> Option<ParsedItem<'_, T>> {
+    debug_assert!(M >= N);
+    n_to_m::<N, M, _, _>(any_digit)(input)?.flat_map(|value| value.parse_bytes())
+}
+
+/// Consume exactly `n` digits, returning the numerical value.
+pub(crate) fn exactly_n_digits<const N: u8, T: Integer>(input: &[u8]) -> Option<ParsedItem<'_, T>> {
+    n_to_m_digits::<N, N, _>(input)
+}
+
+/// Consume exactly `n` digits, returning the numerical value.
+pub(crate) fn exactly_n_digits_padded<'a, const N: u8, T: Integer>(
+    padding: Padding,
+) -> impl Fn(&'a [u8]) -> Option<ParsedItem<'a, T>> {
+    n_to_m_digits_padded::<N, N, _>(padding)
+}
+
+/// Consume between `n` and `m` digits, returning the numerical value.
+pub(crate) fn n_to_m_digits_padded<'a, const N: u8, const M: u8, T: Integer>(
+    padding: Padding,
+) -> impl Fn(&'a [u8]) -> Option<ParsedItem<'a, T>> {
+    debug_assert!(M >= N);
+    move |mut input| match padding {
+        Padding::None => n_to_m_digits::<1, M, _>(input),
+        Padding::Space => {
+            debug_assert!(N > 0);
+
+            let mut orig_input = input;
+            for _ in 0..(N - 1) {
+                match ascii_char::<b' '>(input) {
+                    Some(parsed) => input = parsed.0,
+                    None => break,
+                }
+            }
+            let pad_width = (orig_input.len() - input.len()).truncate::<u8>();
+
+            orig_input = input;
+            for _ in 0..(N - pad_width) {
+                input = any_digit(input)?.0;
+            }
+            for _ in N..M {
+                match any_digit(input) {
+                    Some(parsed) => input = parsed.0,
+                    None => break,
+                }
+            }
+
+            ParsedItem(input, &orig_input[..(orig_input.len() - input.len())])
+                .flat_map(|value| value.parse_bytes())
+        }
+        Padding::Zero => n_to_m_digits::<N, M, _>(input),
+    }
+}
+
+/// Consume exactly one digit.
+pub(crate) const fn any_digit(input: &[u8]) -> Option<ParsedItem<'_, u8>> {
+    match input {
+        [c, remaining @ ..] if c.is_ascii_digit() => Some(ParsedItem(remaining, *c)),
+        _ => None,
+    }
+}
+
+/// Consume exactly one of the provided ASCII characters.
+pub(crate) fn ascii_char<const CHAR: u8>(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    debug_assert!(CHAR.is_ascii_graphic() || CHAR.is_ascii_whitespace());
+    match input {
+        [c, remaining @ ..] if *c == CHAR => Some(ParsedItem(remaining, ())),
+        _ => None,
+    }
+}
+
+/// Consume exactly one of the provided ASCII characters, case-insensitive.
+pub(crate) fn ascii_char_ignore_case<const CHAR: u8>(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    debug_assert!(CHAR.is_ascii_graphic() || CHAR.is_ascii_whitespace());
+    match input {
+        [c, remaining @ ..] if c.eq_ignore_ascii_case(&CHAR) => Some(ParsedItem(remaining, ())),
+        _ => None,
+    }
+}
+
+/// Optionally consume an input with a given parser.
+pub(crate) fn opt<'a, T>(
+    parser: impl Fn(&'a [u8]) -> Option<ParsedItem<'a, T>>,
+) -> impl Fn(&'a [u8]) -> ParsedItem<'a, Option<T>> {
+    move |input| match parser(input) {
+        Some(value) => value.map(Some),
+        None => ParsedItem(input, None),
+    }
+}
diff --git a/time/src/parsing/combinator/rfc/iso8601.rs b/time/src/parsing/combinator/rfc/iso8601.rs
new file mode 100644
index 000000000..91eea2dc2
--- /dev/null
+++ b/time/src/parsing/combinator/rfc/iso8601.rs
@@ -0,0 +1,175 @@
+//! Rules defined in [ISO 8601].
+//!
+//! [ISO 8601]: https://www.iso.org/iso-8601-date-and-time-format.html
+
+use core::num::{NonZeroU16, NonZeroU8};
+
+use num_conv::prelude::*;
+
+use crate::parsing::combinator::{any_digit, ascii_char, exactly_n_digits, first_match, sign};
+use crate::parsing::ParsedItem;
+use crate::{Month, Weekday};
+
+/// What kind of format is being parsed. This is used to ensure each part of the format (date, time,
+/// offset) is the same kind.
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum ExtendedKind {
+    /// The basic format.
+    Basic,
+    /// The extended format.
+    Extended,
+    /// ¯\_(ツ)_/¯
+    Unknown,
+}
+
+impl ExtendedKind {
+    /// Is it possible that the format is extended?
+    pub(crate) const fn maybe_extended(self) -> bool {
+        matches!(self, Self::Extended | Self::Unknown)
+    }
+
+    /// Is the format known for certain to be extended?
+    pub(crate) const fn is_extended(self) -> bool {
+        matches!(self, Self::Extended)
+    }
+
+    /// If the kind is `Unknown`, make it `Basic`. Otherwise, do nothing. Returns `Some` if and only
+    /// if the kind is now `Basic`.
+    pub(crate) fn coerce_basic(&mut self) -> Option<()> {
+        match self {
+            Self::Basic => Some(()),
+            Self::Extended => None,
+            Self::Unknown => {
+                *self = Self::Basic;
+                Some(())
+            }
+        }
+    }
+
+    /// If the kind is `Unknown`, make it `Extended`. Otherwise, do nothing. Returns `Some` if and
+    /// only if the kind is now `Extended`.
+    pub(crate) fn coerce_extended(&mut self) -> Option<()> {
+        match self {
+            Self::Basic => None,
+            Self::Extended => Some(()),
+            Self::Unknown => {
+                *self = Self::Extended;
+                Some(())
+            }
+        }
+    }
+}
+
+/// Parse a possibly expanded year.
+pub(crate) fn year(input: &[u8]) -> Option<ParsedItem<'_, i32>> {
+    Some(match sign(input) {
+        Some(ParsedItem(input, sign)) => exactly_n_digits::<6, u32>(input)?.map(|val| {
+            let val = val.cast_signed();
+            if sign == b'-' { -val } else { val }
+        }),
+        None => exactly_n_digits::<4, u32>(input)?.map(|val| val.cast_signed()),
+    })
+}
+
+/// Parse a month.
+pub(crate) fn month(input: &[u8]) -> Option<ParsedItem<'_, Month>> {
+    first_match(
+        [
+            (b"01".as_slice(), Month::January),
+            (b"02".as_slice(), Month::February),
+            (b"03".as_slice(), Month::March),
+            (b"04".as_slice(), Month::April),
+            (b"05".as_slice(), Month::May),
+            (b"06".as_slice(), Month::June),
+            (b"07".as_slice(), Month::July),
+            (b"08".as_slice(), Month::August),
+            (b"09".as_slice(), Month::September),
+            (b"10".as_slice(), Month::October),
+            (b"11".as_slice(), Month::November),
+            (b"12".as_slice(), Month::December),
+        ],
+        true,
+    )(input)
+}
+
+/// Parse a week number.
+pub(crate) fn week(input: &[u8]) -> Option<ParsedItem<'_, NonZeroU8>> {
+    exactly_n_digits::<2, _>(input)
+}
+
+/// Parse a day of the month.
+pub(crate) fn day(input: &[u8]) -> Option<ParsedItem<'_, NonZeroU8>> {
+    exactly_n_digits::<2, _>(input)
+}
+
+/// Parse a day of the week.
+pub(crate) fn dayk(input: &[u8]) -> Option<ParsedItem<'_, Weekday>> {
+    first_match(
+        [
+            (b"1".as_slice(), Weekday::Monday),
+            (b"2".as_slice(), Weekday::Tuesday),
+            (b"3".as_slice(), Weekday::Wednesday),
+            (b"4".as_slice(), Weekday::Thursday),
+            (b"5".as_slice(), Weekday::Friday),
+            (b"6".as_slice(), Weekday::Saturday),
+            (b"7".as_slice(), Weekday::Sunday),
+        ],
+        true,
+    )(input)
+}
+
+/// Parse a day of the year.
+pub(crate) fn dayo(input: &[u8]) -> Option<ParsedItem<'_, NonZeroU16>> {
+    exactly_n_digits::<3, _>(input)
+}
+
+/// Parse the hour.
+pub(crate) fn hour(input: &[u8]) -> Option<ParsedItem<'_, u8>> {
+    exactly_n_digits::<2, _>(input)
+}
+
+/// Parse the minute.
+pub(crate) fn min(input: &[u8]) -> Option<ParsedItem<'_, u8>> {
+    exactly_n_digits::<2, _>(input)
+}
+
+/// Parse a floating point number as its integer and optional fractional parts.
+///
+/// The number must have two digits before the decimal point. If a decimal point is present, at
+/// least one digit must follow.
+///
+/// The return type is a tuple of the integer part and optional fraction part.
+pub(crate) fn float(input: &[u8]) -> Option<ParsedItem<'_, (u8, Option<f64>)>> {
+    // Two digits before the decimal.
+    let ParsedItem(input, integer_part) = match input {
+        [
+            first_digit @ b'0'..=b'9',
+            second_digit @ b'0'..=b'9',
+            input @ ..,
+        ] => ParsedItem(input, (first_digit - b'0') * 10 + (second_digit - b'0')),
+        _ => return None,
+    };
+
+    if let Some(ParsedItem(input, ())) = decimal_sign(input) {
+        // Mandatory post-decimal digit.
+        let ParsedItem(mut input, mut fractional_part) =
+            any_digit(input)?.map(|digit| ((digit - b'0') as f64) / 10.);
+
+        let mut divisor = 10.;
+        // Any number of subsequent digits.
+        while let Some(ParsedItem(new_input, digit)) = any_digit(input) {
+            input = new_input;
+            divisor *= 10.;
+            fractional_part += (digit - b'0') as f64 / divisor;
+        }
+
+        Some(ParsedItem(input, (integer_part, Some(fractional_part))))
+    } else {
+        Some(ParsedItem(input, (integer_part, None)))
+    }
+}
+
+/// Parse a "decimal sign", which is either a comma or a period.
+fn decimal_sign(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    ascii_char::<b'.'>(input).or_else(|| ascii_char::<b','>(input))
+}
diff --git a/time/src/parsing/combinator/rfc/mod.rs b/time/src/parsing/combinator/rfc/mod.rs
new file mode 100644
index 000000000..2974a4d5c
--- /dev/null
+++ b/time/src/parsing/combinator/rfc/mod.rs
@@ -0,0 +1,10 @@
+//! Combinators for rules as defined in a standard.
+//!
+//! When applicable, these rules have been converted strictly following the ABNF syntax as specified
+//! in [RFC 2234].
+//!
+//! [RFC 2234]: https://datatracker.ietf.org/doc/html/rfc2234
+
+pub(crate) mod iso8601;
+pub(crate) mod rfc2234;
+pub(crate) mod rfc2822;
diff --git a/time/src/parsing/combinator/rfc/rfc2234.rs b/time/src/parsing/combinator/rfc/rfc2234.rs
new file mode 100644
index 000000000..675344435
--- /dev/null
+++ b/time/src/parsing/combinator/rfc/rfc2234.rs
@@ -0,0 +1,13 @@
+//! Rules defined in [RFC 2234].
+//!
+//! [RFC 2234]: https://datatracker.ietf.org/doc/html/rfc2234
+
+use crate::parsing::ParsedItem;
+
+/// Consume exactly one space or tab.
+pub(crate) const fn wsp(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    match input {
+        [b' ' | b'\t', rest @ ..] => Some(ParsedItem(rest, ())),
+        _ => None,
+    }
+}
diff --git a/time/src/parsing/combinator/rfc/rfc2822.rs b/time/src/parsing/combinator/rfc/rfc2822.rs
new file mode 100644
index 000000000..8410de06e
--- /dev/null
+++ b/time/src/parsing/combinator/rfc/rfc2822.rs
@@ -0,0 +1,115 @@
+//! Rules defined in [RFC 2822].
+//!
+//! [RFC 2822]: https://datatracker.ietf.org/doc/html/rfc2822
+
+use crate::parsing::combinator::rfc::rfc2234::wsp;
+use crate::parsing::combinator::{ascii_char, one_or_more, zero_or_more};
+use crate::parsing::ParsedItem;
+
+/// Consume the `fws` rule.
+// The full rule is equivalent to /\r\n[ \t]+|[ \t]+(?:\r\n[ \t]+)*/
+pub(crate) fn fws(mut input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    if let [b'\r', b'\n', rest @ ..] = input {
+        one_or_more(wsp)(rest)
+    } else {
+        input = one_or_more(wsp)(input)?.into_inner();
+        while let [b'\r', b'\n', rest @ ..] = input {
+            input = one_or_more(wsp)(rest)?.into_inner();
+        }
+        Some(ParsedItem(input, ()))
+    }
+}
+
+/// Consume the `cfws` rule.
+// The full rule is equivalent to any combination of `fws` and `comment` so long as it is not empty.
+pub(crate) fn cfws(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    one_or_more(|input| fws(input).or_else(|| comment(input)))(input)
+}
+
+/// Consume the `comment` rule.
+fn comment(mut input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    input = ascii_char::<b'('>(input)?.into_inner();
+    input = zero_or_more(fws)(input).into_inner();
+    while let Some(rest) = ccontent(input) {
+        input = rest.into_inner();
+        input = zero_or_more(fws)(input).into_inner();
+    }
+    input = ascii_char::<b')'>(input)?.into_inner();
+
+    Some(ParsedItem(input, ()))
+}
+
+/// Consume the `ccontent` rule.
+fn ccontent(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    ctext(input)
+        .or_else(|| quoted_pair(input))
+        .or_else(|| comment(input))
+}
+
+/// Consume the `ctext` rule.
+#[allow(clippy::unnecessary_lazy_evaluations)] // rust-lang/rust-clippy#8522
+fn ctext(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    no_ws_ctl(input).or_else(|| match input {
+        [33..=39 | 42..=91 | 93..=126, rest @ ..] => Some(ParsedItem(rest, ())),
+        _ => None,
+    })
+}
+
+/// Consume the `quoted_pair` rule.
+fn quoted_pair(mut input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    input = ascii_char::<b'\\'>(input)?.into_inner();
+
+    let old_input_len = input.len();
+
+    input = text(input).into_inner();
+
+    // If nothing is parsed, this means we hit the `obs-text` rule and nothing matched. This is
+    // technically a success, but we should still check the `obs-qp` rule to ensure we consume
+    // everything possible.
+    if input.len() == old_input_len {
+        match input {
+            [0..=127, rest @ ..] => Some(ParsedItem(rest, ())),
+            _ => Some(ParsedItem(input, ())),
+        }
+    } else {
+        Some(ParsedItem(input, ()))
+    }
+}
+
+/// Consume the `no_ws_ctl` rule.
+const fn no_ws_ctl(input: &[u8]) -> Option<ParsedItem<'_, ()>> {
+    match input {
+        [1..=8 | 11..=12 | 14..=31 | 127, rest @ ..] => Some(ParsedItem(rest, ())),
+        _ => None,
+    }
+}
+
+/// Consume the `text` rule.
+fn text<'a>(input: &'a [u8]) -> ParsedItem<'a, ()> {
+    let new_text = |input: &'a [u8]| match input {
+        [1..=9 | 11..=12 | 14..=127, rest @ ..] => Some(ParsedItem(rest, ())),
+        _ => None,
+    };
+
+    let obs_char = |input: &'a [u8]| match input {
+        // This is technically allowed, but consuming this would mean the rest of the string is
+        // eagerly consumed without consideration for where the comment actually ends.
+        [b')', ..] => None,
+        [0..=9 | 11..=12 | 14..=127, rest @ ..] => Some(rest),
+        _ => None,
+    };
+
+    let obs_text = |mut input| {
+        input = zero_or_more(ascii_char::<b'\n'>)(input).into_inner();
+        input = zero_or_more(ascii_char::<b'\r'>)(input).into_inner();
+        while let Some(rest) = obs_char(input) {
+            input = rest;
+            input = zero_or_more(ascii_char::<b'\n'>)(input).into_inner();
+            input = zero_or_more(ascii_char::<b'\r'>)(input).into_inner();
+        }
+
+        ParsedItem(input, ())
+    };
+
+    new_text(input).unwrap_or_else(|| obs_text(input))
+}
diff --git a/time/src/parsing/component.rs b/time/src/parsing/component.rs
new file mode 100644
index 000000000..e2a7e7c0d
--- /dev/null
+++ b/time/src/parsing/component.rs
@@ -0,0 +1,346 @@
+//! Parsing implementations for all [`Component`](crate::format_description::Component)s.
+
+use core::num::{NonZeroU16, NonZeroU8};
+
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::format_description::modifier;
+#[cfg(feature = "large-dates")]
+use crate::parsing::combinator::n_to_m_digits_padded;
+use crate::parsing::combinator::{
+    any_digit, exactly_n_digits, exactly_n_digits_padded, first_match, n_to_m_digits, opt, sign,
+};
+use crate::parsing::ParsedItem;
+use crate::{Month, Weekday};
+
+// region: date components
+/// Parse the "year" component of a `Date`.
+pub(crate) fn parse_year(input: &[u8], modifiers: modifier::Year) -> Option<ParsedItem<'_, i32>> {
+    match modifiers.repr {
+        modifier::YearRepr::Full => {
+            let ParsedItem(input, sign) = opt(sign)(input);
+            #[cfg(not(feature = "large-dates"))]
+            let ParsedItem(input, year) =
+                exactly_n_digits_padded::<4, u32>(modifiers.padding)(input)?;
+            #[cfg(feature = "large-dates")]
+            let ParsedItem(input, year) =
+                n_to_m_digits_padded::<4, 6, u32>(modifiers.padding)(input)?;
+            match sign {
+                Some(b'-') => Some(ParsedItem(input, -year.cast_signed())),
+                None if modifiers.sign_is_mandatory || year >= 10_000 => None,
+                _ => Some(ParsedItem(input, year.cast_signed())),
+            }
+        }
+        modifier::YearRepr::LastTwo => Some(
+            exactly_n_digits_padded::<2, u32>(modifiers.padding)(input)?.map(|v| v.cast_signed()),
+        ),
+    }
+}
+
+/// Parse the "month" component of a `Date`.
+pub(crate) fn parse_month(
+    input: &[u8],
+    modifiers: modifier::Month,
+) -> Option<ParsedItem<'_, Month>> {
+    use Month::*;
+    let ParsedItem(remaining, value) = first_match(
+        match modifiers.repr {
+            modifier::MonthRepr::Numerical => {
+                return exactly_n_digits_padded::<2, _>(modifiers.padding)(input)?
+                    .flat_map(|n| Month::from_number(n).ok());
+            }
+            modifier::MonthRepr::Long => [
+                (b"January".as_slice(), January),
+                (b"February".as_slice(), February),
+                (b"March".as_slice(), March),
+                (b"April".as_slice(), April),
+                (b"May".as_slice(), May),
+                (b"June".as_slice(), June),
+                (b"July".as_slice(), July),
+                (b"August".as_slice(), August),
+                (b"September".as_slice(), September),
+                (b"October".as_slice(), October),
+                (b"November".as_slice(), November),
+                (b"December".as_slice(), December),
+            ],
+            modifier::MonthRepr::Short => [
+                (b"Jan".as_slice(), January),
+                (b"Feb".as_slice(), February),
+                (b"Mar".as_slice(), March),
+                (b"Apr".as_slice(), April),
+                (b"May".as_slice(), May),
+                (b"Jun".as_slice(), June),
+                (b"Jul".as_slice(), July),
+                (b"Aug".as_slice(), August),
+                (b"Sep".as_slice(), September),
+                (b"Oct".as_slice(), October),
+                (b"Nov".as_slice(), November),
+                (b"Dec".as_slice(), December),
+            ],
+        },
+        modifiers.case_sensitive,
+    )(input)?;
+    Some(ParsedItem(remaining, value))
+}
+
+/// Parse the "week number" component of a `Date`.
+pub(crate) fn parse_week_number(
+    input: &[u8],
+    modifiers: modifier::WeekNumber,
+) -> Option<ParsedItem<'_, u8>> {
+    exactly_n_digits_padded::<2, _>(modifiers.padding)(input)
+}
+
+/// Parse the "weekday" component of a `Date`.
+pub(crate) fn parse_weekday(
+    input: &[u8],
+    modifiers: modifier::Weekday,
+) -> Option<ParsedItem<'_, Weekday>> {
+    first_match(
+        match (modifiers.repr, modifiers.one_indexed) {
+            (modifier::WeekdayRepr::Short, _) => [
+                (b"Mon".as_slice(), Weekday::Monday),
+                (b"Tue".as_slice(), Weekday::Tuesday),
+                (b"Wed".as_slice(), Weekday::Wednesday),
+                (b"Thu".as_slice(), Weekday::Thursday),
+                (b"Fri".as_slice(), Weekday::Friday),
+                (b"Sat".as_slice(), Weekday::Saturday),
+                (b"Sun".as_slice(), Weekday::Sunday),
+            ],
+            (modifier::WeekdayRepr::Long, _) => [
+                (b"Monday".as_slice(), Weekday::Monday),
+                (b"Tuesday".as_slice(), Weekday::Tuesday),
+                (b"Wednesday".as_slice(), Weekday::Wednesday),
+                (b"Thursday".as_slice(), Weekday::Thursday),
+                (b"Friday".as_slice(), Weekday::Friday),
+                (b"Saturday".as_slice(), Weekday::Saturday),
+                (b"Sunday".as_slice(), Weekday::Sunday),
+            ],
+            (modifier::WeekdayRepr::Sunday, false) => [
+                (b"1".as_slice(), Weekday::Monday),
+                (b"2".as_slice(), Weekday::Tuesday),
+                (b"3".as_slice(), Weekday::Wednesday),
+                (b"4".as_slice(), Weekday::Thursday),
+                (b"5".as_slice(), Weekday::Friday),
+                (b"6".as_slice(), Weekday::Saturday),
+                (b"0".as_slice(), Weekday::Sunday),
+            ],
+            (modifier::WeekdayRepr::Sunday, true) => [
+                (b"2".as_slice(), Weekday::Monday),
+                (b"3".as_slice(), Weekday::Tuesday),
+                (b"4".as_slice(), Weekday::Wednesday),
+                (b"5".as_slice(), Weekday::Thursday),
+                (b"6".as_slice(), Weekday::Friday),
+                (b"7".as_slice(), Weekday::Saturday),
+                (b"1".as_slice(), Weekday::Sunday),
+            ],
+            (modifier::WeekdayRepr::Monday, false) => [
+                (b"0".as_slice(), Weekday::Monday),
+                (b"1".as_slice(), Weekday::Tuesday),
+                (b"2".as_slice(), Weekday::Wednesday),
+                (b"3".as_slice(), Weekday::Thursday),
+                (b"4".as_slice(), Weekday::Friday),
+                (b"5".as_slice(), Weekday::Saturday),
+                (b"6".as_slice(), Weekday::Sunday),
+            ],
+            (modifier::WeekdayRepr::Monday, true) => [
+                (b"1".as_slice(), Weekday::Monday),
+                (b"2".as_slice(), Weekday::Tuesday),
+                (b"3".as_slice(), Weekday::Wednesday),
+                (b"4".as_slice(), Weekday::Thursday),
+                (b"5".as_slice(), Weekday::Friday),
+                (b"6".as_slice(), Weekday::Saturday),
+                (b"7".as_slice(), Weekday::Sunday),
+            ],
+        },
+        modifiers.case_sensitive,
+    )(input)
+}
+
+/// Parse the "ordinal" component of a `Date`.
+pub(crate) fn parse_ordinal(
+    input: &[u8],
+    modifiers: modifier::Ordinal,
+) -> Option<ParsedItem<'_, NonZeroU16>> {
+    exactly_n_digits_padded::<3, _>(modifiers.padding)(input)
+}
+
+/// Parse the "day" component of a `Date`.
+pub(crate) fn parse_day(
+    input: &[u8],
+    modifiers: modifier::Day,
+) -> Option<ParsedItem<'_, NonZeroU8>> {
+    exactly_n_digits_padded::<2, _>(modifiers.padding)(input)
+}
+// endregion date components
+
+// region: time components
+/// Indicate whether the hour is "am" or "pm".
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Period {
+    #[allow(clippy::missing_docs_in_private_items)]
+    Am,
+    #[allow(clippy::missing_docs_in_private_items)]
+    Pm,
+}
+
+/// Parse the "hour" component of a `Time`.
+pub(crate) fn parse_hour(input: &[u8], modifiers: modifier::Hour) -> Option<ParsedItem<'_, u8>> {
+    exactly_n_digits_padded::<2, _>(modifiers.padding)(input)
+}
+
+/// Parse the "minute" component of a `Time`.
+pub(crate) fn parse_minute(
+    input: &[u8],
+    modifiers: modifier::Minute,
+) -> Option<ParsedItem<'_, u8>> {
+    exactly_n_digits_padded::<2, _>(modifiers.padding)(input)
+}
+
+/// Parse the "second" component of a `Time`.
+pub(crate) fn parse_second(
+    input: &[u8],
+    modifiers: modifier::Second,
+) -> Option<ParsedItem<'_, u8>> {
+    exactly_n_digits_padded::<2, _>(modifiers.padding)(input)
+}
+
+/// Parse the "period" component of a `Time`. Required if the hour is on a 12-hour clock.
+pub(crate) fn parse_period(
+    input: &[u8],
+    modifiers: modifier::Period,
+) -> Option<ParsedItem<'_, Period>> {
+    first_match(
+        if modifiers.is_uppercase {
+            [
+                (b"AM".as_slice(), Period::Am),
+                (b"PM".as_slice(), Period::Pm),
+            ]
+        } else {
+            [
+                (b"am".as_slice(), Period::Am),
+                (b"pm".as_slice(), Period::Pm),
+            ]
+        },
+        modifiers.case_sensitive,
+    )(input)
+}
+
+/// Parse the "subsecond" component of a `Time`.
+pub(crate) fn parse_subsecond(
+    input: &[u8],
+    modifiers: modifier::Subsecond,
+) -> Option<ParsedItem<'_, u32>> {
+    use modifier::SubsecondDigits::*;
+    Some(match modifiers.digits {
+        One => exactly_n_digits::<1, u32>(input)?.map(|v| v * 100_000_000),
+        Two => exactly_n_digits::<2, u32>(input)?.map(|v| v * 10_000_000),
+        Three => exactly_n_digits::<3, u32>(input)?.map(|v| v * 1_000_000),
+        Four => exactly_n_digits::<4, u32>(input)?.map(|v| v * 100_000),
+        Five => exactly_n_digits::<5, u32>(input)?.map(|v| v * 10_000),
+        Six => exactly_n_digits::<6, u32>(input)?.map(|v| v * 1_000),
+        Seven => exactly_n_digits::<7, u32>(input)?.map(|v| v * 100),
+        Eight => exactly_n_digits::<8, u32>(input)?.map(|v| v * 10),
+        Nine => exactly_n_digits::<9, _>(input)?,
+        OneOrMore => {
+            let ParsedItem(mut input, mut value) =
+                any_digit(input)?.map(|v| (v - b'0').extend::<u32>() * 100_000_000);
+
+            let mut multiplier = 10_000_000;
+            while let Some(ParsedItem(new_input, digit)) = any_digit(input) {
+                value += (digit - b'0').extend::<u32>() * multiplier;
+                input = new_input;
+                multiplier /= 10;
+            }
+
+            ParsedItem(input, value)
+        }
+    })
+}
+// endregion time components
+
+// region: offset components
+/// Parse the "hour" component of a `UtcOffset`.
+///
+/// Returns the value and whether the value is negative. This is used for when "-0" is parsed.
+pub(crate) fn parse_offset_hour(
+    input: &[u8],
+    modifiers: modifier::OffsetHour,
+) -> Option<ParsedItem<'_, (i8, bool)>> {
+    let ParsedItem(input, sign) = opt(sign)(input);
+    let ParsedItem(input, hour) = exactly_n_digits_padded::<2, u8>(modifiers.padding)(input)?;
+    match sign {
+        Some(b'-') => Some(ParsedItem(input, (-hour.cast_signed(), true))),
+        None if modifiers.sign_is_mandatory => None,
+        _ => Some(ParsedItem(input, (hour.cast_signed(), false))),
+    }
+}
+
+/// Parse the "minute" component of a `UtcOffset`.
+pub(crate) fn parse_offset_minute(
+    input: &[u8],
+    modifiers: modifier::OffsetMinute,
+) -> Option<ParsedItem<'_, i8>> {
+    Some(
+        exactly_n_digits_padded::<2, u8>(modifiers.padding)(input)?
+            .map(|offset_minute| offset_minute.cast_signed()),
+    )
+}
+
+/// Parse the "second" component of a `UtcOffset`.
+pub(crate) fn parse_offset_second(
+    input: &[u8],
+    modifiers: modifier::OffsetSecond,
+) -> Option<ParsedItem<'_, i8>> {
+    Some(
+        exactly_n_digits_padded::<2, u8>(modifiers.padding)(input)?
+            .map(|offset_second| offset_second.cast_signed()),
+    )
+}
+// endregion offset components
+
+/// Ignore the given number of bytes.
+pub(crate) fn parse_ignore(
+    input: &[u8],
+    modifiers: modifier::Ignore,
+) -> Option<ParsedItem<'_, ()>> {
+    let modifier::Ignore { count } = modifiers;
+    let input = input.get((count.get().extend())..)?;
+    Some(ParsedItem(input, ()))
+}
+
+/// Parse the Unix timestamp component.
+pub(crate) fn parse_unix_timestamp(
+    input: &[u8],
+    modifiers: modifier::UnixTimestamp,
+) -> Option<ParsedItem<'_, i128>> {
+    let ParsedItem(input, sign) = opt(sign)(input);
+    let ParsedItem(input, nano_timestamp) = match modifiers.precision {
+        modifier::UnixTimestampPrecision::Second => n_to_m_digits::<1, 14, u128>(input)?
+            .map(|val| val * Nanosecond::per(Second).extend::<u128>()),
+        modifier::UnixTimestampPrecision::Millisecond => n_to_m_digits::<1, 17, u128>(input)?
+            .map(|val| val * Nanosecond::per(Millisecond).extend::<u128>()),
+        modifier::UnixTimestampPrecision::Microsecond => n_to_m_digits::<1, 20, u128>(input)?
+            .map(|val| val * Nanosecond::per(Microsecond).extend::<u128>()),
+        modifier::UnixTimestampPrecision::Nanosecond => n_to_m_digits::<1, 23, _>(input)?,
+    };
+
+    match sign {
+        Some(b'-') => Some(ParsedItem(input, -nano_timestamp.cast_signed())),
+        None if modifiers.sign_is_mandatory => None,
+        _ => Some(ParsedItem(input, nano_timestamp.cast_signed())),
+    }
+}
+
+/// Parse the `end` component, which represents the end of input. If any input is remaining, `None`
+/// is returned.
+pub(crate) const fn parse_end(input: &[u8], end: modifier::End) -> Option<ParsedItem<'_, ()>> {
+    let modifier::End {} = end;
+
+    if input.is_empty() {
+        Some(ParsedItem(input, ()))
+    } else {
+        None
+    }
+}
diff --git a/time/src/parsing/iso8601.rs b/time/src/parsing/iso8601.rs
new file mode 100644
index 000000000..000835b0d
--- /dev/null
+++ b/time/src/parsing/iso8601.rs
@@ -0,0 +1,326 @@
+//! Parse parts of an ISO 8601-formatted value.
+
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::error;
+use crate::error::ParseFromDescription::{InvalidComponent, InvalidLiteral};
+use crate::format_description::well_known::iso8601::EncodedConfig;
+use crate::format_description::well_known::Iso8601;
+use crate::parsing::combinator::rfc::iso8601::{
+    day, dayk, dayo, float, hour, min, month, week, year, ExtendedKind,
+};
+use crate::parsing::combinator::{ascii_char, sign};
+use crate::parsing::{Parsed, ParsedItem};
+
+impl<const CONFIG: EncodedConfig> Iso8601<CONFIG> {
+    // Basic: [year][month][day]
+    // Extended: [year]["-"][month]["-"][day]
+    // Basic: [year][dayo]
+    // Extended: [year]["-"][dayo]
+    // Basic: [year]["W"][week][dayk]
+    // Extended: [year]["-"]["W"][week]["-"][dayk]
+    /// Parse a date in the basic or extended format. Reduced precision is permitted.
+    pub(crate) fn parse_date<'a>(
+        parsed: &'a mut Parsed,
+        extended_kind: &'a mut ExtendedKind,
+    ) -> impl FnMut(&[u8]) -> Result<&[u8], error::Parse> + 'a {
+        move |input| {
+            // Same for any acceptable format.
+            let ParsedItem(mut input, year) = year(input).ok_or(InvalidComponent("year"))?;
+            *extended_kind = match ascii_char::<b'-'>(input) {
+                Some(ParsedItem(new_input, ())) => {
+                    input = new_input;
+                    ExtendedKind::Extended
+                }
+                None => ExtendedKind::Basic, // no separator before mandatory month/ordinal/week
+            };
+
+            let parsed_month_day = (|| {
+                let ParsedItem(mut input, month) = month(input).ok_or(InvalidComponent("month"))?;
+                if extended_kind.is_extended() {
+                    input = ascii_char::<b'-'>(input)
+                        .ok_or(InvalidLiteral)?
+                        .into_inner();
+                }
+                let ParsedItem(input, day) = day(input).ok_or(InvalidComponent("day"))?;
+                Ok(ParsedItem(input, (month, day)))
+            })();
+            let mut ret_error = match parsed_month_day {
+                Ok(ParsedItem(input, (month, day))) => {
+                    *parsed = parsed
+                        .with_year(year)
+                        .ok_or(InvalidComponent("year"))?
+                        .with_month(month)
+                        .ok_or(InvalidComponent("month"))?
+                        .with_day(day)
+                        .ok_or(InvalidComponent("day"))?;
+                    return Ok(input);
+                }
+                Err(err) => err,
+            };
+
+            // Don't check for `None`, as the error from year-month-day will always take priority.
+            if let Some(ParsedItem(input, ordinal)) = dayo(input) {
+                *parsed = parsed
+                    .with_year(year)
+                    .ok_or(InvalidComponent("year"))?
+                    .with_ordinal(ordinal)
+                    .ok_or(InvalidComponent("ordinal"))?;
+                return Ok(input);
+            }
+
+            let parsed_week_weekday = (|| {
+                let input = ascii_char::<b'W'>(input)
+                    .ok_or((false, InvalidLiteral))?
+                    .into_inner();
+                let ParsedItem(mut input, week) =
+                    week(input).ok_or((true, InvalidComponent("week")))?;
+                if extended_kind.is_extended() {
+                    input = ascii_char::<b'-'>(input)
+                        .ok_or((true, InvalidLiteral))?
+                        .into_inner();
+                }
+                let ParsedItem(input, weekday) =
+                    dayk(input).ok_or((true, InvalidComponent("weekday")))?;
+                Ok(ParsedItem(input, (week, weekday)))
+            })();
+            match parsed_week_weekday {
+                Ok(ParsedItem(input, (week, weekday))) => {
+                    *parsed = parsed
+                        .with_iso_year(year)
+                        .ok_or(InvalidComponent("year"))?
+                        .with_iso_week_number(week)
+                        .ok_or(InvalidComponent("week"))?
+                        .with_weekday(weekday)
+                        .ok_or(InvalidComponent("weekday"))?;
+                    return Ok(input);
+                }
+                Err((false, _err)) => {}
+                // This error is more accurate than the one from year-month-day.
+                Err((true, err)) => ret_error = err,
+            }
+
+            Err(ret_error.into())
+        }
+    }
+
+    // Basic: ["T"][hour][min][sec]
+    // Extended: ["T"][hour][":"][min][":"][sec]
+    // Reduced precision: components after [hour] (including their preceding separator) can be
+    // omitted. ["T"] can be omitted if there is no date present.
+    /// Parse a time in the basic or extended format. Reduced precision is permitted.
+    pub(crate) fn parse_time<'a>(
+        parsed: &'a mut Parsed,
+        extended_kind: &'a mut ExtendedKind,
+        date_is_present: bool,
+    ) -> impl FnMut(&[u8]) -> Result<&[u8], error::Parse> + 'a {
+        move |mut input| {
+            if date_is_present {
+                input = ascii_char::<b'T'>(input)
+                    .ok_or(InvalidLiteral)?
+                    .into_inner();
+            }
+
+            let ParsedItem(mut input, hour) = float(input).ok_or(InvalidComponent("hour"))?;
+            match hour {
+                (hour, None) => parsed.set_hour_24(hour).ok_or(InvalidComponent("hour"))?,
+                (hour, Some(fractional_part)) => {
+                    *parsed = parsed
+                        .with_hour_24(hour)
+                        .ok_or(InvalidComponent("hour"))?
+                        .with_minute((fractional_part * Second::per(Minute) as f64) as _)
+                        .ok_or(InvalidComponent("minute"))?
+                        .with_second(
+                            (fractional_part * Second::per(Hour) as f64 % Minute::per(Hour) as f64)
+                                as _,
+                        )
+                        .ok_or(InvalidComponent("second"))?
+                        .with_subsecond(
+                            (fractional_part * Nanosecond::per(Hour) as f64
+                                % Nanosecond::per(Second) as f64) as _,
+                        )
+                        .ok_or(InvalidComponent("subsecond"))?;
+                    return Ok(input);
+                }
+            };
+
+            if let Some(ParsedItem(new_input, ())) = ascii_char::<b':'>(input) {
+                extended_kind
+                    .coerce_extended()
+                    .ok_or(InvalidComponent("minute"))?;
+                input = new_input;
+            };
+
+            let mut input = match float(input) {
+                Some(ParsedItem(input, (minute, None))) => {
+                    extended_kind.coerce_basic();
+                    parsed
+                        .set_minute(minute)
+                        .ok_or(InvalidComponent("minute"))?;
+                    input
+                }
+                Some(ParsedItem(input, (minute, Some(fractional_part)))) => {
+                    // `None` is valid behavior, so don't error if this fails.
+                    extended_kind.coerce_basic();
+                    *parsed = parsed
+                        .with_minute(minute)
+                        .ok_or(InvalidComponent("minute"))?
+                        .with_second((fractional_part * Second::per(Minute) as f64) as _)
+                        .ok_or(InvalidComponent("second"))?
+                        .with_subsecond(
+                            (fractional_part * Nanosecond::per(Minute) as f64
+                                % Nanosecond::per(Second) as f64) as _,
+                        )
+                        .ok_or(InvalidComponent("subsecond"))?;
+                    return Ok(input);
+                }
+                // colon was present, so minutes are required
+                None if extended_kind.is_extended() => {
+                    return Err(error::Parse::ParseFromDescription(InvalidComponent(
+                        "minute",
+                    )));
+                }
+                None => {
+                    // Missing components are assumed to be zero.
+                    *parsed = parsed
+                        .with_minute(0)
+                        .ok_or(InvalidComponent("minute"))?
+                        .with_second(0)
+                        .ok_or(InvalidComponent("second"))?
+                        .with_subsecond(0)
+                        .ok_or(InvalidComponent("subsecond"))?;
+                    return Ok(input);
+                }
+            };
+
+            if extended_kind.is_extended() {
+                match ascii_char::<b':'>(input) {
+                    Some(ParsedItem(new_input, ())) => input = new_input,
+                    None => {
+                        *parsed = parsed
+                            .with_second(0)
+                            .ok_or(InvalidComponent("second"))?
+                            .with_subsecond(0)
+                            .ok_or(InvalidComponent("subsecond"))?;
+                        return Ok(input);
+                    }
+                }
+            }
+
+            let (input, second, subsecond) = match float(input) {
+                Some(ParsedItem(input, (second, None))) => (input, second, 0),
+                Some(ParsedItem(input, (second, Some(fractional_part)))) => (
+                    input,
+                    second,
+                    round(fractional_part * Nanosecond::per(Second) as f64) as _,
+                ),
+                None if extended_kind.is_extended() => {
+                    return Err(error::Parse::ParseFromDescription(InvalidComponent(
+                        "second",
+                    )));
+                }
+                // Missing components are assumed to be zero.
+                None => (input, 0, 0),
+            };
+            *parsed = parsed
+                .with_second(second)
+                .ok_or(InvalidComponent("second"))?
+                .with_subsecond(subsecond)
+                .ok_or(InvalidComponent("subsecond"))?;
+
+            Ok(input)
+        }
+    }
+
+    // Basic: [±][hour][min] or ["Z"]
+    // Extended: [±][hour][":"][min] or ["Z"]
+    // Reduced precision: [±][hour] or ["Z"]
+    /// Parse a UTC offset in the basic or extended format. Reduced precision is supported.
+    pub(crate) fn parse_offset<'a>(
+        parsed: &'a mut Parsed,
+        extended_kind: &'a mut ExtendedKind,
+    ) -> impl FnMut(&[u8]) -> Result<&[u8], error::Parse> + 'a {
+        move |input| {
+            if let Some(ParsedItem(input, ())) = ascii_char::<b'Z'>(input) {
+                *parsed = parsed
+                    .with_offset_hour(0)
+                    .ok_or(InvalidComponent("offset hour"))?
+                    .with_offset_minute_signed(0)
+                    .ok_or(InvalidComponent("offset minute"))?
+                    .with_offset_second_signed(0)
+                    .ok_or(InvalidComponent("offset second"))?;
+                return Ok(input);
+            }
+
+            let ParsedItem(input, sign) = sign(input).ok_or(InvalidComponent("offset hour"))?;
+            let mut input = hour(input)
+                .and_then(|parsed_item| {
+                    parsed_item.consume_value(|hour| {
+                        parsed.set_offset_hour(if sign == b'-' {
+                            -hour.cast_signed()
+                        } else {
+                            hour.cast_signed()
+                        })
+                    })
+                })
+                .ok_or(InvalidComponent("offset hour"))?;
+
+            if extended_kind.maybe_extended() {
+                if let Some(ParsedItem(new_input, ())) = ascii_char::<b':'>(input) {
+                    extended_kind
+                        .coerce_extended()
+                        .ok_or(InvalidComponent("offset minute"))?;
+                    input = new_input;
+                };
+            }
+
+            match min(input) {
+                Some(ParsedItem(new_input, min)) => {
+                    input = new_input;
+                    parsed
+                        .set_offset_minute_signed(if sign == b'-' {
+                            -min.cast_signed()
+                        } else {
+                            min.cast_signed()
+                        })
+                        .ok_or(InvalidComponent("offset minute"))?;
+                }
+                None => {
+                    // Omitted offset minute is assumed to be zero.
+                    parsed.set_offset_minute_signed(0);
+                }
+            }
+
+            // If `:` was present, the format has already been set to extended. As such, this call
+            // will do nothing in that case. If there wasn't `:` but minutes were
+            // present, we know it's the basic format. Do not use `?` on the call, as
+            // returning `None` is valid behavior.
+            extended_kind.coerce_basic();
+
+            Ok(input)
+        }
+    }
+}
+
+/// Round wrapper that uses hardware implementation if `std` is available, falling back to manual
+/// implementation for `no_std`
+fn round(value: f64) -> f64 {
+    #[cfg(feature = "std")]
+    {
+        value.round()
+    }
+    #[cfg(not(feature = "std"))]
+    {
+        round_impl(value)
+    }
+}
+
+#[cfg(not(feature = "std"))]
+#[allow(clippy::missing_docs_in_private_items)]
+fn round_impl(value: f64) -> f64 {
+    debug_assert!(value.is_sign_positive() && !value.is_nan());
+
+    let f = value % 1.;
+    if f < 0.5 { value - f } else { value - f + 1. }
+}
diff --git a/time/src/parsing/mod.rs b/time/src/parsing/mod.rs
new file mode 100644
index 000000000..34e927366
--- /dev/null
+++ b/time/src/parsing/mod.rs
@@ -0,0 +1,57 @@
+//! Parsing for various types.
+
+pub(crate) mod combinator;
+pub(crate) mod component;
+mod iso8601;
+pub(crate) mod parsable;
+mod parsed;
+pub(crate) mod shim;
+
+pub use self::parsable::Parsable;
+pub use self::parsed::Parsed;
+
+/// An item that has been parsed. Represented as a `(remaining, value)` pair.
+#[derive(Debug)]
+pub(crate) struct ParsedItem<'a, T>(pub(crate) &'a [u8], pub(crate) T);
+
+impl<'a, T> ParsedItem<'a, T> {
+    /// Map the value to a new value, preserving the remaining input.
+    pub(crate) fn map<U>(self, f: impl FnOnce(T) -> U) -> ParsedItem<'a, U> {
+        ParsedItem(self.0, f(self.1))
+    }
+
+    /// Map the value to a new, optional value, preserving the remaining input.
+    pub(crate) fn flat_map<U>(self, f: impl FnOnce(T) -> Option<U>) -> Option<ParsedItem<'a, U>> {
+        Some(ParsedItem(self.0, f(self.1)?))
+    }
+
+    /// Consume the stored value with the provided function. The remaining input is returned.
+    #[must_use = "this returns the remaining input"]
+    pub(crate) fn consume_value(self, f: impl FnOnce(T) -> Option<()>) -> Option<&'a [u8]> {
+        f(self.1)?;
+        Some(self.0)
+    }
+
+    /// Filter the value with the provided function. If the function returns `false`, the value
+    /// is discarded and `None` is returned. Otherwise, the value is preserved and `Some(self)` is
+    /// returned.
+    pub(crate) fn filter(self, f: impl FnOnce(&T) -> bool) -> Option<Self> {
+        f(&self.1).then_some(self)
+    }
+}
+
+impl<'a> ParsedItem<'a, ()> {
+    /// Discard the unit value, returning the remaining input.
+    #[must_use = "this returns the remaining input"]
+    pub(crate) const fn into_inner(self) -> &'a [u8] {
+        self.0
+    }
+}
+
+impl<'a> ParsedItem<'a, Option<()>> {
+    /// Discard the potential unit value, returning the remaining input.
+    #[must_use = "this returns the remaining input"]
+    pub(crate) const fn into_inner(self) -> &'a [u8] {
+        self.0
+    }
+}
diff --git a/time/src/parsing/parsable.rs b/time/src/parsing/parsable.rs
new file mode 100644
index 000000000..8386d132f
--- /dev/null
+++ b/time/src/parsing/parsable.rs
@@ -0,0 +1,805 @@
+//! A trait that can be used to parse an item from an input.
+
+use core::ops::Deref;
+
+use num_conv::prelude::*;
+
+use crate::error::TryFromParsed;
+use crate::format_description::well_known::iso8601::EncodedConfig;
+use crate::format_description::well_known::{Iso8601, Rfc2822, Rfc3339};
+use crate::format_description::BorrowedFormatItem;
+#[cfg(feature = "alloc")]
+use crate::format_description::OwnedFormatItem;
+use crate::internal_macros::bug;
+use crate::parsing::{Parsed, ParsedItem};
+use crate::{error, Date, Month, OffsetDateTime, Time, UtcOffset, Weekday};
+
+/// A type that can be parsed.
+#[cfg_attr(docsrs, doc(notable_trait))]
+#[doc(alias = "Parseable")]
+pub trait Parsable: sealed::Sealed {}
+impl Parsable for BorrowedFormatItem<'_> {}
+impl Parsable for [BorrowedFormatItem<'_>] {}
+#[cfg(feature = "alloc")]
+impl Parsable for OwnedFormatItem {}
+#[cfg(feature = "alloc")]
+impl Parsable for [OwnedFormatItem] {}
+impl Parsable for Rfc2822 {}
+impl Parsable for Rfc3339 {}
+impl<const CONFIG: EncodedConfig> Parsable for Iso8601<CONFIG> {}
+impl<T: Deref> Parsable for T where T::Target: Parsable {}
+
+/// Seal the trait to prevent downstream users from implementing it, while still allowing it to
+/// exist in generic bounds.
+mod sealed {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+    use crate::PrimitiveDateTime;
+
+    /// Parse the item using a format description and an input.
+    pub trait Sealed {
+        /// Parse the item into the provided [`Parsed`] struct.
+        ///
+        /// This method can be used to parse a single component without parsing the full value.
+        fn parse_into<'a>(
+            &self,
+            input: &'a [u8],
+            parsed: &mut Parsed,
+        ) -> Result<&'a [u8], error::Parse>;
+
+        /// Parse the item into a new [`Parsed`] struct.
+        ///
+        /// This method can only be used to parse a complete value of a type. If any characters
+        /// remain after parsing, an error will be returned.
+        fn parse(&self, input: &[u8]) -> Result<Parsed, error::Parse> {
+            let mut parsed = Parsed::new();
+            if self.parse_into(input, &mut parsed)?.is_empty() {
+                Ok(parsed)
+            } else {
+                Err(error::Parse::ParseFromDescription(
+                    error::ParseFromDescription::UnexpectedTrailingCharacters,
+                ))
+            }
+        }
+
+        /// Parse a [`Date`] from the format description.
+        fn parse_date(&self, input: &[u8]) -> Result<Date, error::Parse> {
+            Ok(self.parse(input)?.try_into()?)
+        }
+
+        /// Parse a [`Time`] from the format description.
+        fn parse_time(&self, input: &[u8]) -> Result<Time, error::Parse> {
+            Ok(self.parse(input)?.try_into()?)
+        }
+
+        /// Parse a [`UtcOffset`] from the format description.
+        fn parse_offset(&self, input: &[u8]) -> Result<UtcOffset, error::Parse> {
+            Ok(self.parse(input)?.try_into()?)
+        }
+
+        /// Parse a [`PrimitiveDateTime`] from the format description.
+        fn parse_primitive_date_time(
+            &self,
+            input: &[u8],
+        ) -> Result<PrimitiveDateTime, error::Parse> {
+            Ok(self.parse(input)?.try_into()?)
+        }
+
+        /// Parse a [`OffsetDateTime`] from the format description.
+        fn parse_offset_date_time(&self, input: &[u8]) -> Result<OffsetDateTime, error::Parse> {
+            Ok(self.parse(input)?.try_into()?)
+        }
+    }
+}
+
+// region: custom formats
+impl sealed::Sealed for BorrowedFormatItem<'_> {
+    fn parse_into<'a>(
+        &self,
+        input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        Ok(parsed.parse_item(input, self)?)
+    }
+}
+
+impl sealed::Sealed for [BorrowedFormatItem<'_>] {
+    fn parse_into<'a>(
+        &self,
+        input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        Ok(parsed.parse_items(input, self)?)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl sealed::Sealed for OwnedFormatItem {
+    fn parse_into<'a>(
+        &self,
+        input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        Ok(parsed.parse_item(input, self)?)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl sealed::Sealed for [OwnedFormatItem] {
+    fn parse_into<'a>(
+        &self,
+        input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        Ok(parsed.parse_items(input, self)?)
+    }
+}
+
+impl<T: Deref> sealed::Sealed for T
+where
+    T::Target: sealed::Sealed,
+{
+    fn parse_into<'a>(
+        &self,
+        input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        self.deref().parse_into(input, parsed)
+    }
+}
+// endregion custom formats
+
+// region: well-known formats
+impl sealed::Sealed for Rfc2822 {
+    fn parse_into<'a>(
+        &self,
+        input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        use crate::error::ParseFromDescription::{InvalidComponent, InvalidLiteral};
+        use crate::parsing::combinator::rfc::rfc2822::{cfws, fws};
+        use crate::parsing::combinator::{
+            ascii_char, exactly_n_digits, first_match, n_to_m_digits, opt, sign,
+        };
+
+        let colon = ascii_char::<b':'>;
+        let comma = ascii_char::<b','>;
+
+        let input = opt(cfws)(input).into_inner();
+        let weekday = first_match(
+            [
+                (b"Mon".as_slice(), Weekday::Monday),
+                (b"Tue".as_slice(), Weekday::Tuesday),
+                (b"Wed".as_slice(), Weekday::Wednesday),
+                (b"Thu".as_slice(), Weekday::Thursday),
+                (b"Fri".as_slice(), Weekday::Friday),
+                (b"Sat".as_slice(), Weekday::Saturday),
+                (b"Sun".as_slice(), Weekday::Sunday),
+            ],
+            false,
+        )(input);
+        let input = if let Some(item) = weekday {
+            let input = item
+                .consume_value(|value| parsed.set_weekday(value))
+                .ok_or(InvalidComponent("weekday"))?;
+            let input = comma(input).ok_or(InvalidLiteral)?.into_inner();
+            opt(cfws)(input).into_inner()
+        } else {
+            input
+        };
+        let input = n_to_m_digits::<1, 2, _>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_day(value)))
+            .ok_or(InvalidComponent("day"))?;
+        let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = first_match(
+            [
+                (b"Jan".as_slice(), Month::January),
+                (b"Feb".as_slice(), Month::February),
+                (b"Mar".as_slice(), Month::March),
+                (b"Apr".as_slice(), Month::April),
+                (b"May".as_slice(), Month::May),
+                (b"Jun".as_slice(), Month::June),
+                (b"Jul".as_slice(), Month::July),
+                (b"Aug".as_slice(), Month::August),
+                (b"Sep".as_slice(), Month::September),
+                (b"Oct".as_slice(), Month::October),
+                (b"Nov".as_slice(), Month::November),
+                (b"Dec".as_slice(), Month::December),
+            ],
+            false,
+        )(input)
+        .and_then(|item| item.consume_value(|value| parsed.set_month(value)))
+        .ok_or(InvalidComponent("month"))?;
+        let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = match exactly_n_digits::<4, u32>(input) {
+            Some(item) => {
+                let input = item
+                    .flat_map(|year| if year >= 1900 { Some(year) } else { None })
+                    .and_then(|item| {
+                        item.consume_value(|value| parsed.set_year(value.cast_signed()))
+                    })
+                    .ok_or(InvalidComponent("year"))?;
+                fws(input).ok_or(InvalidLiteral)?.into_inner()
+            }
+            None => {
+                let input = exactly_n_digits::<2, u32>(input)
+                    .and_then(|item| {
+                        item.map(|year| if year < 50 { year + 2000 } else { year + 1900 })
+                            .map(|year| year.cast_signed())
+                            .consume_value(|value| parsed.set_year(value))
+                    })
+                    .ok_or(InvalidComponent("year"))?;
+                cfws(input).ok_or(InvalidLiteral)?.into_inner()
+            }
+        };
+
+        let input = exactly_n_digits::<2, _>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_hour_24(value)))
+            .ok_or(InvalidComponent("hour"))?;
+        let input = opt(cfws)(input).into_inner();
+        let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = opt(cfws)(input).into_inner();
+        let input = exactly_n_digits::<2, _>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_minute(value)))
+            .ok_or(InvalidComponent("minute"))?;
+
+        let input = if let Some(input) = colon(opt(cfws)(input).into_inner()) {
+            let input = input.into_inner(); // discard the colon
+            let input = opt(cfws)(input).into_inner();
+            let input = exactly_n_digits::<2, _>(input)
+                .and_then(|item| item.consume_value(|value| parsed.set_second(value)))
+                .ok_or(InvalidComponent("second"))?;
+            cfws(input).ok_or(InvalidLiteral)?.into_inner()
+        } else {
+            cfws(input).ok_or(InvalidLiteral)?.into_inner()
+        };
+
+        // The RFC explicitly allows leap seconds.
+        parsed.leap_second_allowed = true;
+
+        #[allow(clippy::unnecessary_lazy_evaluations)] // rust-lang/rust-clippy#8522
+        let zone_literal = first_match(
+            [
+                (b"UT".as_slice(), 0),
+                (b"GMT".as_slice(), 0),
+                (b"EST".as_slice(), -5),
+                (b"EDT".as_slice(), -4),
+                (b"CST".as_slice(), -6),
+                (b"CDT".as_slice(), -5),
+                (b"MST".as_slice(), -7),
+                (b"MDT".as_slice(), -6),
+                (b"PST".as_slice(), -8),
+                (b"PDT".as_slice(), -7),
+            ],
+            false,
+        )(input)
+        .or_else(|| match input {
+            [
+                b'a'..=b'i' | b'k'..=b'z' | b'A'..=b'I' | b'K'..=b'Z',
+                rest @ ..,
+            ] => Some(ParsedItem(rest, 0)),
+            _ => None,
+        });
+        if let Some(zone_literal) = zone_literal {
+            let input = zone_literal
+                .consume_value(|value| parsed.set_offset_hour(value))
+                .ok_or(InvalidComponent("offset hour"))?;
+            parsed
+                .set_offset_minute_signed(0)
+                .ok_or(InvalidComponent("offset minute"))?;
+            parsed
+                .set_offset_second_signed(0)
+                .ok_or(InvalidComponent("offset second"))?;
+            return Ok(input);
+        }
+
+        let ParsedItem(input, offset_sign) = sign(input).ok_or(InvalidComponent("offset hour"))?;
+        let input = exactly_n_digits::<2, u8>(input)
+            .and_then(|item| {
+                item.map(|offset_hour| {
+                    if offset_sign == b'-' {
+                        -offset_hour.cast_signed()
+                    } else {
+                        offset_hour.cast_signed()
+                    }
+                })
+                .consume_value(|value| parsed.set_offset_hour(value))
+            })
+            .ok_or(InvalidComponent("offset hour"))?;
+        let input = exactly_n_digits::<2, u8>(input)
+            .and_then(|item| {
+                item.consume_value(|value| parsed.set_offset_minute_signed(value.cast_signed()))
+            })
+            .ok_or(InvalidComponent("offset minute"))?;
+
+        let input = opt(cfws)(input).into_inner();
+
+        Ok(input)
+    }
+
+    fn parse_offset_date_time(&self, input: &[u8]) -> Result<OffsetDateTime, error::Parse> {
+        use crate::error::ParseFromDescription::{InvalidComponent, InvalidLiteral};
+        use crate::parsing::combinator::rfc::rfc2822::{cfws, fws};
+        use crate::parsing::combinator::{
+            ascii_char, exactly_n_digits, first_match, n_to_m_digits, opt, sign,
+        };
+
+        let colon = ascii_char::<b':'>;
+        let comma = ascii_char::<b','>;
+
+        let input = opt(cfws)(input).into_inner();
+        // This parses the weekday, but we don't actually use the value anywhere. Because of this,
+        // just return `()` to avoid unnecessary generated code.
+        let weekday = first_match(
+            [
+                (b"Mon".as_slice(), ()),
+                (b"Tue".as_slice(), ()),
+                (b"Wed".as_slice(), ()),
+                (b"Thu".as_slice(), ()),
+                (b"Fri".as_slice(), ()),
+                (b"Sat".as_slice(), ()),
+                (b"Sun".as_slice(), ()),
+            ],
+            false,
+        )(input);
+        let input = if let Some(item) = weekday {
+            let input = item.into_inner();
+            let input = comma(input).ok_or(InvalidLiteral)?.into_inner();
+            opt(cfws)(input).into_inner()
+        } else {
+            input
+        };
+        let ParsedItem(input, day) =
+            n_to_m_digits::<1, 2, _>(input).ok_or(InvalidComponent("day"))?;
+        let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
+        let ParsedItem(input, month) = first_match(
+            [
+                (b"Jan".as_slice(), Month::January),
+                (b"Feb".as_slice(), Month::February),
+                (b"Mar".as_slice(), Month::March),
+                (b"Apr".as_slice(), Month::April),
+                (b"May".as_slice(), Month::May),
+                (b"Jun".as_slice(), Month::June),
+                (b"Jul".as_slice(), Month::July),
+                (b"Aug".as_slice(), Month::August),
+                (b"Sep".as_slice(), Month::September),
+                (b"Oct".as_slice(), Month::October),
+                (b"Nov".as_slice(), Month::November),
+                (b"Dec".as_slice(), Month::December),
+            ],
+            false,
+        )(input)
+        .ok_or(InvalidComponent("month"))?;
+        let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
+        let (input, year) = match exactly_n_digits::<4, u32>(input) {
+            Some(item) => {
+                let ParsedItem(input, year) = item
+                    .flat_map(|year| if year >= 1900 { Some(year) } else { None })
+                    .ok_or(InvalidComponent("year"))?;
+                let input = fws(input).ok_or(InvalidLiteral)?.into_inner();
+                (input, year)
+            }
+            None => {
+                let ParsedItem(input, year) = exactly_n_digits::<2, u32>(input)
+                    .map(|item| item.map(|year| if year < 50 { year + 2000 } else { year + 1900 }))
+                    .ok_or(InvalidComponent("year"))?;
+                let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
+                (input, year)
+            }
+        };
+
+        let ParsedItem(input, hour) =
+            exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("hour"))?;
+        let input = opt(cfws)(input).into_inner();
+        let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = opt(cfws)(input).into_inner();
+        let ParsedItem(input, minute) =
+            exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("minute"))?;
+
+        let (input, mut second) = if let Some(input) = colon(opt(cfws)(input).into_inner()) {
+            let input = input.into_inner(); // discard the colon
+            let input = opt(cfws)(input).into_inner();
+            let ParsedItem(input, second) =
+                exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("second"))?;
+            let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
+            (input, second)
+        } else {
+            (cfws(input).ok_or(InvalidLiteral)?.into_inner(), 0)
+        };
+
+        #[allow(clippy::unnecessary_lazy_evaluations)] // rust-lang/rust-clippy#8522
+        let zone_literal = first_match(
+            [
+                (b"UT".as_slice(), 0),
+                (b"GMT".as_slice(), 0),
+                (b"EST".as_slice(), -5),
+                (b"EDT".as_slice(), -4),
+                (b"CST".as_slice(), -6),
+                (b"CDT".as_slice(), -5),
+                (b"MST".as_slice(), -7),
+                (b"MDT".as_slice(), -6),
+                (b"PST".as_slice(), -8),
+                (b"PDT".as_slice(), -7),
+            ],
+            false,
+        )(input)
+        .or_else(|| match input {
+            [
+                b'a'..=b'i' | b'k'..=b'z' | b'A'..=b'I' | b'K'..=b'Z',
+                rest @ ..,
+            ] => Some(ParsedItem(rest, 0)),
+            _ => None,
+        });
+
+        let (input, offset_hour, offset_minute) = if let Some(zone_literal) = zone_literal {
+            let ParsedItem(input, offset_hour) = zone_literal;
+            (input, offset_hour, 0)
+        } else {
+            let ParsedItem(input, offset_sign) =
+                sign(input).ok_or(InvalidComponent("offset hour"))?;
+            let ParsedItem(input, offset_hour) = exactly_n_digits::<2, u8>(input)
+                .map(|item| {
+                    item.map(|offset_hour| {
+                        if offset_sign == b'-' {
+                            -offset_hour.cast_signed()
+                        } else {
+                            offset_hour.cast_signed()
+                        }
+                    })
+                })
+                .ok_or(InvalidComponent("offset hour"))?;
+            let ParsedItem(input, offset_minute) =
+                exactly_n_digits::<2, u8>(input).ok_or(InvalidComponent("offset minute"))?;
+            (input, offset_hour, offset_minute.cast_signed())
+        };
+
+        let input = opt(cfws)(input).into_inner();
+
+        if !input.is_empty() {
+            return Err(error::Parse::ParseFromDescription(
+                error::ParseFromDescription::UnexpectedTrailingCharacters,
+            ));
+        }
+
+        let mut nanosecond = 0;
+        let leap_second_input = if second == 60 {
+            second = 59;
+            nanosecond = 999_999_999;
+            true
+        } else {
+            false
+        };
+
+        let dt = (|| {
+            let date = Date::from_calendar_date(year.cast_signed(), month, day)?;
+            let time = Time::from_hms_nano(hour, minute, second, nanosecond)?;
+            let offset = UtcOffset::from_hms(offset_hour, offset_minute, 0)?;
+            Ok(OffsetDateTime::new_in_offset(date, time, offset))
+        })()
+        .map_err(TryFromParsed::ComponentRange)?;
+
+        if leap_second_input && !dt.is_valid_leap_second_stand_in() {
+            return Err(error::Parse::TryFromParsed(TryFromParsed::ComponentRange(
+                error::ComponentRange {
+                    name: "second",
+                    minimum: 0,
+                    maximum: 59,
+                    value: 60,
+                    conditional_range: true,
+                },
+            )));
+        }
+
+        Ok(dt)
+    }
+}
+
+impl sealed::Sealed for Rfc3339 {
+    fn parse_into<'a>(
+        &self,
+        input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        use crate::error::ParseFromDescription::{InvalidComponent, InvalidLiteral};
+        use crate::parsing::combinator::{
+            any_digit, ascii_char, ascii_char_ignore_case, exactly_n_digits, sign,
+        };
+
+        let dash = ascii_char::<b'-'>;
+        let colon = ascii_char::<b':'>;
+
+        let input = exactly_n_digits::<4, u32>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_year(value.cast_signed())))
+            .ok_or(InvalidComponent("year"))?;
+        let input = dash(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = exactly_n_digits::<2, _>(input)
+            .and_then(|item| item.flat_map(|value| Month::from_number(value).ok()))
+            .and_then(|item| item.consume_value(|value| parsed.set_month(value)))
+            .ok_or(InvalidComponent("month"))?;
+        let input = dash(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = exactly_n_digits::<2, _>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_day(value)))
+            .ok_or(InvalidComponent("day"))?;
+
+        // RFC3339 allows any separator, not just `T`, not just `space`.
+        // cf. Section 5.6: Internet Date/Time Format:
+        //   NOTE: ISO 8601 defines date and time separated by "T".
+        //   Applications using this syntax may choose, for the sake of
+        //   readability, to specify a full-date and full-time separated by
+        //   (say) a space character.
+        // Specifically, rusqlite uses space separators.
+        let input = input
+            .get(1..)
+            .ok_or_else(|| InvalidComponent("separator"))?;
+
+        let input = exactly_n_digits::<2, _>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_hour_24(value)))
+            .ok_or(InvalidComponent("hour"))?;
+        let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = exactly_n_digits::<2, _>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_minute(value)))
+            .ok_or(InvalidComponent("minute"))?;
+        let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = exactly_n_digits::<2, _>(input)
+            .and_then(|item| item.consume_value(|value| parsed.set_second(value)))
+            .ok_or(InvalidComponent("second"))?;
+        let input = if let Some(ParsedItem(input, ())) = ascii_char::<b'.'>(input) {
+            let ParsedItem(mut input, mut value) = any_digit(input)
+                .ok_or(InvalidComponent("subsecond"))?
+                .map(|v| (v - b'0').extend::<u32>() * 100_000_000);
+
+            let mut multiplier = 10_000_000;
+            while let Some(ParsedItem(new_input, digit)) = any_digit(input) {
+                value += (digit - b'0').extend::<u32>() * multiplier;
+                input = new_input;
+                multiplier /= 10;
+            }
+
+            parsed
+                .set_subsecond(value)
+                .ok_or(InvalidComponent("subsecond"))?;
+            input
+        } else {
+            input
+        };
+
+        // The RFC explicitly allows leap seconds.
+        parsed.leap_second_allowed = true;
+
+        if let Some(ParsedItem(input, ())) = ascii_char_ignore_case::<b'Z'>(input) {
+            parsed
+                .set_offset_hour(0)
+                .ok_or(InvalidComponent("offset hour"))?;
+            parsed
+                .set_offset_minute_signed(0)
+                .ok_or(InvalidComponent("offset minute"))?;
+            parsed
+                .set_offset_second_signed(0)
+                .ok_or(InvalidComponent("offset second"))?;
+            return Ok(input);
+        }
+
+        let ParsedItem(input, offset_sign) = sign(input).ok_or(InvalidComponent("offset hour"))?;
+        let input = exactly_n_digits::<2, u8>(input)
+            .and_then(|item| {
+                item.filter(|&offset_hour| offset_hour <= 23)?
+                    .map(|offset_hour| {
+                        if offset_sign == b'-' {
+                            -offset_hour.cast_signed()
+                        } else {
+                            offset_hour.cast_signed()
+                        }
+                    })
+                    .consume_value(|value| parsed.set_offset_hour(value))
+            })
+            .ok_or(InvalidComponent("offset hour"))?;
+        let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+        let input = exactly_n_digits::<2, u8>(input)
+            .and_then(|item| {
+                item.map(|offset_minute| {
+                    if offset_sign == b'-' {
+                        -offset_minute.cast_signed()
+                    } else {
+                        offset_minute.cast_signed()
+                    }
+                })
+                .consume_value(|value| parsed.set_offset_minute_signed(value))
+            })
+            .ok_or(InvalidComponent("offset minute"))?;
+
+        Ok(input)
+    }
+
+    fn parse_offset_date_time(&self, input: &[u8]) -> Result<OffsetDateTime, error::Parse> {
+        use crate::error::ParseFromDescription::{InvalidComponent, InvalidLiteral};
+        use crate::parsing::combinator::{
+            any_digit, ascii_char, ascii_char_ignore_case, exactly_n_digits, sign,
+        };
+
+        let dash = ascii_char::<b'-'>;
+        let colon = ascii_char::<b':'>;
+
+        let ParsedItem(input, year) =
+            exactly_n_digits::<4, u32>(input).ok_or(InvalidComponent("year"))?;
+        let input = dash(input).ok_or(InvalidLiteral)?.into_inner();
+        let ParsedItem(input, month) =
+            exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("month"))?;
+        let input = dash(input).ok_or(InvalidLiteral)?.into_inner();
+        let ParsedItem(input, day) =
+            exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("day"))?;
+
+        // RFC3339 allows any separator, not just `T`, not just `space`.
+        // cf. Section 5.6: Internet Date/Time Format:
+        //   NOTE: ISO 8601 defines date and time separated by "T".
+        //   Applications using this syntax may choose, for the sake of
+        //   readability, to specify a full-date and full-time separated by
+        //   (say) a space character.
+        // Specifically, rusqlite uses space separators.
+        let input = input
+            .get(1..)
+            .ok_or_else(|| InvalidComponent("separator"))?;
+
+        let ParsedItem(input, hour) =
+            exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("hour"))?;
+        let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+        let ParsedItem(input, minute) =
+            exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("minute"))?;
+        let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+        let ParsedItem(input, mut second) =
+            exactly_n_digits::<2, _>(input).ok_or(InvalidComponent("second"))?;
+        let ParsedItem(input, mut nanosecond) =
+            if let Some(ParsedItem(input, ())) = ascii_char::<b'.'>(input) {
+                let ParsedItem(mut input, mut value) = any_digit(input)
+                    .ok_or(InvalidComponent("subsecond"))?
+                    .map(|v| (v - b'0').extend::<u32>() * 100_000_000);
+
+                let mut multiplier = 10_000_000;
+                while let Some(ParsedItem(new_input, digit)) = any_digit(input) {
+                    value += (digit - b'0').extend::<u32>() * multiplier;
+                    input = new_input;
+                    multiplier /= 10;
+                }
+
+                ParsedItem(input, value)
+            } else {
+                ParsedItem(input, 0)
+            };
+        let ParsedItem(input, offset) = {
+            if let Some(ParsedItem(input, ())) = ascii_char_ignore_case::<b'Z'>(input) {
+                ParsedItem(input, UtcOffset::UTC)
+            } else {
+                let ParsedItem(input, offset_sign) =
+                    sign(input).ok_or(InvalidComponent("offset hour"))?;
+                let ParsedItem(input, offset_hour) = exactly_n_digits::<2, u8>(input)
+                    .and_then(|parsed| parsed.filter(|&offset_hour| offset_hour <= 23))
+                    .ok_or(InvalidComponent("offset hour"))?;
+                let input = colon(input).ok_or(InvalidLiteral)?.into_inner();
+                let ParsedItem(input, offset_minute) =
+                    exactly_n_digits::<2, u8>(input).ok_or(InvalidComponent("offset minute"))?;
+                UtcOffset::from_hms(
+                    if offset_sign == b'-' {
+                        -offset_hour.cast_signed()
+                    } else {
+                        offset_hour.cast_signed()
+                    },
+                    if offset_sign == b'-' {
+                        -offset_minute.cast_signed()
+                    } else {
+                        offset_minute.cast_signed()
+                    },
+                    0,
+                )
+                .map(|offset| ParsedItem(input, offset))
+                .map_err(|mut err| {
+                    // Provide the user a more accurate error.
+                    if err.name == "hours" {
+                        err.name = "offset hour";
+                    } else if err.name == "minutes" {
+                        err.name = "offset minute";
+                    }
+                    err
+                })
+                .map_err(TryFromParsed::ComponentRange)?
+            }
+        };
+
+        if !input.is_empty() {
+            return Err(error::Parse::ParseFromDescription(
+                error::ParseFromDescription::UnexpectedTrailingCharacters,
+            ));
+        }
+
+        // The RFC explicitly permits leap seconds. We don't currently support them, so treat it as
+        // the preceding nanosecond. However, leap seconds can only occur as the last second of the
+        // month UTC.
+        let leap_second_input = if second == 60 {
+            second = 59;
+            nanosecond = 999_999_999;
+            true
+        } else {
+            false
+        };
+
+        let date = Month::from_number(month)
+            .and_then(|month| Date::from_calendar_date(year.cast_signed(), month, day))
+            .map_err(TryFromParsed::ComponentRange)?;
+        let time = Time::from_hms_nano(hour, minute, second, nanosecond)
+            .map_err(TryFromParsed::ComponentRange)?;
+        let dt = OffsetDateTime::new_in_offset(date, time, offset);
+
+        if leap_second_input && !dt.is_valid_leap_second_stand_in() {
+            return Err(error::Parse::TryFromParsed(TryFromParsed::ComponentRange(
+                error::ComponentRange {
+                    name: "second",
+                    minimum: 0,
+                    maximum: 59,
+                    value: 60,
+                    conditional_range: true,
+                },
+            )));
+        }
+
+        Ok(dt)
+    }
+}
+
+impl<const CONFIG: EncodedConfig> sealed::Sealed for Iso8601<CONFIG> {
+    fn parse_into<'a>(
+        &self,
+        mut input: &'a [u8],
+        parsed: &mut Parsed,
+    ) -> Result<&'a [u8], error::Parse> {
+        use crate::parsing::combinator::rfc::iso8601::ExtendedKind;
+
+        let mut extended_kind = ExtendedKind::Unknown;
+        let mut date_is_present = false;
+        let mut time_is_present = false;
+        let mut offset_is_present = false;
+        let mut first_error = None;
+
+        parsed.leap_second_allowed = true;
+
+        match Self::parse_date(parsed, &mut extended_kind)(input) {
+            Ok(new_input) => {
+                input = new_input;
+                date_is_present = true;
+            }
+            Err(err) => {
+                first_error.get_or_insert(err);
+            }
+        }
+
+        match Self::parse_time(parsed, &mut extended_kind, date_is_present)(input) {
+            Ok(new_input) => {
+                input = new_input;
+                time_is_present = true;
+            }
+            Err(err) => {
+                first_error.get_or_insert(err);
+            }
+        }
+
+        // If a date and offset are present, a time must be as well.
+        if !date_is_present || time_is_present {
+            match Self::parse_offset(parsed, &mut extended_kind)(input) {
+                Ok(new_input) => {
+                    input = new_input;
+                    offset_is_present = true;
+                }
+                Err(err) => {
+                    first_error.get_or_insert(err);
+                }
+            }
+        }
+
+        if !date_is_present && !time_is_present && !offset_is_present {
+            match first_error {
+                Some(err) => return Err(err),
+                None => bug!("an error should be present if no components were parsed"),
+            }
+        }
+
+        Ok(input)
+    }
+}
+// endregion well-known formats
diff --git a/time/src/parsing/parsed.rs b/time/src/parsing/parsed.rs
new file mode 100644
index 000000000..3c6c4f511
--- /dev/null
+++ b/time/src/parsing/parsed.rs
@@ -0,0 +1,903 @@
+//! Information parsed from an input and format description.
+
+use core::num::{NonZeroU16, NonZeroU8};
+
+use deranged::{
+    OptionRangedI128, OptionRangedI32, OptionRangedI8, OptionRangedU16, OptionRangedU32,
+    OptionRangedU8, RangedI128, RangedI32, RangedI8, RangedU16, RangedU32, RangedU8,
+};
+use num_conv::prelude::*;
+
+use crate::convert::{Day, Hour, Minute, Nanosecond, Second};
+use crate::date::{MAX_YEAR, MIN_YEAR};
+use crate::error::TryFromParsed::InsufficientInformation;
+#[cfg(feature = "alloc")]
+use crate::format_description::OwnedFormatItem;
+use crate::format_description::{modifier, BorrowedFormatItem, Component};
+use crate::internal_macros::{bug, const_try_opt};
+use crate::parsing::component::{
+    parse_day, parse_end, parse_hour, parse_ignore, parse_minute, parse_month, parse_offset_hour,
+    parse_offset_minute, parse_offset_second, parse_ordinal, parse_period, parse_second,
+    parse_subsecond, parse_unix_timestamp, parse_week_number, parse_weekday, parse_year, Period,
+};
+use crate::parsing::ParsedItem;
+use crate::{error, Date, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+/// Sealed to prevent downstream implementations.
+mod sealed {
+    use super::*;
+
+    /// A trait to allow `parse_item` to be generic.
+    pub trait AnyFormatItem {
+        /// Parse a single item, returning the remaining input on success.
+        fn parse_item<'a>(
+            &self,
+            parsed: &mut Parsed,
+            input: &'a [u8],
+        ) -> Result<&'a [u8], error::ParseFromDescription>;
+    }
+}
+
+impl sealed::AnyFormatItem for BorrowedFormatItem<'_> {
+    fn parse_item<'a>(
+        &self,
+        parsed: &mut Parsed,
+        input: &'a [u8],
+    ) -> Result<&'a [u8], error::ParseFromDescription> {
+        match self {
+            Self::Literal(literal) => Parsed::parse_literal(input, literal),
+            Self::Component(component) => parsed.parse_component(input, *component),
+            Self::Compound(compound) => parsed.parse_items(input, compound),
+            Self::Optional(item) => parsed.parse_item(input, *item).or(Ok(input)),
+            Self::First(items) => {
+                let mut first_err = None;
+
+                for item in items.iter() {
+                    match parsed.parse_item(input, item) {
+                        Ok(remaining_input) => return Ok(remaining_input),
+                        Err(err) if first_err.is_none() => first_err = Some(err),
+                        Err(_) => {}
+                    }
+                }
+
+                match first_err {
+                    Some(err) => Err(err),
+                    // This location will be reached if the slice is empty, skipping the `for` loop.
+                    // As this case is expected to be uncommon, there's no need to check up front.
+                    None => Ok(input),
+                }
+            }
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl sealed::AnyFormatItem for OwnedFormatItem {
+    fn parse_item<'a>(
+        &self,
+        parsed: &mut Parsed,
+        input: &'a [u8],
+    ) -> Result<&'a [u8], error::ParseFromDescription> {
+        match self {
+            Self::Literal(literal) => Parsed::parse_literal(input, literal),
+            Self::Component(component) => parsed.parse_component(input, *component),
+            Self::Compound(compound) => parsed.parse_items(input, compound),
+            Self::Optional(item) => parsed.parse_item(input, item.as_ref()).or(Ok(input)),
+            Self::First(items) => {
+                let mut first_err = None;
+
+                for item in items.iter() {
+                    match parsed.parse_item(input, item) {
+                        Ok(remaining_input) => return Ok(remaining_input),
+                        Err(err) if first_err.is_none() => first_err = Some(err),
+                        Err(_) => {}
+                    }
+                }
+
+                match first_err {
+                    Some(err) => Err(err),
+                    // This location will be reached if the slice is empty, skipping the `for` loop.
+                    // As this case is expected to be uncommon, there's no need to check up front.
+                    None => Ok(input),
+                }
+            }
+        }
+    }
+}
+
+/// All information parsed.
+///
+/// This information is directly used to construct the final values.
+///
+/// Most users will not need think about this struct in any way. It is public to allow for manual
+/// control over values, in the instance that the default parser is insufficient.
+#[derive(Debug, Clone, Copy)]
+pub struct Parsed {
+    /// Calendar year.
+    year: OptionRangedI32<{ MIN_YEAR }, { MAX_YEAR }>,
+    /// The last two digits of the calendar year.
+    year_last_two: OptionRangedU8<0, 99>,
+    /// Year of the [ISO week date](https://en.wikipedia.org/wiki/ISO_week_date).
+    iso_year: OptionRangedI32<{ MIN_YEAR }, { MAX_YEAR }>,
+    /// The last two digits of the ISO week year.
+    iso_year_last_two: OptionRangedU8<0, 99>,
+    /// Month of the year.
+    month: Option<Month>,
+    /// Week of the year, where week one begins on the first Sunday of the calendar year.
+    sunday_week_number: OptionRangedU8<0, 53>,
+    /// Week of the year, where week one begins on the first Monday of the calendar year.
+    monday_week_number: OptionRangedU8<0, 53>,
+    /// Week of the year, where week one is the Monday-to-Sunday period containing January 4.
+    iso_week_number: OptionRangedU8<1, 53>,
+    /// Day of the week.
+    weekday: Option<Weekday>,
+    /// Day of the year.
+    ordinal: OptionRangedU16<1, 366>,
+    /// Day of the month.
+    day: OptionRangedU8<1, 31>,
+    /// Hour within the day.
+    hour_24: OptionRangedU8<0, { Hour::per(Day) - 1 }>,
+    /// Hour within the 12-hour period (midnight to noon or vice versa). This is typically used in
+    /// conjunction with AM/PM, which is indicated by the `hour_12_is_pm` field.
+    hour_12: OptionRangedU8<1, 12>,
+    /// Whether the `hour_12` field indicates a time that "PM".
+    hour_12_is_pm: Option<bool>,
+    /// Minute within the hour.
+    // minute: MaybeUninit<u8>,
+    minute: OptionRangedU8<0, { Minute::per(Hour) - 1 }>,
+    /// Second within the minute.
+    // do not subtract one, as leap seconds may be allowed
+    second: OptionRangedU8<0, { Second::per(Minute) }>,
+    /// Nanosecond within the second.
+    subsecond: OptionRangedU32<0, { Nanosecond::per(Second) - 1 }>,
+    /// Whole hours of the UTC offset.
+    offset_hour: OptionRangedI8<-23, 23>,
+    /// Minutes within the hour of the UTC offset.
+    offset_minute:
+        OptionRangedI8<{ -((Minute::per(Hour) - 1) as i8) }, { (Minute::per(Hour) - 1) as _ }>,
+    /// Seconds within the minute of the UTC offset.
+    offset_second:
+        OptionRangedI8<{ -((Second::per(Minute) - 1) as i8) }, { (Second::per(Minute) - 1) as _ }>,
+    /// The Unix timestamp in nanoseconds.
+    unix_timestamp_nanos: OptionRangedI128<
+        {
+            OffsetDateTime::new_in_offset(Date::MIN, Time::MIDNIGHT, UtcOffset::UTC)
+                .unix_timestamp_nanos()
+        },
+        {
+            OffsetDateTime::new_in_offset(Date::MAX, Time::MAX, UtcOffset::UTC)
+                .unix_timestamp_nanos()
+        },
+    >,
+    /// Indicates whether the [`UtcOffset`] is negative. This information is obtained when parsing
+    /// the offset hour, but may not otherwise be stored due to "-0" being equivalent to "0".
+    offset_is_negative: Option<bool>,
+    /// Indicates whether a leap second is permitted to be parsed. This is required by some
+    /// well-known formats.
+    pub(super) leap_second_allowed: bool,
+}
+
+impl Default for Parsed {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Parsed {
+    /// Create a new instance of `Parsed` with no information known.
+    pub const fn new() -> Self {
+        Self {
+            year: OptionRangedI32::None,
+            year_last_two: OptionRangedU8::None,
+            iso_year: OptionRangedI32::None,
+            iso_year_last_two: OptionRangedU8::None,
+            month: None,
+            sunday_week_number: OptionRangedU8::None,
+            monday_week_number: OptionRangedU8::None,
+            iso_week_number: OptionRangedU8::None,
+            weekday: None,
+            ordinal: OptionRangedU16::None,
+            day: OptionRangedU8::None,
+            hour_24: OptionRangedU8::None,
+            hour_12: OptionRangedU8::None,
+            hour_12_is_pm: None,
+            minute: OptionRangedU8::None,
+            second: OptionRangedU8::None,
+            subsecond: OptionRangedU32::None,
+            offset_hour: OptionRangedI8::None,
+            offset_minute: OptionRangedI8::None,
+            offset_second: OptionRangedI8::None,
+            unix_timestamp_nanos: OptionRangedI128::None,
+            offset_is_negative: None,
+            leap_second_allowed: false,
+        }
+    }
+
+    /// Parse a single [`BorrowedFormatItem`] or [`OwnedFormatItem`], mutating the struct. The
+    /// remaining input is returned as the `Ok` value.
+    ///
+    /// If a [`BorrowedFormatItem::Optional`] or [`OwnedFormatItem::Optional`] is passed, parsing
+    /// will not fail; the input will be returned as-is if the expected format is not present.
+    pub fn parse_item<'a>(
+        &mut self,
+        input: &'a [u8],
+        item: &impl sealed::AnyFormatItem,
+    ) -> Result<&'a [u8], error::ParseFromDescription> {
+        item.parse_item(self, input)
+    }
+
+    /// Parse a sequence of [`BorrowedFormatItem`]s or [`OwnedFormatItem`]s, mutating the struct.
+    /// The remaining input is returned as the `Ok` value.
+    ///
+    /// This method will fail if any of the contained [`BorrowedFormatItem`]s or
+    /// [`OwnedFormatItem`]s fail to parse. `self` will not be mutated in this instance.
+    pub fn parse_items<'a>(
+        &mut self,
+        mut input: &'a [u8],
+        items: &[impl sealed::AnyFormatItem],
+    ) -> Result<&'a [u8], error::ParseFromDescription> {
+        // Make a copy that we can mutate. It will only be set to the user's copy if everything
+        // succeeds.
+        let mut this = *self;
+        for item in items {
+            input = this.parse_item(input, item)?;
+        }
+        *self = this;
+        Ok(input)
+    }
+
+    /// Parse a literal byte sequence. The remaining input is returned as the `Ok` value.
+    pub fn parse_literal<'a>(
+        input: &'a [u8],
+        literal: &[u8],
+    ) -> Result<&'a [u8], error::ParseFromDescription> {
+        input
+            .strip_prefix(literal)
+            .ok_or(error::ParseFromDescription::InvalidLiteral)
+    }
+
+    /// Parse a single component, mutating the struct. The remaining input is returned as the `Ok`
+    /// value.
+    pub fn parse_component<'a>(
+        &mut self,
+        input: &'a [u8],
+        component: Component,
+    ) -> Result<&'a [u8], error::ParseFromDescription> {
+        use error::ParseFromDescription::InvalidComponent;
+
+        match component {
+            Component::Day(modifiers) => parse_day(input, modifiers)
+                .and_then(|parsed| parsed.consume_value(|value| self.set_day(value)))
+                .ok_or(InvalidComponent("day")),
+            Component::Month(modifiers) => parse_month(input, modifiers)
+                .and_then(|parsed| parsed.consume_value(|value| self.set_month(value)))
+                .ok_or(InvalidComponent("month")),
+            Component::Ordinal(modifiers) => parse_ordinal(input, modifiers)
+                .and_then(|parsed| parsed.consume_value(|value| self.set_ordinal(value)))
+                .ok_or(InvalidComponent("ordinal")),
+            Component::Weekday(modifiers) => parse_weekday(input, modifiers)
+                .and_then(|parsed| parsed.consume_value(|value| self.set_weekday(value)))
+                .ok_or(InvalidComponent("weekday")),
+            Component::WeekNumber(modifiers) => {
+                let ParsedItem(remaining, value) =
+                    parse_week_number(input, modifiers).ok_or(InvalidComponent("week number"))?;
+                match modifiers.repr {
+                    modifier::WeekNumberRepr::Iso => {
+                        NonZeroU8::new(value).and_then(|value| self.set_iso_week_number(value))
+                    }
+                    modifier::WeekNumberRepr::Sunday => self.set_sunday_week_number(value),
+                    modifier::WeekNumberRepr::Monday => self.set_monday_week_number(value),
+                }
+                .ok_or(InvalidComponent("week number"))?;
+                Ok(remaining)
+            }
+            Component::Year(modifiers) => {
+                let ParsedItem(remaining, value) =
+                    parse_year(input, modifiers).ok_or(InvalidComponent("year"))?;
+                match (modifiers.iso_week_based, modifiers.repr) {
+                    (false, modifier::YearRepr::Full) => self.set_year(value),
+                    (false, modifier::YearRepr::LastTwo) => {
+                        self.set_year_last_two(value.cast_unsigned().truncate())
+                    }
+                    (true, modifier::YearRepr::Full) => self.set_iso_year(value),
+                    (true, modifier::YearRepr::LastTwo) => {
+                        self.set_iso_year_last_two(value.cast_unsigned().truncate())
+                    }
+                }
+                .ok_or(InvalidComponent("year"))?;
+                Ok(remaining)
+            }
+            Component::Hour(modifiers) => {
+                let ParsedItem(remaining, value) =
+                    parse_hour(input, modifiers).ok_or(InvalidComponent("hour"))?;
+                if modifiers.is_12_hour_clock {
+                    NonZeroU8::new(value).and_then(|value| self.set_hour_12(value))
+                } else {
+                    self.set_hour_24(value)
+                }
+                .ok_or(InvalidComponent("hour"))?;
+                Ok(remaining)
+            }
+            Component::Minute(modifiers) => parse_minute(input, modifiers)
+                .and_then(|parsed| parsed.consume_value(|value| self.set_minute(value)))
+                .ok_or(InvalidComponent("minute")),
+            Component::Period(modifiers) => parse_period(input, modifiers)
+                .and_then(|parsed| {
+                    parsed.consume_value(|value| self.set_hour_12_is_pm(value == Period::Pm))
+                })
+                .ok_or(InvalidComponent("period")),
+            Component::Second(modifiers) => parse_second(input, modifiers)
+                .and_then(|parsed| parsed.consume_value(|value| self.set_second(value)))
+                .ok_or(InvalidComponent("second")),
+            Component::Subsecond(modifiers) => parse_subsecond(input, modifiers)
+                .and_then(|parsed| parsed.consume_value(|value| self.set_subsecond(value)))
+                .ok_or(InvalidComponent("subsecond")),
+            Component::OffsetHour(modifiers) => parse_offset_hour(input, modifiers)
+                .and_then(|parsed| {
+                    parsed.consume_value(|(value, is_negative)| {
+                        self.set_offset_hour(value)?;
+                        self.offset_is_negative = Some(is_negative);
+                        Some(())
+                    })
+                })
+                .ok_or(InvalidComponent("offset hour")),
+            Component::OffsetMinute(modifiers) => parse_offset_minute(input, modifiers)
+                .and_then(|parsed| {
+                    parsed.consume_value(|value| self.set_offset_minute_signed(value))
+                })
+                .ok_or(InvalidComponent("offset minute")),
+            Component::OffsetSecond(modifiers) => parse_offset_second(input, modifiers)
+                .and_then(|parsed| {
+                    parsed.consume_value(|value| self.set_offset_second_signed(value))
+                })
+                .ok_or(InvalidComponent("offset second")),
+            Component::Ignore(modifiers) => parse_ignore(input, modifiers)
+                .map(ParsedItem::<()>::into_inner)
+                .ok_or(InvalidComponent("ignore")),
+            Component::UnixTimestamp(modifiers) => parse_unix_timestamp(input, modifiers)
+                .and_then(|parsed| {
+                    parsed.consume_value(|value| self.set_unix_timestamp_nanos(value))
+                })
+                .ok_or(InvalidComponent("unix_timestamp")),
+            Component::End(modifiers) => parse_end(input, modifiers)
+                .map(ParsedItem::<()>::into_inner)
+                .ok_or(error::ParseFromDescription::UnexpectedTrailingCharacters),
+        }
+    }
+}
+
+/// Getter methods
+impl Parsed {
+    /// Obtain the `year` component.
+    pub const fn year(&self) -> Option<i32> {
+        self.year.get_primitive()
+    }
+
+    /// Obtain the `year_last_two` component.
+    pub const fn year_last_two(&self) -> Option<u8> {
+        self.year_last_two.get_primitive()
+    }
+
+    /// Obtain the `iso_year` component.
+    pub const fn iso_year(&self) -> Option<i32> {
+        self.iso_year.get_primitive()
+    }
+
+    /// Obtain the `iso_year_last_two` component.
+    pub const fn iso_year_last_two(&self) -> Option<u8> {
+        self.iso_year_last_two.get_primitive()
+    }
+
+    /// Obtain the `month` component.
+    pub const fn month(&self) -> Option<Month> {
+        self.month
+    }
+
+    /// Obtain the `sunday_week_number` component.
+    pub const fn sunday_week_number(&self) -> Option<u8> {
+        self.sunday_week_number.get_primitive()
+    }
+
+    /// Obtain the `monday_week_number` component.
+    pub const fn monday_week_number(&self) -> Option<u8> {
+        self.monday_week_number.get_primitive()
+    }
+
+    /// Obtain the `iso_week_number` component.
+    pub const fn iso_week_number(&self) -> Option<NonZeroU8> {
+        NonZeroU8::new(const_try_opt!(self.iso_week_number.get_primitive()))
+    }
+
+    /// Obtain the `weekday` component.
+    pub const fn weekday(&self) -> Option<Weekday> {
+        self.weekday
+    }
+
+    /// Obtain the `ordinal` component.
+    pub const fn ordinal(&self) -> Option<NonZeroU16> {
+        NonZeroU16::new(const_try_opt!(self.ordinal.get_primitive()))
+    }
+
+    /// Obtain the `day` component.
+    pub const fn day(&self) -> Option<NonZeroU8> {
+        NonZeroU8::new(const_try_opt!(self.day.get_primitive()))
+    }
+
+    /// Obtain the `hour_24` component.
+    pub const fn hour_24(&self) -> Option<u8> {
+        self.hour_24.get_primitive()
+    }
+
+    /// Obtain the `hour_12` component.
+    pub const fn hour_12(&self) -> Option<NonZeroU8> {
+        NonZeroU8::new(const_try_opt!(self.hour_12.get_primitive()))
+    }
+
+    /// Obtain the `hour_12_is_pm` component.
+    pub const fn hour_12_is_pm(&self) -> Option<bool> {
+        self.hour_12_is_pm
+    }
+
+    /// Obtain the `minute` component.
+    pub const fn minute(&self) -> Option<u8> {
+        self.minute.get_primitive()
+    }
+
+    /// Obtain the `second` component.
+    pub const fn second(&self) -> Option<u8> {
+        self.second.get_primitive()
+    }
+
+    /// Obtain the `subsecond` component.
+    pub const fn subsecond(&self) -> Option<u32> {
+        self.subsecond.get_primitive()
+    }
+
+    /// Obtain the `offset_hour` component.
+    pub const fn offset_hour(&self) -> Option<i8> {
+        self.offset_hour.get_primitive()
+    }
+
+    /// Obtain the absolute value of the `offset_minute` component.
+    #[doc(hidden)]
+    #[deprecated(since = "0.3.8", note = "use `parsed.offset_minute_signed()` instead")]
+    pub const fn offset_minute(&self) -> Option<u8> {
+        Some(const_try_opt!(self.offset_minute_signed()).unsigned_abs())
+    }
+
+    /// Obtain the `offset_minute` component.
+    pub const fn offset_minute_signed(&self) -> Option<i8> {
+        match (self.offset_minute.get_primitive(), self.offset_is_negative) {
+            (Some(offset_minute), Some(true)) => Some(-offset_minute),
+            (Some(offset_minute), _) => Some(offset_minute),
+            (None, _) => None,
+        }
+    }
+
+    /// Obtain the absolute value of the `offset_second` component.
+    #[doc(hidden)]
+    #[deprecated(since = "0.3.8", note = "use `parsed.offset_second_signed()` instead")]
+    pub const fn offset_second(&self) -> Option<u8> {
+        Some(const_try_opt!(self.offset_second_signed()).unsigned_abs())
+    }
+
+    /// Obtain the `offset_second` component.
+    pub const fn offset_second_signed(&self) -> Option<i8> {
+        match (self.offset_second.get_primitive(), self.offset_is_negative) {
+            (Some(offset_second), Some(true)) => Some(-offset_second),
+            (Some(offset_second), _) => Some(offset_second),
+            (None, _) => None,
+        }
+    }
+
+    /// Obtain the `unix_timestamp_nanos` component.
+    pub const fn unix_timestamp_nanos(&self) -> Option<i128> {
+        self.unix_timestamp_nanos.get_primitive()
+    }
+}
+
+/// Generate setters based on the builders.
+macro_rules! setters {
+    ($($name:ident $setter:ident $builder:ident $type:ty;)*) => {$(
+        #[doc = concat!("Set the `", stringify!($setter), "` component.")]
+        pub fn $setter(&mut self, value: $type) -> Option<()> {
+            *self = self.$builder(value)?;
+            Some(())
+        }
+    )*};
+}
+
+/// Setter methods
+///
+/// All setters return `Option<()>`, which is `Some` if the value was set, and `None` if not. The
+/// setters _may_ fail if the value is invalid, though behavior is not guaranteed.
+impl Parsed {
+    setters! {
+        year set_year with_year i32;
+        year_last_two set_year_last_two with_year_last_two u8;
+        iso_year set_iso_year with_iso_year i32;
+        iso_year_last_two set_iso_year_last_two with_iso_year_last_two u8;
+        month set_month with_month Month;
+        sunday_week_number set_sunday_week_number with_sunday_week_number u8;
+        monday_week_number set_monday_week_number with_monday_week_number u8;
+        iso_week_number set_iso_week_number with_iso_week_number NonZeroU8;
+        weekday set_weekday with_weekday Weekday;
+        ordinal set_ordinal with_ordinal NonZeroU16;
+        day set_day with_day NonZeroU8;
+        hour_24 set_hour_24 with_hour_24 u8;
+        hour_12 set_hour_12 with_hour_12 NonZeroU8;
+        hour_12_is_pm set_hour_12_is_pm with_hour_12_is_pm bool;
+        minute set_minute with_minute u8;
+        second set_second with_second u8;
+        subsecond set_subsecond with_subsecond u32;
+        offset_hour set_offset_hour with_offset_hour i8;
+        offset_minute set_offset_minute_signed with_offset_minute_signed i8;
+        offset_second set_offset_second_signed with_offset_second_signed i8;
+        unix_timestamp_nanos set_unix_timestamp_nanos with_unix_timestamp_nanos i128;
+    }
+
+    /// Set the `offset_minute` component.
+    #[doc(hidden)]
+    #[deprecated(
+        since = "0.3.8",
+        note = "use `parsed.set_offset_minute_signed()` instead"
+    )]
+    pub fn set_offset_minute(&mut self, value: u8) -> Option<()> {
+        if value > i8::MAX.cast_unsigned() {
+            None
+        } else {
+            self.set_offset_minute_signed(value.cast_signed())
+        }
+    }
+
+    /// Set the `offset_minute` component.
+    #[doc(hidden)]
+    #[deprecated(
+        since = "0.3.8",
+        note = "use `parsed.set_offset_second_signed()` instead"
+    )]
+    pub fn set_offset_second(&mut self, value: u8) -> Option<()> {
+        if value > i8::MAX.cast_unsigned() {
+            None
+        } else {
+            self.set_offset_second_signed(value.cast_signed())
+        }
+    }
+}
+
+/// Builder methods
+///
+/// All builder methods return `Option<Self>`, which is `Some` if the value was set, and `None` if
+/// not. The builder methods _may_ fail if the value is invalid, though behavior is not guaranteed.
+impl Parsed {
+    /// Set the `year` component and return `self`.
+    pub const fn with_year(mut self, value: i32) -> Option<Self> {
+        self.year = OptionRangedI32::Some(const_try_opt!(RangedI32::new(value)));
+        Some(self)
+    }
+
+    /// Set the `year_last_two` component and return `self`.
+    pub const fn with_year_last_two(mut self, value: u8) -> Option<Self> {
+        self.year_last_two = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `iso_year` component and return `self`.
+    pub const fn with_iso_year(mut self, value: i32) -> Option<Self> {
+        self.iso_year = OptionRangedI32::Some(const_try_opt!(RangedI32::new(value)));
+        Some(self)
+    }
+
+    /// Set the `iso_year_last_two` component and return `self`.
+    pub const fn with_iso_year_last_two(mut self, value: u8) -> Option<Self> {
+        self.iso_year_last_two = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `month` component and return `self`.
+    pub const fn with_month(mut self, value: Month) -> Option<Self> {
+        self.month = Some(value);
+        Some(self)
+    }
+
+    /// Set the `sunday_week_number` component and return `self`.
+    pub const fn with_sunday_week_number(mut self, value: u8) -> Option<Self> {
+        self.sunday_week_number = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `monday_week_number` component and return `self`.
+    pub const fn with_monday_week_number(mut self, value: u8) -> Option<Self> {
+        self.monday_week_number = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `iso_week_number` component and return `self`.
+    pub const fn with_iso_week_number(mut self, value: NonZeroU8) -> Option<Self> {
+        self.iso_week_number = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value.get())));
+        Some(self)
+    }
+
+    /// Set the `weekday` component and return `self`.
+    pub const fn with_weekday(mut self, value: Weekday) -> Option<Self> {
+        self.weekday = Some(value);
+        Some(self)
+    }
+
+    /// Set the `ordinal` component and return `self`.
+    pub const fn with_ordinal(mut self, value: NonZeroU16) -> Option<Self> {
+        self.ordinal = OptionRangedU16::Some(const_try_opt!(RangedU16::new(value.get())));
+        Some(self)
+    }
+
+    /// Set the `day` component and return `self`.
+    pub const fn with_day(mut self, value: NonZeroU8) -> Option<Self> {
+        self.day = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value.get())));
+        Some(self)
+    }
+
+    /// Set the `hour_24` component and return `self`.
+    pub const fn with_hour_24(mut self, value: u8) -> Option<Self> {
+        self.hour_24 = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `hour_12` component and return `self`.
+    pub const fn with_hour_12(mut self, value: NonZeroU8) -> Option<Self> {
+        self.hour_12 = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value.get())));
+        Some(self)
+    }
+
+    /// Set the `hour_12_is_pm` component and return `self`.
+    pub const fn with_hour_12_is_pm(mut self, value: bool) -> Option<Self> {
+        self.hour_12_is_pm = Some(value);
+        Some(self)
+    }
+
+    /// Set the `minute` component and return `self`.
+    pub const fn with_minute(mut self, value: u8) -> Option<Self> {
+        self.minute = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `second` component and return `self`.
+    pub const fn with_second(mut self, value: u8) -> Option<Self> {
+        self.second = OptionRangedU8::Some(const_try_opt!(RangedU8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `subsecond` component and return `self`.
+    pub const fn with_subsecond(mut self, value: u32) -> Option<Self> {
+        self.subsecond = OptionRangedU32::Some(const_try_opt!(RangedU32::new(value)));
+        Some(self)
+    }
+
+    /// Set the `offset_hour` component and return `self`.
+    pub const fn with_offset_hour(mut self, value: i8) -> Option<Self> {
+        self.offset_hour = OptionRangedI8::Some(const_try_opt!(RangedI8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `offset_minute` component and return `self`.
+    #[doc(hidden)]
+    #[deprecated(
+        since = "0.3.8",
+        note = "use `parsed.with_offset_minute_signed()` instead"
+    )]
+    pub const fn with_offset_minute(self, value: u8) -> Option<Self> {
+        if value > i8::MAX as u8 {
+            None
+        } else {
+            self.with_offset_minute_signed(value as _)
+        }
+    }
+
+    /// Set the `offset_minute` component and return `self`.
+    pub const fn with_offset_minute_signed(mut self, value: i8) -> Option<Self> {
+        self.offset_minute = OptionRangedI8::Some(const_try_opt!(RangedI8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `offset_minute` component and return `self`.
+    #[doc(hidden)]
+    #[deprecated(
+        since = "0.3.8",
+        note = "use `parsed.with_offset_second_signed()` instead"
+    )]
+    pub const fn with_offset_second(self, value: u8) -> Option<Self> {
+        if value > i8::MAX as u8 {
+            None
+        } else {
+            self.with_offset_second_signed(value as _)
+        }
+    }
+
+    /// Set the `offset_second` component and return `self`.
+    pub const fn with_offset_second_signed(mut self, value: i8) -> Option<Self> {
+        self.offset_second = OptionRangedI8::Some(const_try_opt!(RangedI8::new(value)));
+        Some(self)
+    }
+
+    /// Set the `unix_timestamp_nanos` component and return `self`.
+    pub const fn with_unix_timestamp_nanos(mut self, value: i128) -> Option<Self> {
+        self.unix_timestamp_nanos = OptionRangedI128::Some(const_try_opt!(RangedI128::new(value)));
+        Some(self)
+    }
+}
+
+impl TryFrom<Parsed> for Date {
+    type Error = error::TryFromParsed;
+
+    fn try_from(parsed: Parsed) -> Result<Self, Self::Error> {
+        /// Match on the components that need to be present.
+        macro_rules! match_ {
+            (_ => $catch_all:expr $(,)?) => {
+                $catch_all
+            };
+            (($($name:ident),* $(,)?) => $arm:expr, $($rest:tt)*) => {
+                if let ($(Some($name)),*) = ($(parsed.$name()),*) {
+                    $arm
+                } else {
+                    match_!($($rest)*)
+                }
+            };
+        }
+
+        /// Get the value needed to adjust the ordinal day for Sunday and Monday-based week
+        /// numbering.
+        const fn adjustment(year: i32) -> i16 {
+            // Safety: `ordinal` is not zero.
+            match unsafe { Date::__from_ordinal_date_unchecked(year, 1) }.weekday() {
+                Weekday::Monday => 7,
+                Weekday::Tuesday => 1,
+                Weekday::Wednesday => 2,
+                Weekday::Thursday => 3,
+                Weekday::Friday => 4,
+                Weekday::Saturday => 5,
+                Weekday::Sunday => 6,
+            }
+        }
+
+        // TODO Only the basics have been covered. There are many other valid values that are not
+        // currently constructed from the information known.
+
+        match_! {
+            (year, ordinal) => Ok(Self::from_ordinal_date(year, ordinal.get())?),
+            (year, month, day) => Ok(Self::from_calendar_date(year, month, day.get())?),
+            (iso_year, iso_week_number, weekday) => Ok(Self::from_iso_week_date(
+                iso_year,
+                iso_week_number.get(),
+                weekday,
+            )?),
+            (year, sunday_week_number, weekday) => Ok(Self::from_ordinal_date(
+                year,
+                (sunday_week_number.cast_signed().extend::<i16>() * 7
+                    + weekday.number_days_from_sunday().cast_signed().extend::<i16>()
+                    - adjustment(year)
+                    + 1).cast_unsigned(),
+            )?),
+            (year, monday_week_number, weekday) => Ok(Self::from_ordinal_date(
+                year,
+                (monday_week_number.cast_signed().extend::<i16>() * 7
+                    + weekday.number_days_from_monday().cast_signed().extend::<i16>()
+                    - adjustment(year)
+                    + 1).cast_unsigned(),
+            )?),
+            _ => Err(InsufficientInformation),
+        }
+    }
+}
+
+impl TryFrom<Parsed> for Time {
+    type Error = error::TryFromParsed;
+
+    fn try_from(parsed: Parsed) -> Result<Self, Self::Error> {
+        let hour = match (parsed.hour_24(), parsed.hour_12(), parsed.hour_12_is_pm()) {
+            (Some(hour), _, _) => hour,
+            (_, Some(hour), Some(false)) if hour.get() == 12 => 0,
+            (_, Some(hour), Some(true)) if hour.get() == 12 => 12,
+            (_, Some(hour), Some(false)) => hour.get(),
+            (_, Some(hour), Some(true)) => hour.get() + 12,
+            _ => return Err(InsufficientInformation),
+        };
+
+        if parsed.hour_24().is_none()
+            && parsed.hour_12().is_some()
+            && parsed.hour_12_is_pm().is_some()
+            && parsed.minute().is_none()
+            && parsed.second().is_none()
+            && parsed.subsecond().is_none()
+        {
+            return Ok(Self::from_hms_nano(hour, 0, 0, 0)?);
+        }
+
+        // Reject combinations such as hour-second with minute omitted.
+        match (parsed.minute(), parsed.second(), parsed.subsecond()) {
+            (None, None, None) => Ok(Self::from_hms_nano(hour, 0, 0, 0)?),
+            (Some(minute), None, None) => Ok(Self::from_hms_nano(hour, minute, 0, 0)?),
+            (Some(minute), Some(second), None) => Ok(Self::from_hms_nano(hour, minute, second, 0)?),
+            (Some(minute), Some(second), Some(subsecond)) => {
+                Ok(Self::from_hms_nano(hour, minute, second, subsecond)?)
+            }
+            _ => Err(InsufficientInformation),
+        }
+    }
+}
+
+impl TryFrom<Parsed> for UtcOffset {
+    type Error = error::TryFromParsed;
+
+    fn try_from(parsed: Parsed) -> Result<Self, Self::Error> {
+        let hour = parsed.offset_hour().ok_or(InsufficientInformation)?;
+        let minute = parsed.offset_minute_signed().unwrap_or(0);
+        let second = parsed.offset_second_signed().unwrap_or(0);
+
+        Self::from_hms(hour, minute, second).map_err(|mut err| {
+            // Provide the user a more accurate error.
+            if err.name == "hours" {
+                err.name = "offset hour";
+            } else if err.name == "minutes" {
+                err.name = "offset minute";
+            } else if err.name == "seconds" {
+                err.name = "offset second";
+            }
+            err.into()
+        })
+    }
+}
+
+impl TryFrom<Parsed> for PrimitiveDateTime {
+    type Error = error::TryFromParsed;
+
+    fn try_from(parsed: Parsed) -> Result<Self, Self::Error> {
+        Ok(Self::new(parsed.try_into()?, parsed.try_into()?))
+    }
+}
+
+impl TryFrom<Parsed> for OffsetDateTime {
+    type Error = error::TryFromParsed;
+
+    fn try_from(mut parsed: Parsed) -> Result<Self, Self::Error> {
+        if let Some(timestamp) = parsed.unix_timestamp_nanos() {
+            let mut value = Self::from_unix_timestamp_nanos(timestamp)?;
+            if let Some(subsecond) = parsed.subsecond() {
+                value = value.replace_nanosecond(subsecond)?;
+            }
+            return Ok(value);
+        }
+
+        // Some well-known formats explicitly allow leap seconds. We don't currently support them,
+        // so treat it as the nearest preceding moment that can be represented. Because leap seconds
+        // always fall at the end of a month UTC, reject any that are at other times.
+        let leap_second_input = if parsed.leap_second_allowed && parsed.second() == Some(60) {
+            if parsed.set_second(59).is_none() {
+                bug!("59 is a valid second");
+            }
+            if parsed.set_subsecond(999_999_999).is_none() {
+                bug!("999_999_999 is a valid subsecond");
+            }
+            true
+        } else {
+            false
+        };
+
+        let dt = Self::new_in_offset(
+            Date::try_from(parsed)?,
+            Time::try_from(parsed)?,
+            UtcOffset::try_from(parsed)?,
+        );
+
+        if leap_second_input && !dt.is_valid_leap_second_stand_in() {
+            return Err(error::TryFromParsed::ComponentRange(
+                error::ComponentRange {
+                    name: "second",
+                    minimum: 0,
+                    maximum: 59,
+                    value: 60,
+                    conditional_range: true,
+                },
+            ));
+        }
+        Ok(dt)
+    }
+}
diff --git a/time/src/parsing/shim.rs b/time/src/parsing/shim.rs
new file mode 100644
index 000000000..ced7feb03
--- /dev/null
+++ b/time/src/parsing/shim.rs
@@ -0,0 +1,50 @@
+//! Extension traits for things either not implemented or not yet stable in the MSRV.
+
+/// Equivalent of `foo.parse()` for slices.
+pub(crate) trait IntegerParseBytes<T> {
+    #[allow(clippy::missing_docs_in_private_items)]
+    fn parse_bytes(&self) -> Option<T>;
+}
+
+impl<T: Integer> IntegerParseBytes<T> for [u8] {
+    fn parse_bytes(&self) -> Option<T> {
+        T::parse_bytes(self)
+    }
+}
+
+/// Marker trait for all integer types, including `NonZero*`
+pub(crate) trait Integer: Sized {
+    #[allow(clippy::missing_docs_in_private_items)]
+    fn parse_bytes(src: &[u8]) -> Option<Self>;
+}
+
+/// Parse the given types from bytes.
+macro_rules! impl_parse_bytes {
+    ($($t:ty)*) => ($(
+        impl Integer for $t {
+            #[allow(trivial_numeric_casts)]
+            fn parse_bytes(src: &[u8]) -> Option<Self> {
+                src.iter().try_fold::<Self, _, _>(0, |result, c| {
+                    result.checked_mul(10)?.checked_add((c - b'0') as Self)
+                })
+            }
+        }
+    )*)
+}
+impl_parse_bytes! { u8 u16 u32 u128 }
+
+/// Parse the given types from bytes.
+macro_rules! impl_parse_bytes_nonzero {
+    ($($t:ty)*) => {$(
+        impl Integer for $t {
+            fn parse_bytes(src: &[u8]) -> Option<Self> {
+                Self::new(src.parse_bytes()?)
+            }
+        }
+    )*}
+}
+
+impl_parse_bytes_nonzero! {
+    core::num::NonZeroU8
+    core::num::NonZeroU16
+}
diff --git a/time/src/primitive_date_time.rs b/time/src/primitive_date_time.rs
new file mode 100644
index 000000000..85ae075e8
--- /dev/null
+++ b/time/src/primitive_date_time.rs
@@ -0,0 +1,1049 @@
+//! The [`PrimitiveDateTime`] struct and its associated `impl`s.
+
+#[cfg(feature = "formatting")]
+use alloc::string::String;
+use core::fmt;
+use core::ops::{Add, AddAssign, Sub, SubAssign};
+use core::time::Duration as StdDuration;
+#[cfg(feature = "formatting")]
+use std::io;
+
+use powerfmt::ext::FormatterExt as _;
+use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
+
+#[cfg(feature = "formatting")]
+use crate::formatting::Formattable;
+use crate::internal_macros::{const_try, const_try_opt};
+#[cfg(feature = "parsing")]
+use crate::parsing::Parsable;
+use crate::{error, util, Date, Duration, Month, OffsetDateTime, Time, UtcOffset, Weekday};
+
+/// Combined date and time.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct PrimitiveDateTime {
+    date: Date,
+    time: Time,
+}
+
+impl PrimitiveDateTime {
+    /// The smallest value that can be represented by `PrimitiveDateTime`.
+    ///
+    /// Depending on `large-dates` feature flag, value of this constant may vary.
+    ///
+    /// 1. With `large-dates` disabled it is equal to `-9999-01-01 00:00:00.0`
+    /// 2. With `large-dates` enabled it is equal to `-999999-01-01 00:00:00.0`
+    ///
+    /// ```rust
+    /// # use time::PrimitiveDateTime;
+    /// # use time_macros::datetime;
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "// Assuming `large-dates` feature is enabled."
+    )]
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "assert_eq!(PrimitiveDateTime::MIN, datetime!(-999999-01-01 0:00));"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "// Assuming `large-dates` feature is disabled."
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "assert_eq!(PrimitiveDateTime::MIN, datetime!(-9999-01-01 0:00));"
+    )]
+    /// ```
+    pub const MIN: Self = Self {
+        date: Date::MIN,
+        time: Time::MIDNIGHT,
+    };
+
+    /// The largest value that can be represented by `PrimitiveDateTime`.
+    ///
+    /// Depending on `large-dates` feature flag, value of this constant may vary.
+    ///
+    /// 1. With `large-dates` disabled it is equal to `9999-12-31 23:59:59.999_999_999`
+    /// 2. With `large-dates` enabled it is equal to `999999-12-31 23:59:59.999_999_999`
+    ///
+    /// ```rust
+    /// # use time::PrimitiveDateTime;
+    /// # use time_macros::datetime;
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "// Assuming `large-dates` feature is enabled."
+    )]
+    #[cfg_attr(
+        feature = "large-dates",
+        doc = "assert_eq!(PrimitiveDateTime::MAX, datetime!(+999999-12-31 23:59:59.999_999_999));"
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "// Assuming `large-dates` feature is disabled."
+    )]
+    #[cfg_attr(
+        not(feature = "large-dates"),
+        doc = "assert_eq!(PrimitiveDateTime::MAX, datetime!(+9999-12-31 23:59:59.999_999_999));"
+    )]
+    /// ```
+    pub const MAX: Self = Self {
+        date: Date::MAX,
+        time: Time::MAX,
+    };
+
+    /// Create a new `PrimitiveDateTime` from the provided [`Date`] and [`Time`].
+    ///
+    /// ```rust
+    /// # use time::PrimitiveDateTime;
+    /// # use time_macros::{date, datetime, time};
+    /// assert_eq!(
+    ///     PrimitiveDateTime::new(date!(2019-01-01), time!(0:00)),
+    ///     datetime!(2019-01-01 0:00),
+    /// );
+    /// ```
+    pub const fn new(date: Date, time: Time) -> Self {
+        Self { date, time }
+    }
+
+    // region: component getters
+    /// Get the [`Date`] component of the `PrimitiveDateTime`.
+    ///
+    /// ```rust
+    /// # use time_macros::{date, datetime};
+    /// assert_eq!(datetime!(2019-01-01 0:00).date(), date!(2019-01-01));
+    /// ```
+    pub const fn date(self) -> Date {
+        self.date
+    }
+
+    /// Get the [`Time`] component of the `PrimitiveDateTime`.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, time};
+    /// assert_eq!(datetime!(2019-01-01 0:00).time(), time!(0:00));
+    /// ```
+    pub const fn time(self) -> Time {
+        self.time
+    }
+    // endregion component getters
+
+    // region: date getters
+    /// Get the year of the date.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).year(), 2019);
+    /// assert_eq!(datetime!(2019-12-31 0:00).year(), 2019);
+    /// assert_eq!(datetime!(2020-01-01 0:00).year(), 2020);
+    /// ```
+    pub const fn year(self) -> i32 {
+        self.date().year()
+    }
+
+    /// Get the month of the date.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).month(), Month::January);
+    /// assert_eq!(datetime!(2019-12-31 0:00).month(), Month::December);
+    /// ```
+    pub const fn month(self) -> Month {
+        self.date().month()
+    }
+
+    /// Get the day of the date.
+    ///
+    /// The returned value will always be in the range `1..=31`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).day(), 1);
+    /// assert_eq!(datetime!(2019-12-31 0:00).day(), 31);
+    /// ```
+    pub const fn day(self) -> u8 {
+        self.date().day()
+    }
+
+    /// Get the day of the year.
+    ///
+    /// The returned value will always be in the range `1..=366` (`1..=365` for common years).
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).ordinal(), 1);
+    /// assert_eq!(datetime!(2019-12-31 0:00).ordinal(), 365);
+    /// ```
+    pub const fn ordinal(self) -> u16 {
+        self.date().ordinal()
+    }
+
+    /// Get the ISO week number.
+    ///
+    /// The returned value will always be in the range `1..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).iso_week(), 1);
+    /// assert_eq!(datetime!(2019-10-04 0:00).iso_week(), 40);
+    /// assert_eq!(datetime!(2020-01-01 0:00).iso_week(), 1);
+    /// assert_eq!(datetime!(2020-12-31 0:00).iso_week(), 53);
+    /// assert_eq!(datetime!(2021-01-01 0:00).iso_week(), 53);
+    /// ```
+    pub const fn iso_week(self) -> u8 {
+        self.date().iso_week()
+    }
+
+    /// Get the week number where week 1 begins on the first Sunday.
+    ///
+    /// The returned value will always be in the range `0..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).sunday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-01-01 0:00).sunday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-12-31 0:00).sunday_based_week(), 52);
+    /// assert_eq!(datetime!(2021-01-01 0:00).sunday_based_week(), 0);
+    /// ```
+    pub const fn sunday_based_week(self) -> u8 {
+        self.date().sunday_based_week()
+    }
+
+    /// Get the week number where week 1 begins on the first Monday.
+    ///
+    /// The returned value will always be in the range `0..=53`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).monday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-01-01 0:00).monday_based_week(), 0);
+    /// assert_eq!(datetime!(2020-12-31 0:00).monday_based_week(), 52);
+    /// assert_eq!(datetime!(2021-01-01 0:00).monday_based_week(), 0);
+    /// ```
+    pub const fn monday_based_week(self) -> u8 {
+        self.date().monday_based_week()
+    }
+
+    /// Get the year, month, and day.
+    ///
+    /// ```rust
+    /// # use time::Month;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00).to_calendar_date(),
+    ///     (2019, Month::January, 1)
+    /// );
+    /// ```
+    pub const fn to_calendar_date(self) -> (i32, Month, u8) {
+        self.date().to_calendar_date()
+    }
+
+    /// Get the year and ordinal day number.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).to_ordinal_date(), (2019, 1));
+    /// ```
+    pub const fn to_ordinal_date(self) -> (i32, u16) {
+        self.date().to_ordinal_date()
+    }
+
+    /// Get the ISO 8601 year, week number, and weekday.
+    ///
+    /// ```rust
+    /// # use time::Weekday::*;
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00).to_iso_week_date(),
+    ///     (2019, 1, Tuesday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2019-10-04 0:00).to_iso_week_date(),
+    ///     (2019, 40, Friday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 0:00).to_iso_week_date(),
+    ///     (2020, 1, Wednesday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2020-12-31 0:00).to_iso_week_date(),
+    ///     (2020, 53, Thursday)
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2021-01-01 0:00).to_iso_week_date(),
+    ///     (2020, 53, Friday)
+    /// );
+    /// ```
+    pub const fn to_iso_week_date(self) -> (i32, u8, Weekday) {
+        self.date().to_iso_week_date()
+    }
+
+    /// Get the weekday.
+    ///
+    /// ```rust
+    /// # use time::Weekday::*;
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).weekday(), Tuesday);
+    /// assert_eq!(datetime!(2019-02-01 0:00).weekday(), Friday);
+    /// assert_eq!(datetime!(2019-03-01 0:00).weekday(), Friday);
+    /// assert_eq!(datetime!(2019-04-01 0:00).weekday(), Monday);
+    /// assert_eq!(datetime!(2019-05-01 0:00).weekday(), Wednesday);
+    /// assert_eq!(datetime!(2019-06-01 0:00).weekday(), Saturday);
+    /// assert_eq!(datetime!(2019-07-01 0:00).weekday(), Monday);
+    /// assert_eq!(datetime!(2019-08-01 0:00).weekday(), Thursday);
+    /// assert_eq!(datetime!(2019-09-01 0:00).weekday(), Sunday);
+    /// assert_eq!(datetime!(2019-10-01 0:00).weekday(), Tuesday);
+    /// assert_eq!(datetime!(2019-11-01 0:00).weekday(), Friday);
+    /// assert_eq!(datetime!(2019-12-01 0:00).weekday(), Sunday);
+    /// ```
+    pub const fn weekday(self) -> Weekday {
+        self.date().weekday()
+    }
+
+    /// Get the Julian day for the date. The time is not taken into account for this calculation.
+    ///
+    /// The algorithm to perform this conversion is derived from one provided by Peter Baum; it is
+    /// freely available [here](https://www.researchgate.net/publication/316558298_Date_Algorithms).
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(-4713-11-24 0:00).to_julian_day(), 0);
+    /// assert_eq!(datetime!(2000-01-01 0:00).to_julian_day(), 2_451_545);
+    /// assert_eq!(datetime!(2019-01-01 0:00).to_julian_day(), 2_458_485);
+    /// assert_eq!(datetime!(2019-12-31 0:00).to_julian_day(), 2_458_849);
+    /// ```
+    pub const fn to_julian_day(self) -> i32 {
+        self.date().to_julian_day()
+    }
+    // endregion date getters
+
+    // region: time getters
+    /// Get the clock hour, minute, and second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms(), (0, 0, 0));
+    /// assert_eq!(datetime!(2020-01-01 23:59:59).as_hms(), (23, 59, 59));
+    /// ```
+    pub const fn as_hms(self) -> (u8, u8, u8) {
+        self.time().as_hms()
+    }
+
+    /// Get the clock hour, minute, second, and millisecond.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms_milli(), (0, 0, 0, 0));
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 23:59:59.999).as_hms_milli(),
+    ///     (23, 59, 59, 999)
+    /// );
+    /// ```
+    pub const fn as_hms_milli(self) -> (u8, u8, u8, u16) {
+        self.time().as_hms_milli()
+    }
+
+    /// Get the clock hour, minute, second, and microsecond.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms_micro(), (0, 0, 0, 0));
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 23:59:59.999_999).as_hms_micro(),
+    ///     (23, 59, 59, 999_999)
+    /// );
+    /// ```
+    pub const fn as_hms_micro(self) -> (u8, u8, u8, u32) {
+        self.time().as_hms_micro()
+    }
+
+    /// Get the clock hour, minute, second, and nanosecond.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2020-01-01 0:00:00).as_hms_nano(), (0, 0, 0, 0));
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 23:59:59.999_999_999).as_hms_nano(),
+    ///     (23, 59, 59, 999_999_999)
+    /// );
+    /// ```
+    pub const fn as_hms_nano(self) -> (u8, u8, u8, u32) {
+        self.time().as_hms_nano()
+    }
+
+    /// Get the clock hour.
+    ///
+    /// The returned value will always be in the range `0..24`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).hour(), 0);
+    /// assert_eq!(datetime!(2019-01-01 23:59:59).hour(), 23);
+    /// ```
+    pub const fn hour(self) -> u8 {
+        self.time().hour()
+    }
+
+    /// Get the minute within the hour.
+    ///
+    /// The returned value will always be in the range `0..60`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).minute(), 0);
+    /// assert_eq!(datetime!(2019-01-01 23:59:59).minute(), 59);
+    /// ```
+    pub const fn minute(self) -> u8 {
+        self.time().minute()
+    }
+
+    /// Get the second within the minute.
+    ///
+    /// The returned value will always be in the range `0..60`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).second(), 0);
+    /// assert_eq!(datetime!(2019-01-01 23:59:59).second(), 59);
+    /// ```
+    pub const fn second(self) -> u8 {
+        self.time().second()
+    }
+
+    /// Get the milliseconds within the second.
+    ///
+    /// The returned value will always be in the range `0..1_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).millisecond(), 0);
+    /// assert_eq!(datetime!(2019-01-01 23:59:59.999).millisecond(), 999);
+    /// ```
+    pub const fn millisecond(self) -> u16 {
+        self.time().millisecond()
+    }
+
+    /// Get the microseconds within the second.
+    ///
+    /// The returned value will always be in the range `0..1_000_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).microsecond(), 0);
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 23:59:59.999_999).microsecond(),
+    ///     999_999
+    /// );
+    /// ```
+    pub const fn microsecond(self) -> u32 {
+        self.time().microsecond()
+    }
+
+    /// Get the nanoseconds within the second.
+    ///
+    /// The returned value will always be in the range `0..1_000_000_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2019-01-01 0:00).nanosecond(), 0);
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 23:59:59.999_999_999).nanosecond(),
+    ///     999_999_999,
+    /// );
+    /// ```
+    pub const fn nanosecond(self) -> u32 {
+        self.time().nanosecond()
+    }
+    // endregion time getters
+
+    // region: attach offset
+    /// Assuming that the existing `PrimitiveDateTime` represents a moment in the provided
+    /// [`UtcOffset`], return an [`OffsetDateTime`].
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, offset};
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00)
+    ///         .assume_offset(offset!(UTC))
+    ///         .unix_timestamp(),
+    ///     1_546_300_800,
+    /// );
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00)
+    ///         .assume_offset(offset!(-1))
+    ///         .unix_timestamp(),
+    ///     1_546_304_400,
+    /// );
+    /// ```
+    pub const fn assume_offset(self, offset: UtcOffset) -> OffsetDateTime {
+        OffsetDateTime::new_in_offset(self.date, self.time, offset)
+    }
+
+    /// Assuming that the existing `PrimitiveDateTime` represents a moment in UTC, return an
+    /// [`OffsetDateTime`].
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2019-01-01 0:00).assume_utc().unix_timestamp(),
+    ///     1_546_300_800,
+    /// );
+    /// ```
+    pub const fn assume_utc(self) -> OffsetDateTime {
+        self.assume_offset(UtcOffset::UTC)
+    }
+    // endregion attach offset
+
+    // region: checked arithmetic
+    /// Computes `self + duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::datetime;
+    /// let datetime = Date::MIN.midnight();
+    /// assert_eq!(datetime.checked_add((-2).days()), None);
+    ///
+    /// let datetime = Date::MAX.midnight();
+    /// assert_eq!(datetime.checked_add(1.days()), None);
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30).checked_add(27.hours()),
+    ///     Some(datetime!(2019 - 11 - 26 18:30))
+    /// );
+    /// ```
+    pub const fn checked_add(self, duration: Duration) -> Option<Self> {
+        let (date_adjustment, time) = self.time.adjusting_add(duration);
+        let date = const_try_opt!(self.date.checked_add(duration));
+
+        Some(Self {
+            date: match date_adjustment {
+                util::DateAdjustment::Previous => const_try_opt!(date.previous_day()),
+                util::DateAdjustment::Next => const_try_opt!(date.next_day()),
+                util::DateAdjustment::None => date,
+            },
+            time,
+        })
+    }
+
+    /// Computes `self - duration`, returning `None` if an overflow occurred.
+    ///
+    /// ```
+    /// # use time::{Date, ext::NumericalDuration};
+    /// # use time_macros::datetime;
+    /// let datetime = Date::MIN.midnight();
+    /// assert_eq!(datetime.checked_sub(2.days()), None);
+    ///
+    /// let datetime = Date::MAX.midnight();
+    /// assert_eq!(datetime.checked_sub((-1).days()), None);
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30).checked_sub(27.hours()),
+    ///     Some(datetime!(2019 - 11 - 24 12:30))
+    /// );
+    /// ```
+    pub const fn checked_sub(self, duration: Duration) -> Option<Self> {
+        let (date_adjustment, time) = self.time.adjusting_sub(duration);
+        let date = const_try_opt!(self.date.checked_sub(duration));
+
+        Some(Self {
+            date: match date_adjustment {
+                util::DateAdjustment::Previous => const_try_opt!(date.previous_day()),
+                util::DateAdjustment::Next => const_try_opt!(date.next_day()),
+                util::DateAdjustment::None => date,
+            },
+            time,
+        })
+    }
+    // endregion: checked arithmetic
+
+    // region: saturating arithmetic
+    /// Computes `self + duration`, saturating value on overflow.
+    ///
+    /// ```
+    /// # use time::{PrimitiveDateTime, ext::NumericalDuration};
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     PrimitiveDateTime::MIN.saturating_add((-2).days()),
+    ///     PrimitiveDateTime::MIN
+    /// );
+    ///
+    /// assert_eq!(
+    ///     PrimitiveDateTime::MAX.saturating_add(2.days()),
+    ///     PrimitiveDateTime::MAX
+    /// );
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30).saturating_add(27.hours()),
+    ///     datetime!(2019 - 11 - 26 18:30)
+    /// );
+    /// ```
+    pub const fn saturating_add(self, duration: Duration) -> Self {
+        if let Some(datetime) = self.checked_add(duration) {
+            datetime
+        } else if duration.is_negative() {
+            Self::MIN
+        } else {
+            Self::MAX
+        }
+    }
+
+    /// Computes `self - duration`, saturating value on overflow.
+    ///
+    /// ```
+    /// # use time::{PrimitiveDateTime, ext::NumericalDuration};
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     PrimitiveDateTime::MIN.saturating_sub(2.days()),
+    ///     PrimitiveDateTime::MIN
+    /// );
+    ///
+    /// assert_eq!(
+    ///     PrimitiveDateTime::MAX.saturating_sub((-2).days()),
+    ///     PrimitiveDateTime::MAX
+    /// );
+    ///
+    /// assert_eq!(
+    ///     datetime!(2019 - 11 - 25 15:30).saturating_sub(27.hours()),
+    ///     datetime!(2019 - 11 - 24 12:30)
+    /// );
+    /// ```
+    pub const fn saturating_sub(self, duration: Duration) -> Self {
+        if let Some(datetime) = self.checked_sub(duration) {
+            datetime
+        } else if duration.is_negative() {
+            Self::MAX
+        } else {
+            Self::MIN
+        }
+    }
+    // endregion: saturating arithmetic
+}
+
+// region: replacement
+/// Methods that replace part of the `PrimitiveDateTime`.
+impl PrimitiveDateTime {
+    /// Replace the time, preserving the date.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, time};
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 17:00).replace_time(time!(5:00)),
+    ///     datetime!(2020-01-01 5:00)
+    /// );
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_time(self, time: Time) -> Self {
+        Self {
+            date: self.date,
+            time,
+        }
+    }
+
+    /// Replace the date, preserving the time.
+    ///
+    /// ```rust
+    /// # use time_macros::{datetime, date};
+    /// assert_eq!(
+    ///     datetime!(2020-01-01 12:00).replace_date(date!(2020-01-30)),
+    ///     datetime!(2020-01-30 12:00)
+    /// );
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_date(self, date: Date) -> Self {
+        Self {
+            date,
+            time: self.time,
+        }
+    }
+
+    /// Replace the year. The month and day will be unchanged.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 12:00).replace_year(2019),
+    ///     Ok(datetime!(2019 - 02 - 18 12:00))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 12:00).replace_year(-1_000_000_000).is_err()); // -1_000_000_000 isn't a valid year
+    /// assert!(datetime!(2022 - 02 - 18 12:00).replace_year(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid year
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_year(self, year: i32) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: const_try!(self.date.replace_year(year)),
+            time: self.time,
+        })
+    }
+
+    /// Replace the month of the year.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// # use time::Month;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 12:00).replace_month(Month::January),
+    ///     Ok(datetime!(2022 - 01 - 18 12:00))
+    /// );
+    /// assert!(datetime!(2022 - 01 - 30 12:00).replace_month(Month::February).is_err()); // 30 isn't a valid day in February
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_month(self, month: Month) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: const_try!(self.date.replace_month(month)),
+            time: self.time,
+        })
+    }
+
+    /// Replace the day of the month.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 12:00).replace_day(1),
+    ///     Ok(datetime!(2022 - 02 - 01 12:00))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 12:00).replace_day(0).is_err()); // 00 isn't a valid day
+    /// assert!(datetime!(2022 - 02 - 18 12:00).replace_day(30).is_err()); // 30 isn't a valid day in February
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_day(self, day: u8) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: const_try!(self.date.replace_day(day)),
+            time: self.time,
+        })
+    }
+
+    /// Replace the day of the year.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(datetime!(2022-049 12:00).replace_ordinal(1), Ok(datetime!(2022-001 12:00)));
+    /// assert!(datetime!(2022-049 12:00).replace_ordinal(0).is_err()); // 0 isn't a valid ordinal
+    /// assert!(datetime!(2022-049 12:00).replace_ordinal(366).is_err()); // 2022 isn't a leap year
+    /// ````
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_ordinal(self, ordinal: u16) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: const_try!(self.date.replace_ordinal(ordinal)),
+            time: self.time,
+        })
+    }
+
+    /// Replace the clock hour.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_hour(7),
+    ///     Ok(datetime!(2022 - 02 - 18 07:02:03.004_005_006))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_hour(24).is_err()); // 24 isn't a valid hour
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_hour(self, hour: u8) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: self.date,
+            time: const_try!(self.time.replace_hour(hour)),
+        })
+    }
+
+    /// Replace the minutes within the hour.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_minute(7),
+    ///     Ok(datetime!(2022 - 02 - 18 01:07:03.004_005_006))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_minute(60).is_err()); // 60 isn't a valid minute
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_minute(self, minute: u8) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: self.date,
+            time: const_try!(self.time.replace_minute(minute)),
+        })
+    }
+
+    /// Replace the seconds within the minute.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_second(7),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:07.004_005_006))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_second(60).is_err()); // 60 isn't a valid second
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_second(self, second: u8) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: self.date,
+            time: const_try!(self.time.replace_second(second)),
+        })
+    }
+
+    /// Replace the milliseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_millisecond(7),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:03.007))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_millisecond(1_000).is_err()); // 1_000 isn't a valid millisecond
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_millisecond(
+        self,
+        millisecond: u16,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: self.date,
+            time: const_try!(self.time.replace_millisecond(millisecond)),
+        })
+    }
+
+    /// Replace the microseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_microsecond(7_008),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_microsecond(1_000_000).is_err()); // 1_000_000 isn't a valid microsecond
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_microsecond(
+        self,
+        microsecond: u32,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: self.date,
+            time: const_try!(self.time.replace_microsecond(microsecond)),
+        })
+    }
+
+    /// Replace the nanoseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::datetime;
+    /// assert_eq!(
+    ///     datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_nanosecond(7_008_009),
+    ///     Ok(datetime!(2022 - 02 - 18 01:02:03.007_008_009))
+    /// );
+    /// assert!(datetime!(2022 - 02 - 18 01:02:03.004_005_006).replace_nanosecond(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond
+    /// ```
+    #[must_use = "This method does not mutate the original `PrimitiveDateTime`."]
+    pub const fn replace_nanosecond(self, nanosecond: u32) -> Result<Self, error::ComponentRange> {
+        Ok(Self {
+            date: self.date,
+            time: const_try!(self.time.replace_nanosecond(nanosecond)),
+        })
+    }
+}
+// endregion replacement
+
+// region: formatting & parsing
+#[cfg(feature = "formatting")]
+impl PrimitiveDateTime {
+    /// Format the `PrimitiveDateTime` using the provided [format
+    /// description](crate::format_description).
+    pub fn format_into(
+        self,
+        output: &mut impl io::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<usize, error::Format> {
+        format.format_into(output, Some(self.date), Some(self.time), None)
+    }
+
+    /// Format the `PrimitiveDateTime` using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::format_description;
+    /// # use time_macros::datetime;
+    /// let format = format_description::parse("[year]-[month]-[day] [hour]:[minute]:[second]")?;
+    /// assert_eq!(
+    ///     datetime!(2020-01-02 03:04:05).format(&format)?,
+    ///     "2020-01-02 03:04:05"
+    /// );
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format(self, format: &(impl Formattable + ?Sized)) -> Result<String, error::Format> {
+        format.format(Some(self.date), Some(self.time), None)
+    }
+}
+
+#[cfg(feature = "parsing")]
+impl PrimitiveDateTime {
+    /// Parse a `PrimitiveDateTime` from the input using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::PrimitiveDateTime;
+    /// # use time_macros::{datetime, format_description};
+    /// let format = format_description!("[year]-[month]-[day] [hour]:[minute]:[second]");
+    /// assert_eq!(
+    ///     PrimitiveDateTime::parse("2020-01-02 03:04:05", &format)?,
+    ///     datetime!(2020-01-02 03:04:05)
+    /// );
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn parse(
+        input: &str,
+        description: &(impl Parsable + ?Sized),
+    ) -> Result<Self, error::Parse> {
+        description.parse_primitive_date_time(input.as_bytes())
+    }
+}
+
+impl SmartDisplay for PrimitiveDateTime {
+    type Metadata = ();
+
+    fn metadata(&self, _: FormatterOptions) -> Metadata<Self> {
+        let width = smart_display::padded_width_of!(self.date, " ", self.time);
+        Metadata::new(width, self, ())
+    }
+
+    fn fmt_with_metadata(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        metadata: Metadata<Self>,
+    ) -> fmt::Result {
+        f.pad_with_width(
+            metadata.unpadded_width(),
+            format_args!("{} {}", self.date, self.time),
+        )
+    }
+}
+
+impl fmt::Display for PrimitiveDateTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        SmartDisplay::fmt(self, f)
+    }
+}
+
+impl fmt::Debug for PrimitiveDateTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+// endregion formatting & parsing
+
+// region: trait impls
+impl Add<Duration> for PrimitiveDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, duration: Duration) -> Self::Output {
+        self.checked_add(duration)
+            .expect("resulting value is out of range")
+    }
+}
+
+impl Add<StdDuration> for PrimitiveDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add(self, duration: StdDuration) -> Self::Output {
+        let (is_next_day, time) = self.time.adjusting_add_std(duration);
+
+        Self {
+            date: if is_next_day {
+                (self.date + duration)
+                    .next_day()
+                    .expect("resulting value is out of range")
+            } else {
+                self.date + duration
+            },
+            time,
+        }
+    }
+}
+
+impl AddAssign<Duration> for PrimitiveDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add_assign(&mut self, duration: Duration) {
+        *self = *self + duration;
+    }
+}
+
+impl AddAssign<StdDuration> for PrimitiveDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn add_assign(&mut self, duration: StdDuration) {
+        *self = *self + duration;
+    }
+}
+
+impl Sub<Duration> for PrimitiveDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, duration: Duration) -> Self::Output {
+        self.checked_sub(duration)
+            .expect("resulting value is out of range")
+    }
+}
+
+impl Sub<StdDuration> for PrimitiveDateTime {
+    type Output = Self;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, duration: StdDuration) -> Self::Output {
+        let (is_previous_day, time) = self.time.adjusting_sub_std(duration);
+
+        Self {
+            date: if is_previous_day {
+                (self.date - duration)
+                    .previous_day()
+                    .expect("resulting value is out of range")
+            } else {
+                self.date - duration
+            },
+            time,
+        }
+    }
+}
+
+impl SubAssign<Duration> for PrimitiveDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub_assign(&mut self, duration: Duration) {
+        *self = *self - duration;
+    }
+}
+
+impl SubAssign<StdDuration> for PrimitiveDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub_assign(&mut self, duration: StdDuration) {
+        *self = *self - duration;
+    }
+}
+
+impl Sub for PrimitiveDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: Self) -> Self::Output {
+        (self.date - rhs.date) + (self.time - rhs.time)
+    }
+}
+// endregion trait impls
diff --git a/time/src/quickcheck.rs b/time/src/quickcheck.rs
new file mode 100644
index 000000000..312a09e19
--- /dev/null
+++ b/time/src/quickcheck.rs
@@ -0,0 +1,211 @@
+//! Implementations of the [`quickcheck::Arbitrary`](quickcheck::Arbitrary) trait.
+//!
+//! This enables users to write tests such as this, and have test values provided automatically:
+//!
+//! ```ignore
+//! # #![allow(dead_code)]
+//! use quickcheck::quickcheck;
+//! use time::Date;
+//!
+//! struct DateRange {
+//!     from: Date,
+//!     to: Date,
+//! }
+//!
+//! impl DateRange {
+//!     fn new(from: Date, to: Date) -> Result<Self, ()> {
+//!         Ok(DateRange { from, to })
+//!     }
+//! }
+//!
+//! quickcheck! {
+//!     fn date_range_is_well_defined(from: Date, to: Date) -> bool {
+//!         let r = DateRange::new(from, to);
+//!         if from <= to {
+//!             r.is_ok()
+//!         } else {
+//!             r.is_err()
+//!         }
+//!     }
+//! }
+//! ```
+//!
+//! An implementation for `Instant` is intentionally omitted since its values are only meaningful in
+//! relation to a [`Duration`], and obtaining an `Instant` from a [`Duration`] is very simple
+//! anyway.
+
+use alloc::boxed::Box;
+
+use quickcheck::{empty_shrinker, single_shrinker, Arbitrary, Gen};
+
+use crate::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+/// Obtain an arbitrary value between the minimum and maximum inclusive.
+macro_rules! arbitrary_between {
+    ($type:ty; $gen:expr, $min:expr, $max:expr) => {{
+        let min = $min;
+        let max = $max;
+        let range = max - min;
+        <$type>::arbitrary($gen).rem_euclid(range + 1) + min
+    }};
+}
+
+impl Arbitrary for Date {
+    fn arbitrary(g: &mut Gen) -> Self {
+        Self::from_julian_day_unchecked(arbitrary_between!(
+            i32;
+            g,
+            Self::MIN.to_julian_day(),
+            Self::MAX.to_julian_day()
+        ))
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        Box::new(
+            self.to_ordinal_date()
+                .shrink()
+                .flat_map(|(year, ordinal)| Self::from_ordinal_date(year, ordinal)),
+        )
+    }
+}
+
+impl Arbitrary for Duration {
+    fn arbitrary(g: &mut Gen) -> Self {
+        Self::new_ranged(<_>::arbitrary(g), <_>::arbitrary(g))
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        Box::new(
+            (self.subsec_nanoseconds_ranged(), self.whole_seconds())
+                .shrink()
+                .map(|(mut nanoseconds, seconds)| {
+                    // Coerce the sign if necessary.
+                    if (seconds > 0 && nanoseconds.get() < 0)
+                        || (seconds < 0 && nanoseconds.get() > 0)
+                    {
+                        nanoseconds = nanoseconds.neg();
+                    }
+
+                    Self::new_ranged_unchecked(seconds, nanoseconds)
+                }),
+        )
+    }
+}
+
+impl Arbitrary for Time {
+    fn arbitrary(g: &mut Gen) -> Self {
+        Self::from_hms_nanos_ranged(
+            <_>::arbitrary(g),
+            <_>::arbitrary(g),
+            <_>::arbitrary(g),
+            <_>::arbitrary(g),
+        )
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        Box::new(
+            self.as_hms_nano_ranged()
+                .shrink()
+                .map(|(hour, minute, second, nanosecond)| {
+                    Self::from_hms_nanos_ranged(hour, minute, second, nanosecond)
+                }),
+        )
+    }
+}
+
+impl Arbitrary for PrimitiveDateTime {
+    fn arbitrary(g: &mut Gen) -> Self {
+        Self::new(<_>::arbitrary(g), <_>::arbitrary(g))
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        Box::new(
+            (self.date(), self.time())
+                .shrink()
+                .map(|(date, time)| Self::new(date, time)),
+        )
+    }
+}
+
+impl Arbitrary for UtcOffset {
+    fn arbitrary(g: &mut Gen) -> Self {
+        Self::from_hms_ranged(<_>::arbitrary(g), <_>::arbitrary(g), <_>::arbitrary(g))
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        Box::new(
+            self.as_hms_ranged()
+                .shrink()
+                .map(|(hours, minutes, seconds)| Self::from_hms_ranged(hours, minutes, seconds)),
+        )
+    }
+}
+
+impl Arbitrary for OffsetDateTime {
+    fn arbitrary(g: &mut Gen) -> Self {
+        Self::new_in_offset(<_>::arbitrary(g), <_>::arbitrary(g), <_>::arbitrary(g))
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        Box::new(
+            (self.date(), self.time(), self.offset())
+                .shrink()
+                .map(|(date, time, offset)| Self::new_in_offset(date, time, offset)),
+        )
+    }
+}
+
+impl Arbitrary for Weekday {
+    fn arbitrary(g: &mut Gen) -> Self {
+        use Weekday::*;
+        match arbitrary_between!(u8; g, 0, 6) {
+            0 => Monday,
+            1 => Tuesday,
+            2 => Wednesday,
+            3 => Thursday,
+            4 => Friday,
+            5 => Saturday,
+            val => {
+                debug_assert!(val == 6);
+                Sunday
+            }
+        }
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        match self {
+            Self::Monday => empty_shrinker(),
+            _ => single_shrinker(self.previous()),
+        }
+    }
+}
+
+impl Arbitrary for Month {
+    fn arbitrary(g: &mut Gen) -> Self {
+        use Month::*;
+        match arbitrary_between!(u8; g, 1, 12) {
+            1 => January,
+            2 => February,
+            3 => March,
+            4 => April,
+            5 => May,
+            6 => June,
+            7 => July,
+            8 => August,
+            9 => September,
+            10 => October,
+            11 => November,
+            val => {
+                debug_assert!(val == 12);
+                December
+            }
+        }
+    }
+
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+        match self {
+            Self::January => empty_shrinker(),
+            _ => single_shrinker(self.previous()),
+        }
+    }
+}
diff --git a/time/src/rand.rs b/time/src/rand.rs
new file mode 100644
index 000000000..7f7627b97
--- /dev/null
+++ b/time/src/rand.rs
@@ -0,0 +1,87 @@
+//! Implementation of [`Distribution`] for various structs.
+
+use rand::distributions::{Distribution, Standard};
+use rand::Rng;
+
+use crate::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+impl Distribution<Time> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Time {
+        Time::from_hms_nanos_ranged(rng.r#gen(), rng.r#gen(), rng.r#gen(), rng.r#gen())
+    }
+}
+
+impl Distribution<Date> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Date {
+        Date::from_julian_day_unchecked(
+            rng.gen_range(Date::MIN.to_julian_day()..=Date::MAX.to_julian_day()),
+        )
+    }
+}
+
+impl Distribution<UtcOffset> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> UtcOffset {
+        UtcOffset::from_hms_ranged(rng.r#gen(), rng.r#gen(), rng.r#gen())
+    }
+}
+
+impl Distribution<PrimitiveDateTime> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> PrimitiveDateTime {
+        PrimitiveDateTime::new(Self.sample(rng), Self.sample(rng))
+    }
+}
+
+impl Distribution<OffsetDateTime> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> OffsetDateTime {
+        let date_time: PrimitiveDateTime = Self.sample(rng);
+        date_time.assume_offset(Self.sample(rng))
+    }
+}
+
+impl Distribution<Duration> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Duration {
+        Duration::new_ranged(rng.r#gen(), rng.r#gen())
+    }
+}
+
+impl Distribution<Weekday> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Weekday {
+        use Weekday::*;
+
+        match rng.gen_range(0u8..7) {
+            0 => Monday,
+            1 => Tuesday,
+            2 => Wednesday,
+            3 => Thursday,
+            4 => Friday,
+            5 => Saturday,
+            val => {
+                debug_assert!(val == 6);
+                Sunday
+            }
+        }
+    }
+}
+
+impl Distribution<Month> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Month {
+        use Month::*;
+        match rng.gen_range(1u8..=12) {
+            1 => January,
+            2 => February,
+            3 => March,
+            4 => April,
+            5 => May,
+            6 => June,
+            7 => July,
+            8 => August,
+            9 => September,
+            10 => October,
+            11 => November,
+            val => {
+                debug_assert!(val == 12);
+                December
+            }
+        }
+    }
+}
diff --git a/time/src/serde/iso8601.rs b/time/src/serde/iso8601.rs
new file mode 100644
index 000000000..f9e8a20f1
--- /dev/null
+++ b/time/src/serde/iso8601.rs
@@ -0,0 +1,77 @@
+//! Use the well-known [ISO 8601 format] when serializing and deserializing an [`OffsetDateTime`].
+//!
+//! Use this module in combination with serde's [`#[with]`][with] attribute.
+//!
+//! [ISO 8601 format]: https://www.iso.org/iso-8601-date-and-time-format.html
+//! [with]: https://serde.rs/field-attrs.html#with
+
+#[cfg(feature = "parsing")]
+use core::marker::PhantomData;
+
+#[cfg(feature = "formatting")]
+use serde::ser::Error as _;
+#[cfg(feature = "parsing")]
+use serde::Deserializer;
+#[cfg(feature = "formatting")]
+use serde::{Serialize, Serializer};
+
+#[cfg(feature = "parsing")]
+use super::Visitor;
+use crate::format_description::well_known::iso8601::{Config, EncodedConfig};
+use crate::format_description::well_known::Iso8601;
+use crate::OffsetDateTime;
+
+/// The configuration of ISO 8601 used for serde implementations.
+pub(crate) const SERDE_CONFIG: EncodedConfig =
+    Config::DEFAULT.set_year_is_six_digits(true).encode();
+
+/// Serialize an [`OffsetDateTime`] using the well-known ISO 8601 format.
+#[cfg(feature = "formatting")]
+pub fn serialize<S: Serializer>(
+    datetime: &OffsetDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    datetime
+        .format(&Iso8601::<SERDE_CONFIG>)
+        .map_err(S::Error::custom)?
+        .serialize(serializer)
+}
+
+/// Deserialize an [`OffsetDateTime`] from its ISO 8601 representation.
+#[cfg(feature = "parsing")]
+pub fn deserialize<'a, D: Deserializer<'a>>(deserializer: D) -> Result<OffsetDateTime, D::Error> {
+    deserializer.deserialize_str(Visitor::<Iso8601<SERDE_CONFIG>>(PhantomData))
+}
+
+/// Use the well-known ISO 8601 format when serializing and deserializing an
+/// [`Option<OffsetDateTime>`].
+///
+/// Use this module in combination with serde's [`#[with]`][with] attribute.
+///
+/// [ISO 8601 format]: https://www.iso.org/iso-8601-date-and-time-format.html
+/// [with]: https://serde.rs/field-attrs.html#with
+pub mod option {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Serialize an [`Option<OffsetDateTime>`] using the well-known ISO 8601 format.
+    #[cfg(feature = "formatting")]
+    pub fn serialize<S: Serializer>(
+        option: &Option<OffsetDateTime>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        option
+            .map(|odt| odt.format(&Iso8601::<SERDE_CONFIG>))
+            .transpose()
+            .map_err(S::Error::custom)?
+            .serialize(serializer)
+    }
+
+    /// Deserialize an [`Option<OffsetDateTime>`] from its ISO 8601 representation.
+    #[cfg(feature = "parsing")]
+    pub fn deserialize<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        deserializer.deserialize_option(Visitor::<Option<Iso8601<SERDE_CONFIG>>>(PhantomData))
+    }
+}
diff --git a/time/src/serde/mod.rs b/time/src/serde/mod.rs
new file mode 100644
index 000000000..5cc5122c9
--- /dev/null
+++ b/time/src/serde/mod.rs
@@ -0,0 +1,510 @@
+//! Differential formats for serde.
+// This also includes the serde implementations for all types. This doesn't need to be externally
+// documented, though.
+
+// Types with guaranteed stable serde representations. Strings are avoided to allow for optimal
+// representations in various binary forms.
+
+/// Consume the next item in a sequence.
+macro_rules! item {
+    ($seq:expr, $name:literal) => {
+        $seq.next_element()?
+            .ok_or_else(|| <A::Error as serde::de::Error>::custom(concat!("expected ", $name)))
+    };
+}
+
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+pub mod iso8601;
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+pub mod rfc2822;
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+pub mod rfc3339;
+pub mod timestamp;
+mod visitor;
+
+#[cfg(feature = "serde-human-readable")]
+use alloc::string::ToString;
+use core::marker::PhantomData;
+
+#[cfg(feature = "serde-human-readable")]
+use serde::ser::Error as _;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+/// Generate a custom serializer and deserializer from a format string or an existing format.
+///
+/// The syntax accepted by this macro is the same as [`format_description::parse()`], which can
+/// be found in [the book](https://time-rs.github.io/book/api/format-description.html).
+///
+/// # Usage
+///
+/// Invoked as `serde::format_description!(mod_name, Date, FORMAT)` where `FORMAT` is either a
+/// `"<format string>"` or something that implements
+#[cfg_attr(
+    all(feature = "formatting", feature = "parsing"),
+    doc = "[`Formattable`](crate::formatting::Formattable) and \
+           [`Parsable`](crate::parsing::Parsable)."
+)]
+#[cfg_attr(
+    all(feature = "formatting", not(feature = "parsing")),
+    doc = "[`Formattable`](crate::formatting::Formattable)."
+)]
+#[cfg_attr(
+    all(not(feature = "formatting"), feature = "parsing"),
+    doc = "[`Parsable`](crate::parsing::Parsable)."
+)]
+/// This puts a module named `mod_name` in the current scope that can be used to format `Date`
+/// structs. A submodule (`mod_name::option`) is also generated for `Option<Date>`. Both
+/// modules are only visible in the current scope.
+///
+/// The returned `Option` will contain a deserialized value if present and `None` if the field
+/// is present but the value is `null` (or the equivalent in other formats). To return `None`
+/// when the field is not present, you should use `#[serde(default)]` on the field.
+///
+/// # Examples
+///
+/// Using a format string:
+///
+/// ```rust,no_run
+/// # use time::OffsetDateTime;
+#[cfg_attr(
+    all(feature = "formatting", feature = "parsing"),
+    doc = "use ::serde::{Serialize, Deserialize};"
+)]
+#[cfg_attr(
+    all(feature = "formatting", not(feature = "parsing")),
+    doc = "use ::serde::Serialize;"
+)]
+#[cfg_attr(
+    all(not(feature = "formatting"), feature = "parsing"),
+    doc = "use ::serde::Deserialize;"
+)]
+/// use time::serde;
+///
+/// // Makes a module `mod my_format { ... }`.
+/// serde::format_description!(my_format, OffsetDateTime, "hour=[hour], minute=[minute]");
+///
+/// # #[allow(dead_code)]
+#[cfg_attr(
+    all(feature = "formatting", feature = "parsing"),
+    doc = "#[derive(Serialize, Deserialize)]"
+)]
+#[cfg_attr(
+    all(feature = "formatting", not(feature = "parsing")),
+    doc = "#[derive(Serialize)]"
+)]
+#[cfg_attr(
+    all(not(feature = "formatting"), feature = "parsing"),
+    doc = "#[derive(Deserialize)]"
+)]
+/// struct SerializesWithCustom {
+///     #[serde(with = "my_format")]
+///     dt: OffsetDateTime,
+///     #[serde(with = "my_format::option")]
+///     maybe_dt: Option<OffsetDateTime>,
+/// }
+/// ```
+/// 
+/// Define the format separately to be used in multiple places:
+/// ```rust,no_run
+/// # use time::OffsetDateTime;
+#[cfg_attr(
+    all(feature = "formatting", feature = "parsing"),
+    doc = "use ::serde::{Serialize, Deserialize};"
+)]
+#[cfg_attr(
+    all(feature = "formatting", not(feature = "parsing")),
+    doc = "use ::serde::Serialize;"
+)]
+#[cfg_attr(
+    all(not(feature = "formatting"), feature = "parsing"),
+    doc = "use ::serde::Deserialize;"
+)]
+/// use time::serde;
+/// use time::format_description::BorrowedFormatItem;
+///
+/// const DATE_TIME_FORMAT: &[BorrowedFormatItem<'_>] = time::macros::format_description!(
+///     "hour=[hour], minute=[minute]"
+/// );
+///
+/// // Makes a module `mod my_format { ... }`.
+/// serde::format_description!(my_format, OffsetDateTime, DATE_TIME_FORMAT);
+///
+/// # #[allow(dead_code)]
+#[cfg_attr(
+    all(feature = "formatting", feature = "parsing"),
+    doc = "#[derive(Serialize, Deserialize)]"
+)]
+#[cfg_attr(
+    all(feature = "formatting", not(feature = "parsing")),
+    doc = "#[derive(Serialize)]"
+)]
+#[cfg_attr(
+    all(not(feature = "formatting"), feature = "parsing"),
+    doc = "#[derive(Deserialize)]"
+)]
+/// struct SerializesWithCustom {
+///     #[serde(with = "my_format")]
+///     dt: OffsetDateTime,
+///     #[serde(with = "my_format::option")]
+///     maybe_dt: Option<OffsetDateTime>,
+/// }
+///
+/// fn main() {
+///     # #[allow(unused_variables)]
+///     let str_ts = OffsetDateTime::now_utc().format(DATE_TIME_FORMAT).unwrap();
+/// }
+/// ```
+/// 
+/// Customize the configuration of ISO 8601 formatting/parsing:
+/// ```rust,no_run
+/// # use time::OffsetDateTime;
+#[cfg_attr(
+    all(feature = "formatting", feature = "parsing"),
+    doc = "use ::serde::{Serialize, Deserialize};"
+)]
+#[cfg_attr(
+    all(feature = "formatting", not(feature = "parsing")),
+    doc = "use ::serde::Serialize;"
+)]
+#[cfg_attr(
+    all(not(feature = "formatting"), feature = "parsing"),
+    doc = "use ::serde::Deserialize;"
+)]
+/// use time::serde;
+/// use time::format_description::well_known::{iso8601, Iso8601};
+///
+/// # #[allow(dead_code)]
+/// const CONFIG: iso8601::EncodedConfig = iso8601::Config::DEFAULT
+///     .set_year_is_six_digits(false)
+///     .encode();
+/// # #[allow(dead_code)]
+/// const FORMAT: Iso8601<CONFIG> = Iso8601::<CONFIG>;
+///
+/// // Makes a module `mod my_format { ... }`.
+/// serde::format_description!(my_format, OffsetDateTime, FORMAT);
+///
+/// # #[allow(dead_code)]
+#[cfg_attr(
+    all(feature = "formatting", feature = "parsing"),
+    doc = "#[derive(Serialize, Deserialize)]"
+)]
+#[cfg_attr(
+    all(feature = "formatting", not(feature = "parsing")),
+    doc = "#[derive(Serialize)]"
+)]
+#[cfg_attr(
+    all(not(feature = "formatting"), feature = "parsing"),
+    doc = "#[derive(Deserialize)]"
+)]
+/// struct SerializesWithCustom {
+///     #[serde(with = "my_format")]
+///     dt: OffsetDateTime,
+///     #[serde(with = "my_format::option")]
+///     maybe_dt: Option<OffsetDateTime>,
+/// }
+/// # fn main() {}
+/// ```
+/// 
+/// [`format_description::parse()`]: crate::format_description::parse()
+#[cfg(all(feature = "macros", any(feature = "formatting", feature = "parsing"),))]
+pub use time_macros::serde_format_description as format_description;
+
+use self::visitor::Visitor;
+#[cfg(feature = "parsing")]
+use crate::format_description::{modifier, BorrowedFormatItem, Component};
+use crate::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+// region: Date
+/// The format used when serializing and deserializing a human-readable `Date`.
+#[cfg(feature = "parsing")]
+const DATE_FORMAT: &[BorrowedFormatItem<'_>] = &[
+    BorrowedFormatItem::Component(Component::Year(modifier::Year::default())),
+    BorrowedFormatItem::Literal(b"-"),
+    BorrowedFormatItem::Component(Component::Month(modifier::Month::default())),
+    BorrowedFormatItem::Literal(b"-"),
+    BorrowedFormatItem::Component(Component::Day(modifier::Day::default())),
+];
+
+impl Serialize for Date {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            let Ok(s) = self.format(&DATE_FORMAT) else {
+                return Err(S::Error::custom("failed formatting `Date`"));
+            };
+            return serializer.serialize_str(&s);
+        }
+
+        (self.year(), self.ordinal()).serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for Date {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_tuple(2, Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion date
+
+// region: Duration
+impl Serialize for Duration {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            return serializer.collect_str(&format_args!(
+                "{}.{:>09}",
+                self.whole_seconds(),
+                self.subsec_nanoseconds().abs()
+            ));
+        }
+
+        (self.whole_seconds(), self.subsec_nanoseconds()).serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for Duration {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_tuple(2, Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion Duration
+
+// region: OffsetDateTime
+/// The format used when serializing and deserializing a human-readable `OffsetDateTime`.
+#[cfg(feature = "parsing")]
+const OFFSET_DATE_TIME_FORMAT: &[BorrowedFormatItem<'_>] = &[
+    BorrowedFormatItem::Compound(DATE_FORMAT),
+    BorrowedFormatItem::Literal(b" "),
+    BorrowedFormatItem::Compound(TIME_FORMAT),
+    BorrowedFormatItem::Literal(b" "),
+    BorrowedFormatItem::Compound(UTC_OFFSET_FORMAT),
+];
+
+impl Serialize for OffsetDateTime {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            let Ok(s) = self.format(&OFFSET_DATE_TIME_FORMAT) else {
+                return Err(S::Error::custom("failed formatting `OffsetDateTime`"));
+            };
+            return serializer.serialize_str(&s);
+        }
+
+        (
+            self.year(),
+            self.ordinal(),
+            self.hour(),
+            self.minute(),
+            self.second(),
+            self.nanosecond(),
+            self.offset().whole_hours(),
+            self.offset().minutes_past_hour(),
+            self.offset().seconds_past_minute(),
+        )
+            .serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for OffsetDateTime {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_tuple(9, Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion OffsetDateTime
+
+// region: PrimitiveDateTime
+/// The format used when serializing and deserializing a human-readable `PrimitiveDateTime`.
+#[cfg(feature = "parsing")]
+const PRIMITIVE_DATE_TIME_FORMAT: &[BorrowedFormatItem<'_>] = &[
+    BorrowedFormatItem::Compound(DATE_FORMAT),
+    BorrowedFormatItem::Literal(b" "),
+    BorrowedFormatItem::Compound(TIME_FORMAT),
+];
+
+impl Serialize for PrimitiveDateTime {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            let Ok(s) = self.format(&PRIMITIVE_DATE_TIME_FORMAT) else {
+                return Err(S::Error::custom("failed formatting `PrimitiveDateTime`"));
+            };
+            return serializer.serialize_str(&s);
+        }
+
+        (
+            self.year(),
+            self.ordinal(),
+            self.hour(),
+            self.minute(),
+            self.second(),
+            self.nanosecond(),
+        )
+            .serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for PrimitiveDateTime {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_tuple(6, Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion PrimitiveDateTime
+
+// region: Time
+/// The format used when serializing and deserializing a human-readable `Time`.
+#[cfg(feature = "parsing")]
+const TIME_FORMAT: &[BorrowedFormatItem<'_>] = &[
+    BorrowedFormatItem::Component(Component::Hour(modifier::Hour::default())),
+    BorrowedFormatItem::Literal(b":"),
+    BorrowedFormatItem::Component(Component::Minute(modifier::Minute::default())),
+    BorrowedFormatItem::Literal(b":"),
+    BorrowedFormatItem::Component(Component::Second(modifier::Second::default())),
+    BorrowedFormatItem::Literal(b"."),
+    BorrowedFormatItem::Component(Component::Subsecond(modifier::Subsecond::default())),
+];
+
+impl Serialize for Time {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            let Ok(s) = self.format(&TIME_FORMAT) else {
+                return Err(S::Error::custom("failed formatting `Time`"));
+            };
+            return serializer.serialize_str(&s);
+        }
+
+        (self.hour(), self.minute(), self.second(), self.nanosecond()).serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for Time {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_tuple(4, Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion Time
+
+// region: UtcOffset
+// FIXME: turn these constants into `const { ... }` blocks once we can depend on Rust 1.79.
+#[cfg(feature = "parsing")]
+const UTC_OFFSET_HOUR: modifier::OffsetHour = {
+    let mut m = modifier::OffsetHour::default();
+    m.sign_is_mandatory = true;
+    m
+};
+#[cfg(feature = "parsing")]
+const UTC_OFFSET_MINUTE: modifier::OffsetMinute = modifier::OffsetMinute::default();
+#[cfg(feature = "parsing")]
+const UTC_OFFSET_SECOND: modifier::OffsetSecond = modifier::OffsetSecond::default();
+/// The format used when serializing and deserializing a human-readable `UtcOffset`.
+#[cfg(feature = "parsing")]
+const UTC_OFFSET_FORMAT: &[BorrowedFormatItem<'_>] = &[
+    BorrowedFormatItem::Component(Component::OffsetHour(UTC_OFFSET_HOUR)),
+    BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(&[
+        BorrowedFormatItem::Literal(b":"),
+        BorrowedFormatItem::Component(Component::OffsetMinute(UTC_OFFSET_MINUTE)),
+        BorrowedFormatItem::Optional(&BorrowedFormatItem::Compound(&[
+            BorrowedFormatItem::Literal(b":"),
+            BorrowedFormatItem::Component(Component::OffsetSecond(UTC_OFFSET_SECOND)),
+        ])),
+    ])),
+];
+
+impl Serialize for UtcOffset {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            let Ok(s) = self.format(&UTC_OFFSET_FORMAT) else {
+                return Err(S::Error::custom("failed formatting `UtcOffset`"));
+            };
+            return serializer.serialize_str(&s);
+        }
+
+        (
+            self.whole_hours(),
+            self.minutes_past_hour(),
+            self.seconds_past_minute(),
+        )
+            .serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for UtcOffset {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_tuple(3, Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion UtcOffset
+
+// region: Weekday
+impl Serialize for Weekday {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            #[cfg(not(feature = "std"))]
+            use alloc::string::ToString;
+            return self.to_string().serialize(serializer);
+        }
+
+        self.number_from_monday().serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for Weekday {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_u8(Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion Weekday
+
+// region: Month
+impl Serialize for Month {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        #[cfg(feature = "serde-human-readable")]
+        if serializer.is_human_readable() {
+            #[cfg(not(feature = "std"))]
+            use alloc::string::String;
+            return self.to_string().serialize(serializer);
+        }
+
+        u8::from(*self).serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for Month {
+    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
+        if cfg!(feature = "serde-human-readable") && deserializer.is_human_readable() {
+            deserializer.deserialize_any(Visitor::<Self>(PhantomData))
+        } else {
+            deserializer.deserialize_u8(Visitor::<Self>(PhantomData))
+        }
+    }
+}
+// endregion Month
diff --git a/time/src/serde/rfc2822.rs b/time/src/serde/rfc2822.rs
new file mode 100644
index 000000000..eca90f520
--- /dev/null
+++ b/time/src/serde/rfc2822.rs
@@ -0,0 +1,72 @@
+//! Use the well-known [RFC2822 format] when serializing and deserializing an [`OffsetDateTime`].
+//!
+//! Use this module in combination with serde's [`#[with]`][with] attribute.
+//!
+//! [RFC2822 format]: https://tools.ietf.org/html/rfc2822#section-3.3
+//! [with]: https://serde.rs/field-attrs.html#with
+
+#[cfg(feature = "parsing")]
+use core::marker::PhantomData;
+
+#[cfg(feature = "formatting")]
+use serde::ser::Error as _;
+#[cfg(feature = "parsing")]
+use serde::Deserializer;
+#[cfg(feature = "formatting")]
+use serde::{Serialize, Serializer};
+
+#[cfg(feature = "parsing")]
+use super::Visitor;
+use crate::format_description::well_known::Rfc2822;
+use crate::OffsetDateTime;
+
+/// Serialize an [`OffsetDateTime`] using the well-known RFC2822 format.
+#[cfg(feature = "formatting")]
+pub fn serialize<S: Serializer>(
+    datetime: &OffsetDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    datetime
+        .format(&Rfc2822)
+        .map_err(S::Error::custom)?
+        .serialize(serializer)
+}
+
+/// Deserialize an [`OffsetDateTime`] from its RFC2822 representation.
+#[cfg(feature = "parsing")]
+pub fn deserialize<'a, D: Deserializer<'a>>(deserializer: D) -> Result<OffsetDateTime, D::Error> {
+    deserializer.deserialize_str(Visitor::<Rfc2822>(PhantomData))
+}
+
+/// Use the well-known [RFC2822 format] when serializing and deserializing an
+/// [`Option<OffsetDateTime>`].
+///
+/// Use this module in combination with serde's [`#[with]`][with] attribute.
+///
+/// [RFC2822 format]: https://tools.ietf.org/html/rfc2822#section-3.3
+/// [with]: https://serde.rs/field-attrs.html#with
+pub mod option {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Serialize an [`Option<OffsetDateTime>`] using the well-known RFC2822 format.
+    #[cfg(feature = "formatting")]
+    pub fn serialize<S: Serializer>(
+        option: &Option<OffsetDateTime>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        option
+            .map(|odt| odt.format(&Rfc2822))
+            .transpose()
+            .map_err(S::Error::custom)?
+            .serialize(serializer)
+    }
+
+    /// Deserialize an [`Option<OffsetDateTime>`] from its RFC2822 representation.
+    #[cfg(feature = "parsing")]
+    pub fn deserialize<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        deserializer.deserialize_option(Visitor::<Option<Rfc2822>>(PhantomData))
+    }
+}
diff --git a/time/src/serde/rfc3339.rs b/time/src/serde/rfc3339.rs
new file mode 100644
index 000000000..b1ffb2513
--- /dev/null
+++ b/time/src/serde/rfc3339.rs
@@ -0,0 +1,72 @@
+//! Use the well-known [RFC3339 format] when serializing and deserializing an [`OffsetDateTime`].
+//!
+//! Use this module in combination with serde's [`#[with]`][with] attribute.
+//!
+//! [RFC3339 format]: https://tools.ietf.org/html/rfc3339#section-5.6
+//! [with]: https://serde.rs/field-attrs.html#with
+
+#[cfg(feature = "parsing")]
+use core::marker::PhantomData;
+
+#[cfg(feature = "formatting")]
+use serde::ser::Error as _;
+#[cfg(feature = "parsing")]
+use serde::Deserializer;
+#[cfg(feature = "formatting")]
+use serde::{Serialize, Serializer};
+
+#[cfg(feature = "parsing")]
+use super::Visitor;
+use crate::format_description::well_known::Rfc3339;
+use crate::OffsetDateTime;
+
+/// Serialize an [`OffsetDateTime`] using the well-known RFC3339 format.
+#[cfg(feature = "formatting")]
+pub fn serialize<S: Serializer>(
+    datetime: &OffsetDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    datetime
+        .format(&Rfc3339)
+        .map_err(S::Error::custom)?
+        .serialize(serializer)
+}
+
+/// Deserialize an [`OffsetDateTime`] from its RFC3339 representation.
+#[cfg(feature = "parsing")]
+pub fn deserialize<'a, D: Deserializer<'a>>(deserializer: D) -> Result<OffsetDateTime, D::Error> {
+    deserializer.deserialize_str(Visitor::<Rfc3339>(PhantomData))
+}
+
+/// Use the well-known [RFC3339 format] when serializing and deserializing an
+/// [`Option<OffsetDateTime>`].
+///
+/// Use this module in combination with serde's [`#[with]`][with] attribute.
+///
+/// [RFC3339 format]: https://tools.ietf.org/html/rfc3339#section-5.6
+/// [with]: https://serde.rs/field-attrs.html#with
+pub mod option {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Serialize an [`Option<OffsetDateTime>`] using the well-known RFC3339 format.
+    #[cfg(feature = "formatting")]
+    pub fn serialize<S: Serializer>(
+        option: &Option<OffsetDateTime>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        option
+            .map(|odt| odt.format(&Rfc3339))
+            .transpose()
+            .map_err(S::Error::custom)?
+            .serialize(serializer)
+    }
+
+    /// Deserialize an [`Option<OffsetDateTime>`] from its RFC3339 representation.
+    #[cfg(feature = "parsing")]
+    pub fn deserialize<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        deserializer.deserialize_option(Visitor::<Option<Rfc3339>>(PhantomData))
+    }
+}
diff --git a/time/src/serde/timestamp/microseconds.rs b/time/src/serde/timestamp/microseconds.rs
new file mode 100644
index 000000000..65c603ec3
--- /dev/null
+++ b/time/src/serde/timestamp/microseconds.rs
@@ -0,0 +1,63 @@
+//! Treat an [`OffsetDateTime`] as a [Unix timestamp] with microseconds for
+//! the purposes of serde.
+//!
+//! Use this module in combination with serde's [`#[with]`][with] attribute.
+//!
+//! When deserializing, the offset is assumed to be UTC.
+//!
+//! [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+//! [with]: https://serde.rs/field-attrs.html#with
+
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::OffsetDateTime;
+
+/// Serialize an `OffsetDateTime` as its Unix timestamp with microseconds
+pub fn serialize<S: Serializer>(
+    datetime: &OffsetDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    let timestamp = datetime.unix_timestamp_nanos() / 1_000;
+    timestamp.serialize(serializer)
+}
+
+/// Deserialize an `OffsetDateTime` from its Unix timestamp with microseconds
+pub fn deserialize<'a, D: Deserializer<'a>>(deserializer: D) -> Result<OffsetDateTime, D::Error> {
+    let value: i128 = <_>::deserialize(deserializer)?;
+    OffsetDateTime::from_unix_timestamp_nanos(value * 1_000)
+        .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+}
+
+/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] with microseconds
+/// for the purposes of serde.
+///
+/// Use this module in combination with serde's [`#[with]`][with] attribute.
+///
+/// When deserializing, the offset is assumed to be UTC.
+///
+/// [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+/// [with]: https://serde.rs/field-attrs.html#with
+pub mod option {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Serialize an `Option<OffsetDateTime>` as its Unix timestamp with microseconds
+    pub fn serialize<S: Serializer>(
+        option: &Option<OffsetDateTime>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        option
+            .map(|timestamp| timestamp.unix_timestamp_nanos() / 1_000)
+            .serialize(serializer)
+    }
+
+    /// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp with microseconds
+    pub fn deserialize<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        Option::deserialize(deserializer)?
+            .map(|value: i128| OffsetDateTime::from_unix_timestamp_nanos(value * 1_000))
+            .transpose()
+            .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+    }
+}
diff --git a/time/src/serde/timestamp/milliseconds.rs b/time/src/serde/timestamp/milliseconds.rs
new file mode 100644
index 000000000..e571b6c9e
--- /dev/null
+++ b/time/src/serde/timestamp/milliseconds.rs
@@ -0,0 +1,63 @@
+//! Treat an [`OffsetDateTime`] as a [Unix timestamp] with milliseconds for
+//! the purposes of serde.
+//!
+//! Use this module in combination with serde's [`#[with]`][with] attribute.
+//!
+//! When deserializing, the offset is assumed to be UTC.
+//!
+//! [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+//! [with]: https://serde.rs/field-attrs.html#with
+
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::OffsetDateTime;
+
+/// Serialize an `OffsetDateTime` as its Unix timestamp with milliseconds
+pub fn serialize<S: Serializer>(
+    datetime: &OffsetDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    let timestamp = datetime.unix_timestamp_nanos() / 1_000_000;
+    timestamp.serialize(serializer)
+}
+
+/// Deserialize an `OffsetDateTime` from its Unix timestamp with milliseconds
+pub fn deserialize<'a, D: Deserializer<'a>>(deserializer: D) -> Result<OffsetDateTime, D::Error> {
+    let value: i128 = <_>::deserialize(deserializer)?;
+    OffsetDateTime::from_unix_timestamp_nanos(value * 1_000_000)
+        .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+}
+
+/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] with milliseconds
+/// for the purposes of serde.
+///
+/// Use this module in combination with serde's [`#[with]`][with] attribute.
+///
+/// When deserializing, the offset is assumed to be UTC.
+///
+/// [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+/// [with]: https://serde.rs/field-attrs.html#with
+pub mod option {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Serialize an `Option<OffsetDateTime>` as its Unix timestamp with milliseconds
+    pub fn serialize<S: Serializer>(
+        option: &Option<OffsetDateTime>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        option
+            .map(|timestamp| timestamp.unix_timestamp_nanos() / 1_000_000)
+            .serialize(serializer)
+    }
+
+    /// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp with milliseconds
+    pub fn deserialize<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        Option::deserialize(deserializer)?
+            .map(|value: i128| OffsetDateTime::from_unix_timestamp_nanos(value * 1_000_000))
+            .transpose()
+            .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+    }
+}
diff --git a/time/src/serde/timestamp/mod.rs b/time/src/serde/timestamp/mod.rs
new file mode 100644
index 000000000..6dd0db03c
--- /dev/null
+++ b/time/src/serde/timestamp/mod.rs
@@ -0,0 +1,64 @@
+//! Treat an [`OffsetDateTime`] as a [Unix timestamp] for the purposes of serde.
+//!
+//! Use this module in combination with serde's [`#[with]`][with] attribute.
+//!
+//! When deserializing, the offset is assumed to be UTC.
+//!
+//! [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+//! [with]: https://serde.rs/field-attrs.html#with
+
+pub mod microseconds;
+pub mod milliseconds;
+pub mod nanoseconds;
+
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::OffsetDateTime;
+
+/// Serialize an `OffsetDateTime` as its Unix timestamp
+pub fn serialize<S: Serializer>(
+    datetime: &OffsetDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    datetime.unix_timestamp().serialize(serializer)
+}
+
+/// Deserialize an `OffsetDateTime` from its Unix timestamp
+pub fn deserialize<'a, D: Deserializer<'a>>(deserializer: D) -> Result<OffsetDateTime, D::Error> {
+    OffsetDateTime::from_unix_timestamp(<_>::deserialize(deserializer)?)
+        .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+}
+
+/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] for the purposes of
+/// serde.
+///
+/// Use this module in combination with serde's [`#[with]`][with] attribute.
+///
+/// When deserializing, the offset is assumed to be UTC.
+///
+/// [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+/// [with]: https://serde.rs/field-attrs.html#with
+pub mod option {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Serialize an `Option<OffsetDateTime>` as its Unix timestamp
+    pub fn serialize<S: Serializer>(
+        option: &Option<OffsetDateTime>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        option
+            .map(OffsetDateTime::unix_timestamp)
+            .serialize(serializer)
+    }
+
+    /// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp
+    pub fn deserialize<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        Option::deserialize(deserializer)?
+            .map(OffsetDateTime::from_unix_timestamp)
+            .transpose()
+            .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+    }
+}
diff --git a/time/src/serde/timestamp/nanoseconds.rs b/time/src/serde/timestamp/nanoseconds.rs
new file mode 100644
index 000000000..c71d1e7cd
--- /dev/null
+++ b/time/src/serde/timestamp/nanoseconds.rs
@@ -0,0 +1,61 @@
+//! Treat an [`OffsetDateTime`] as a [Unix timestamp] with nanoseconds for
+//! the purposes of serde.
+//!
+//! Use this module in combination with serde's [`#[with]`][with] attribute.
+//!
+//! When deserializing, the offset is assumed to be UTC.
+//!
+//! [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+//! [with]: https://serde.rs/field-attrs.html#with
+
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::OffsetDateTime;
+
+/// Serialize an `OffsetDateTime` as its Unix timestamp with nanoseconds
+pub fn serialize<S: Serializer>(
+    datetime: &OffsetDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    datetime.unix_timestamp_nanos().serialize(serializer)
+}
+
+/// Deserialize an `OffsetDateTime` from its Unix timestamp with nanoseconds
+pub fn deserialize<'a, D: Deserializer<'a>>(deserializer: D) -> Result<OffsetDateTime, D::Error> {
+    OffsetDateTime::from_unix_timestamp_nanos(<_>::deserialize(deserializer)?)
+        .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+}
+
+/// Treat an `Option<OffsetDateTime>` as a [Unix timestamp] with nanoseconds
+/// for the purposes of serde.
+///
+/// Use this module in combination with serde's [`#[with]`][with] attribute.
+///
+/// When deserializing, the offset is assumed to be UTC.
+///
+/// [Unix timestamp]: https://en.wikipedia.org/wiki/Unix_time
+/// [with]: https://serde.rs/field-attrs.html#with
+pub mod option {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    /// Serialize an `Option<OffsetDateTime>` as its Unix timestamp with nanoseconds
+    pub fn serialize<S: Serializer>(
+        option: &Option<OffsetDateTime>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        option
+            .map(OffsetDateTime::unix_timestamp_nanos)
+            .serialize(serializer)
+    }
+
+    /// Deserialize an `Option<OffsetDateTime>` from its Unix timestamp with nanoseconds
+    pub fn deserialize<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        Option::deserialize(deserializer)?
+            .map(OffsetDateTime::from_unix_timestamp_nanos)
+            .transpose()
+            .map_err(|err| de::Error::invalid_value(de::Unexpected::Signed(err.value), &err))
+    }
+}
diff --git a/time/src/serde/visitor.rs b/time/src/serde/visitor.rs
new file mode 100644
index 000000000..3a4311ecb
--- /dev/null
+++ b/time/src/serde/visitor.rs
@@ -0,0 +1,323 @@
+//! Serde visitor for various types.
+
+use core::fmt;
+use core::marker::PhantomData;
+
+use serde::de;
+#[cfg(feature = "parsing")]
+use serde::Deserializer;
+
+#[cfg(feature = "parsing")]
+use super::{
+    DATE_FORMAT, OFFSET_DATE_TIME_FORMAT, PRIMITIVE_DATE_TIME_FORMAT, TIME_FORMAT,
+    UTC_OFFSET_FORMAT,
+};
+use crate::error::ComponentRange;
+#[cfg(feature = "parsing")]
+use crate::format_description::well_known::*;
+use crate::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+/// A serde visitor for various types.
+pub(super) struct Visitor<T: ?Sized>(pub(super) PhantomData<T>);
+
+impl<'a> de::Visitor<'a> for Visitor<Date> {
+    type Value = Date;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a `Date`")
+    }
+
+    #[cfg(feature = "parsing")]
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<Date, E> {
+        Date::parse(value, &DATE_FORMAT).map_err(E::custom)
+    }
+
+    fn visit_seq<A: de::SeqAccess<'a>>(self, mut seq: A) -> Result<Date, A::Error> {
+        let year = item!(seq, "year")?;
+        let ordinal = item!(seq, "day of year")?;
+        Date::from_ordinal_date(year, ordinal).map_err(ComponentRange::into_de_error)
+    }
+}
+
+impl<'a> de::Visitor<'a> for Visitor<Duration> {
+    type Value = Duration;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a `Duration`")
+    }
+
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<Duration, E> {
+        let (seconds, nanoseconds) = value.split_once('.').ok_or_else(|| {
+            de::Error::invalid_value(de::Unexpected::Str(value), &"a decimal point")
+        })?;
+
+        let seconds = seconds
+            .parse()
+            .map_err(|_| de::Error::invalid_value(de::Unexpected::Str(seconds), &"seconds"))?;
+        let mut nanoseconds = nanoseconds.parse().map_err(|_| {
+            de::Error::invalid_value(de::Unexpected::Str(nanoseconds), &"nanoseconds")
+        })?;
+
+        if seconds < 0 {
+            nanoseconds *= -1;
+        }
+
+        Ok(Duration::new(seconds, nanoseconds))
+    }
+
+    fn visit_seq<A: de::SeqAccess<'a>>(self, mut seq: A) -> Result<Duration, A::Error> {
+        let seconds = item!(seq, "seconds")?;
+        let nanoseconds = item!(seq, "nanoseconds")?;
+        Ok(Duration::new(seconds, nanoseconds))
+    }
+}
+
+impl<'a> de::Visitor<'a> for Visitor<OffsetDateTime> {
+    type Value = OffsetDateTime;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("an `OffsetDateTime`")
+    }
+
+    #[cfg(feature = "parsing")]
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<OffsetDateTime, E> {
+        OffsetDateTime::parse(value, &OFFSET_DATE_TIME_FORMAT).map_err(E::custom)
+    }
+
+    fn visit_seq<A: de::SeqAccess<'a>>(self, mut seq: A) -> Result<OffsetDateTime, A::Error> {
+        let year = item!(seq, "year")?;
+        let ordinal = item!(seq, "day of year")?;
+        let hour = item!(seq, "hour")?;
+        let minute = item!(seq, "minute")?;
+        let second = item!(seq, "second")?;
+        let nanosecond = item!(seq, "nanosecond")?;
+        let offset_hours = item!(seq, "offset hours")?;
+        let offset_minutes = item!(seq, "offset minutes")?;
+        let offset_seconds = item!(seq, "offset seconds")?;
+
+        Date::from_ordinal_date(year, ordinal)
+            .and_then(|date| date.with_hms_nano(hour, minute, second, nanosecond))
+            .and_then(|datetime| {
+                UtcOffset::from_hms(offset_hours, offset_minutes, offset_seconds)
+                    .map(|offset| datetime.assume_offset(offset))
+            })
+            .map_err(ComponentRange::into_de_error)
+    }
+}
+
+impl<'a> de::Visitor<'a> for Visitor<PrimitiveDateTime> {
+    type Value = PrimitiveDateTime;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a `PrimitiveDateTime`")
+    }
+
+    #[cfg(feature = "parsing")]
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<PrimitiveDateTime, E> {
+        PrimitiveDateTime::parse(value, &PRIMITIVE_DATE_TIME_FORMAT).map_err(E::custom)
+    }
+
+    fn visit_seq<A: de::SeqAccess<'a>>(self, mut seq: A) -> Result<PrimitiveDateTime, A::Error> {
+        let year = item!(seq, "year")?;
+        let ordinal = item!(seq, "day of year")?;
+        let hour = item!(seq, "hour")?;
+        let minute = item!(seq, "minute")?;
+        let second = item!(seq, "second")?;
+        let nanosecond = item!(seq, "nanosecond")?;
+
+        Date::from_ordinal_date(year, ordinal)
+            .and_then(|date| date.with_hms_nano(hour, minute, second, nanosecond))
+            .map_err(ComponentRange::into_de_error)
+    }
+}
+
+impl<'a> de::Visitor<'a> for Visitor<Time> {
+    type Value = Time;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a `Time`")
+    }
+
+    #[cfg(feature = "parsing")]
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<Time, E> {
+        Time::parse(value, &TIME_FORMAT).map_err(E::custom)
+    }
+
+    fn visit_seq<A: de::SeqAccess<'a>>(self, mut seq: A) -> Result<Time, A::Error> {
+        let hour = item!(seq, "hour")?;
+        let minute = item!(seq, "minute")?;
+        let second = item!(seq, "second")?;
+        let nanosecond = item!(seq, "nanosecond")?;
+
+        Time::from_hms_nano(hour, minute, second, nanosecond).map_err(ComponentRange::into_de_error)
+    }
+}
+
+impl<'a> de::Visitor<'a> for Visitor<UtcOffset> {
+    type Value = UtcOffset;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a `UtcOffset`")
+    }
+
+    #[cfg(feature = "parsing")]
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<UtcOffset, E> {
+        UtcOffset::parse(value, &UTC_OFFSET_FORMAT).map_err(E::custom)
+    }
+
+    fn visit_seq<A: de::SeqAccess<'a>>(self, mut seq: A) -> Result<UtcOffset, A::Error> {
+        let hours = item!(seq, "offset hours")?;
+        let mut minutes = 0;
+        let mut seconds = 0;
+
+        if let Ok(Some(min)) = seq.next_element() {
+            minutes = min;
+            if let Ok(Some(sec)) = seq.next_element() {
+                seconds = sec;
+            }
+        };
+
+        UtcOffset::from_hms(hours, minutes, seconds).map_err(ComponentRange::into_de_error)
+    }
+}
+
+impl de::Visitor<'_> for Visitor<Weekday> {
+    type Value = Weekday;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a `Weekday`")
+    }
+
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<Weekday, E> {
+        match value {
+            "Monday" => Ok(Weekday::Monday),
+            "Tuesday" => Ok(Weekday::Tuesday),
+            "Wednesday" => Ok(Weekday::Wednesday),
+            "Thursday" => Ok(Weekday::Thursday),
+            "Friday" => Ok(Weekday::Friday),
+            "Saturday" => Ok(Weekday::Saturday),
+            "Sunday" => Ok(Weekday::Sunday),
+            _ => Err(E::invalid_value(de::Unexpected::Str(value), &"a `Weekday`")),
+        }
+    }
+
+    fn visit_u64<E: de::Error>(self, value: u64) -> Result<Weekday, E> {
+        match value {
+            1 => Ok(Weekday::Monday),
+            2 => Ok(Weekday::Tuesday),
+            3 => Ok(Weekday::Wednesday),
+            4 => Ok(Weekday::Thursday),
+            5 => Ok(Weekday::Friday),
+            6 => Ok(Weekday::Saturday),
+            7 => Ok(Weekday::Sunday),
+            _ => Err(E::invalid_value(
+                de::Unexpected::Unsigned(value),
+                &"a value in the range 1..=7",
+            )),
+        }
+    }
+}
+
+impl de::Visitor<'_> for Visitor<Month> {
+    type Value = Month;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a `Month`")
+    }
+
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<Month, E> {
+        match value {
+            "January" => Ok(Month::January),
+            "February" => Ok(Month::February),
+            "March" => Ok(Month::March),
+            "April" => Ok(Month::April),
+            "May" => Ok(Month::May),
+            "June" => Ok(Month::June),
+            "July" => Ok(Month::July),
+            "August" => Ok(Month::August),
+            "September" => Ok(Month::September),
+            "October" => Ok(Month::October),
+            "November" => Ok(Month::November),
+            "December" => Ok(Month::December),
+            _ => Err(E::invalid_value(de::Unexpected::Str(value), &"a `Month`")),
+        }
+    }
+
+    fn visit_u64<E: de::Error>(self, value: u64) -> Result<Month, E> {
+        match value {
+            1 => Ok(Month::January),
+            2 => Ok(Month::February),
+            3 => Ok(Month::March),
+            4 => Ok(Month::April),
+            5 => Ok(Month::May),
+            6 => Ok(Month::June),
+            7 => Ok(Month::July),
+            8 => Ok(Month::August),
+            9 => Ok(Month::September),
+            10 => Ok(Month::October),
+            11 => Ok(Month::November),
+            12 => Ok(Month::December),
+            _ => Err(E::invalid_value(
+                de::Unexpected::Unsigned(value),
+                &"a value in the range 1..=12",
+            )),
+        }
+    }
+}
+
+/// Implement a visitor for a well-known format.
+macro_rules! well_known {
+    ($article:literal, $name:literal, $($ty:tt)+) => {
+        #[cfg(feature = "parsing")]
+        impl de::Visitor<'_> for Visitor<$($ty)+> {
+            type Value = OffsetDateTime;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str(concat!($article, " ", $name, "-formatted `OffsetDateTime`"))
+            }
+
+            fn visit_str<E: de::Error>(self, value: &str) -> Result<OffsetDateTime, E> {
+                OffsetDateTime::parse(value, &$($ty)+).map_err(E::custom)
+            }
+        }
+
+        #[cfg(feature = "parsing")]
+        impl<'a> de::Visitor<'a> for Visitor<Option<$($ty)+>> {
+            type Value = Option<OffsetDateTime>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str(concat!(
+                    $article,
+                    " ",
+                    $name,
+                    "-formatted `Option<OffsetDateTime>`"
+                ))
+            }
+
+            fn visit_some<D: Deserializer<'a>>(
+                self,
+                deserializer: D,
+            ) -> Result<Option<OffsetDateTime>, D::Error> {
+                deserializer
+                    .deserialize_any(Visitor::<$($ty)+>(PhantomData))
+                    .map(Some)
+            }
+
+            fn visit_none<E: de::Error>(self) -> Result<Option<OffsetDateTime>, E> {
+                Ok(None)
+            }
+
+            fn visit_unit<E: de::Error>(self) -> Result<Self::Value, E> {
+                Ok(None)
+            }
+        }
+    };
+}
+
+well_known!("an", "RFC2822", Rfc2822);
+well_known!("an", "RFC3339", Rfc3339);
+well_known!(
+    "an",
+    "ISO 8601",
+    Iso8601::<{ super::iso8601::SERDE_CONFIG }>
+);
diff --git a/time/src/sys/local_offset_at/imp.rs b/time/src/sys/local_offset_at/imp.rs
new file mode 100644
index 000000000..251fa667c
--- /dev/null
+++ b/time/src/sys/local_offset_at/imp.rs
@@ -0,0 +1,8 @@
+//! A fallback for any OS not covered.
+
+use crate::{OffsetDateTime, UtcOffset};
+
+#[allow(clippy::missing_docs_in_private_items)]
+pub(super) fn local_offset_at(_datetime: OffsetDateTime) -> Option<UtcOffset> {
+    None
+}
diff --git a/time/src/sys/local_offset_at/mod.rs b/time/src/sys/local_offset_at/mod.rs
new file mode 100644
index 000000000..3367ebb55
--- /dev/null
+++ b/time/src/sys/local_offset_at/mod.rs
@@ -0,0 +1,28 @@
+//! A method to obtain the local offset from UTC.
+
+#![allow(clippy::missing_const_for_fn)]
+
+#[cfg_attr(target_family = "windows", path = "windows.rs")]
+#[cfg_attr(target_family = "unix", path = "unix.rs")]
+#[cfg_attr(
+    all(
+        target_family = "wasm",
+        not(any(target_os = "emscripten", target_os = "wasi")),
+        feature = "wasm-bindgen"
+    ),
+    path = "wasm_js.rs"
+)]
+mod imp;
+
+use crate::{OffsetDateTime, UtcOffset};
+
+/// Attempt to obtain the system's UTC offset. If the offset cannot be determined, `None` is
+/// returned.
+pub(crate) fn local_offset_at(datetime: OffsetDateTime) -> Option<UtcOffset> {
+    // miri does not support tzset()
+    if cfg!(miri) {
+        None
+    } else {
+        imp::local_offset_at(datetime)
+    }
+}
diff --git a/time/src/sys/local_offset_at/unix.rs b/time/src/sys/local_offset_at/unix.rs
new file mode 100644
index 000000000..eddd8e2a9
--- /dev/null
+++ b/time/src/sys/local_offset_at/unix.rs
@@ -0,0 +1,154 @@
+//! Get the system's UTC offset on Unix.
+
+use core::mem::MaybeUninit;
+
+use crate::util::local_offset::{self, Soundness};
+use crate::{OffsetDateTime, UtcOffset};
+
+/// Whether the operating system has a thread-safe environment. This allows bypassing the check for
+/// if the process is multi-threaded.
+// This is the same value as `cfg!(target_os = "x")`.
+// Use byte-strings to work around current limitations of const eval.
+const OS_HAS_THREAD_SAFE_ENVIRONMENT: bool = match std::env::consts::OS.as_bytes() {
+    // https://github.com/illumos/illumos-gate/blob/0fb96ba1f1ce26ff8b286f8f928769a6afcb00a6/usr/src/lib/libc/port/gen/getenv.c
+    b"illumos"
+    // https://github.com/NetBSD/src/blob/f45028636a44111bc4af44d460924958a4460844/lib/libc/stdlib/getenv.c
+    // https://github.com/NetBSD/src/blob/f45028636a44111bc4af44d460924958a4460844/lib/libc/stdlib/setenv.c
+    | b"netbsd"
+    => true,
+    _ => false,
+};
+
+/// Convert the given Unix timestamp to a `libc::tm`. Returns `None` on any error.
+///
+/// # Safety
+///
+/// This method must only be called when the process is single-threaded.
+///
+/// This method will remain `unsafe` until `std::env::set_var` is deprecated or has its behavior
+/// altered. This method is, on its own, safe. It is the presence of a safe, unsound way to set
+/// environment variables that makes it unsafe.
+unsafe fn timestamp_to_tm(timestamp: i64) -> Option<libc::tm> {
+    extern "C" {
+        #[cfg_attr(target_os = "netbsd", link_name = "__tzset50")]
+        fn tzset();
+    }
+
+    // The exact type of `timestamp` beforehand can vary, so this conversion is necessary.
+    #[allow(clippy::useless_conversion)]
+    let timestamp = timestamp.try_into().ok()?;
+
+    let mut tm = MaybeUninit::uninit();
+
+    // Update timezone information from system. `localtime_r` does not do this for us.
+    //
+    // Safety: tzset is thread-safe.
+    unsafe { tzset() };
+
+    // Safety: We are calling a system API, which mutates the `tm` variable. If a null
+    // pointer is returned, an error occurred.
+    let tm_ptr = unsafe { libc::localtime_r(&timestamp, tm.as_mut_ptr()) };
+
+    if tm_ptr.is_null() {
+        None
+    } else {
+        // Safety: The value was initialized, as we no longer have a null pointer.
+        Some(unsafe { tm.assume_init() })
+    }
+}
+
+/// Convert a `libc::tm` to a `UtcOffset`. Returns `None` on any error.
+// This is available to any target known to have the `tm_gmtoff` extension.
+#[cfg(any(
+    target_os = "redox",
+    target_os = "linux",
+    target_os = "l4re",
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "watchos",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "openbsd",
+    target_os = "netbsd",
+    target_os = "haiku",
+))]
+fn tm_to_offset(_unix_timestamp: i64, tm: libc::tm) -> Option<UtcOffset> {
+    let seconds = tm.tm_gmtoff.try_into().ok()?;
+    UtcOffset::from_whole_seconds(seconds).ok()
+}
+
+/// Convert a `libc::tm` to a `UtcOffset`. Returns `None` on any error.
+///
+/// This method can return an incorrect value, as it only approximates the `tm_gmtoff` field. The
+/// reason for this is that daylight saving time does not start on the same date every year, nor are
+/// the rules for daylight saving time the same for every year. This implementation assumes 1970 is
+/// equivalent to every other year, which is not always the case.
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "linux",
+    target_os = "l4re",
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "watchos",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "openbsd",
+    target_os = "netbsd",
+    target_os = "haiku",
+)))]
+fn tm_to_offset(unix_timestamp: i64, tm: libc::tm) -> Option<UtcOffset> {
+    use crate::Date;
+
+    let mut tm = tm;
+    if tm.tm_sec == 60 {
+        // Leap seconds are not currently supported.
+        tm.tm_sec = 59;
+    }
+
+    let local_timestamp =
+        Date::from_ordinal_date(1900 + tm.tm_year, u16::try_from(tm.tm_yday).ok()? + 1)
+            .ok()?
+            .with_hms(
+                tm.tm_hour.try_into().ok()?,
+                tm.tm_min.try_into().ok()?,
+                tm.tm_sec.try_into().ok()?,
+            )
+            .ok()?
+            .assume_utc()
+            .unix_timestamp();
+
+    let diff_secs = (local_timestamp - unix_timestamp).try_into().ok()?;
+
+    UtcOffset::from_whole_seconds(diff_secs).ok()
+}
+
+/// Obtain the system's UTC offset.
+pub(super) fn local_offset_at(datetime: OffsetDateTime) -> Option<UtcOffset> {
+    // Continue to obtaining the UTC offset if and only if the call is sound or the user has
+    // explicitly opted out of soundness.
+    //
+    // Soundness can be guaranteed either by knowledge of the operating system or knowledge that the
+    // process is single-threaded. If the process is single-threaded, then the environment cannot
+    // be mutated by a different thread in the process while execution of this function is taking
+    // place, which can cause a segmentation fault by dereferencing a dangling pointer.
+    //
+    // If the `num_threads` crate is incapable of determining the number of running threads, then
+    // we conservatively return `None` to avoid a soundness bug.
+
+    if OS_HAS_THREAD_SAFE_ENVIRONMENT
+        || local_offset::get_soundness() == Soundness::Unsound
+        || num_threads::is_single_threaded() == Some(true)
+    {
+        let unix_timestamp = datetime.unix_timestamp();
+        // Safety: We have just confirmed that the process is single-threaded or the user has
+        // explicitly opted out of soundness.
+        let tm = unsafe { timestamp_to_tm(unix_timestamp) }?;
+        tm_to_offset(unix_timestamp, tm)
+    } else {
+        None
+    }
+}
diff --git a/time/src/sys/local_offset_at/wasm_js.rs b/time/src/sys/local_offset_at/wasm_js.rs
new file mode 100644
index 000000000..a985e7c48
--- /dev/null
+++ b/time/src/sys/local_offset_at/wasm_js.rs
@@ -0,0 +1,16 @@
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::{OffsetDateTime, UtcOffset};
+
+/// Obtain the system's UTC offset.
+pub(super) fn local_offset_at(datetime: OffsetDateTime) -> Option<UtcOffset> {
+    let js_date: js_sys::Date = datetime.into();
+    // The number of minutes returned by getTimezoneOffset() is positive if the local time zone
+    // is behind UTC, and negative if the local time zone is ahead of UTC. For example,
+    // for UTC+10, -600 will be returned.
+    let timezone_offset =
+        (js_date.get_timezone_offset() as i32) * -Minute::per(Hour).cast_signed().extend::<i32>();
+
+    UtcOffset::from_whole_seconds(timezone_offset).ok()
+}
diff --git a/time/src/sys/local_offset_at/windows.rs b/time/src/sys/local_offset_at/windows.rs
new file mode 100644
index 000000000..d14429209
--- /dev/null
+++ b/time/src/sys/local_offset_at/windows.rs
@@ -0,0 +1,113 @@
+//! Get the system's UTC offset on Windows.
+
+use core::mem::MaybeUninit;
+
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::{OffsetDateTime, UtcOffset};
+
+// ffi: WINAPI FILETIME struct
+#[repr(C)]
+#[allow(non_snake_case, clippy::missing_docs_in_private_items)]
+struct FileTime {
+    dwLowDateTime: u32,
+    dwHighDateTime: u32,
+}
+
+// ffi: WINAPI SYSTEMTIME struct
+#[repr(C)]
+#[allow(non_snake_case, clippy::missing_docs_in_private_items)]
+struct SystemTime {
+    wYear: u16,
+    wMonth: u16,
+    wDayOfWeek: u16,
+    wDay: u16,
+    wHour: u16,
+    wMinute: u16,
+    wSecond: u16,
+    wMilliseconds: u16,
+}
+
+#[link(name = "kernel32")]
+extern "system" {
+    // https://docs.microsoft.com/en-us/windows/win32/api/timezoneapi/nf-timezoneapi-systemtimetofiletime
+    fn SystemTimeToFileTime(lpSystemTime: *const SystemTime, lpFileTime: *mut FileTime) -> i32;
+
+    // https://docs.microsoft.com/en-us/windows/win32/api/timezoneapi/nf-timezoneapi-systemtimetotzspecificlocaltime
+    fn SystemTimeToTzSpecificLocalTime(
+        lpTimeZoneInformation: *const core::ffi::c_void, // We only pass `nullptr` here
+        lpUniversalTime: *const SystemTime,
+        lpLocalTime: *mut SystemTime,
+    ) -> i32;
+}
+
+/// Convert a `SYSTEMTIME` to a `FILETIME`. Returns `None` if any error occurred.
+fn systemtime_to_filetime(systime: &SystemTime) -> Option<FileTime> {
+    let mut ft = MaybeUninit::uninit();
+
+    // Safety: `SystemTimeToFileTime` is thread-safe.
+    if 0 == unsafe { SystemTimeToFileTime(systime, ft.as_mut_ptr()) } {
+        // failed
+        None
+    } else {
+        // Safety: The call succeeded.
+        Some(unsafe { ft.assume_init() })
+    }
+}
+
+/// Convert a `FILETIME` to an `i64`, representing a number of seconds.
+fn filetime_to_secs(filetime: &FileTime) -> i64 {
+    /// FILETIME represents 100-nanosecond intervals
+    const FT_TO_SECS: u64 = Nanosecond::per(Second) as u64 / 100;
+    ((filetime.dwHighDateTime.extend::<u64>() << 32 | filetime.dwLowDateTime.extend::<u64>())
+        / FT_TO_SECS) as i64
+}
+
+/// Convert an [`OffsetDateTime`] to a `SYSTEMTIME`.
+fn offset_to_systemtime(datetime: OffsetDateTime) -> SystemTime {
+    let (_, month, day_of_month) = datetime.to_offset(UtcOffset::UTC).date().to_calendar_date();
+    SystemTime {
+        wYear: datetime.year().cast_unsigned().truncate(),
+        wMonth: u8::from(month).extend(),
+        wDay: day_of_month.extend(),
+        wDayOfWeek: 0, // ignored
+        wHour: datetime.hour().extend(),
+        wMinute: datetime.minute().extend(),
+        wSecond: datetime.second().extend(),
+        wMilliseconds: datetime.millisecond(),
+    }
+}
+
+/// Obtain the system's UTC offset.
+pub(super) fn local_offset_at(datetime: OffsetDateTime) -> Option<UtcOffset> {
+    // This function falls back to UTC if any system call fails.
+    let systime_utc = offset_to_systemtime(datetime.to_offset(UtcOffset::UTC));
+
+    // Safety: `local_time` is only read if it is properly initialized, and
+    // `SystemTimeToTzSpecificLocalTime` is thread-safe.
+    let systime_local = unsafe {
+        let mut local_time = MaybeUninit::uninit();
+
+        if 0 == SystemTimeToTzSpecificLocalTime(
+            core::ptr::null(), // use system's current timezone
+            &systime_utc,
+            local_time.as_mut_ptr(),
+        ) {
+            // call failed
+            return None;
+        } else {
+            local_time.assume_init()
+        }
+    };
+
+    // Convert SYSTEMTIMEs to FILETIMEs so we can perform arithmetic on them.
+    let ft_system = systemtime_to_filetime(&systime_utc)?;
+    let ft_local = systemtime_to_filetime(&systime_local)?;
+
+    let diff_secs = (filetime_to_secs(&ft_local) - filetime_to_secs(&ft_system))
+        .try_into()
+        .ok()?;
+
+    UtcOffset::from_whole_seconds(diff_secs).ok()
+}
diff --git a/time/src/sys/mod.rs b/time/src/sys/mod.rs
new file mode 100644
index 000000000..90bbf7ff3
--- /dev/null
+++ b/time/src/sys/mod.rs
@@ -0,0 +1,9 @@
+//! Functions with a common interface that rely on system calls.
+
+#![allow(unsafe_code)] // We're interfacing with system calls.
+
+#[cfg(feature = "local-offset")]
+mod local_offset_at;
+
+#[cfg(feature = "local-offset")]
+pub(crate) use local_offset_at::local_offset_at;
diff --git a/time/src/tests.rs b/time/src/tests.rs
new file mode 100644
index 000000000..4ccd87b18
--- /dev/null
+++ b/time/src/tests.rs
@@ -0,0 +1,106 @@
+#![cfg(all( // require `--all-features` to be passed
+    feature = "default",
+    feature = "alloc",
+    feature = "formatting",
+    feature = "large-dates",
+    feature = "local-offset",
+    feature = "macros",
+    feature = "parsing",
+    feature = "quickcheck",
+    feature = "serde-human-readable",
+    feature = "serde-well-known",
+    feature = "std",
+    feature = "rand",
+    feature = "serde",
+))]
+#![allow(
+    let_underscore_drop,
+    clippy::clone_on_copy,
+    clippy::cognitive_complexity,
+    clippy::std_instead_of_core
+)]
+
+//! Tests for internal details.
+//!
+//! This module should only be used when it is not possible to test the implementation in a
+//! reasonable manner externally.
+
+use std::format;
+use std::num::NonZeroU8;
+
+use crate::ext::DigitCount;
+use crate::parsing::combinator::rfc::iso8601;
+use crate::parsing::shim::Integer;
+use crate::{duration, parsing};
+
+#[test]
+fn digit_count() {
+    assert_eq!(1_u8.num_digits(), 1);
+    assert_eq!(9_u8.num_digits(), 1);
+    assert_eq!(10_u8.num_digits(), 2);
+    assert_eq!(99_u8.num_digits(), 2);
+    assert_eq!(100_u8.num_digits(), 3);
+
+    assert_eq!(1_u16.num_digits(), 1);
+    assert_eq!(9_u16.num_digits(), 1);
+    assert_eq!(10_u16.num_digits(), 2);
+    assert_eq!(99_u16.num_digits(), 2);
+    assert_eq!(100_u16.num_digits(), 3);
+    assert_eq!(999_u16.num_digits(), 3);
+    assert_eq!(1_000_u16.num_digits(), 4);
+    assert_eq!(9_999_u16.num_digits(), 4);
+    assert_eq!(10_000_u16.num_digits(), 5);
+
+    assert_eq!(1_u32.num_digits(), 1);
+    assert_eq!(9_u32.num_digits(), 1);
+    assert_eq!(10_u32.num_digits(), 2);
+    assert_eq!(99_u32.num_digits(), 2);
+    assert_eq!(100_u32.num_digits(), 3);
+    assert_eq!(999_u32.num_digits(), 3);
+    assert_eq!(1_000_u32.num_digits(), 4);
+    assert_eq!(9_999_u32.num_digits(), 4);
+    assert_eq!(10_000_u32.num_digits(), 5);
+    assert_eq!(99_999_u32.num_digits(), 5);
+    assert_eq!(100_000_u32.num_digits(), 6);
+    assert_eq!(999_999_u32.num_digits(), 6);
+    assert_eq!(1_000_000_u32.num_digits(), 7);
+    assert_eq!(9_999_999_u32.num_digits(), 7);
+    assert_eq!(10_000_000_u32.num_digits(), 8);
+    assert_eq!(99_999_999_u32.num_digits(), 8);
+    assert_eq!(100_000_000_u32.num_digits(), 9);
+    assert_eq!(999_999_999_u32.num_digits(), 9);
+    assert_eq!(1_000_000_000_u32.num_digits(), 10);
+}
+
+#[test]
+fn debug() {
+    let _ = format!("{:?}", duration::Padding::Optimize);
+    let _ = format!("{:?}", parsing::ParsedItem(b"", 0));
+    let _ = format!("{:?}", parsing::component::Period::Am);
+    let _ = format!("{:?}", iso8601::ExtendedKind::Basic);
+}
+
+#[test]
+fn clone() {
+    assert_eq!(
+        parsing::component::Period::Am.clone(),
+        parsing::component::Period::Am
+    );
+    // does not impl Debug
+    assert!(crate::time::Padding::Optimize.clone() == crate::time::Padding::Optimize);
+    // does not impl PartialEq
+    assert!(matches!(
+        iso8601::ExtendedKind::Basic.clone(),
+        iso8601::ExtendedKind::Basic
+    ));
+}
+
+#[test]
+fn parsing_internals() {
+    assert!(
+        parsing::ParsedItem(b"", ())
+            .flat_map(|_| None::<()>)
+            .is_none()
+    );
+    assert!(<NonZeroU8 as Integer>::parse_bytes(b"256").is_none());
+}
diff --git a/time/src/time.rs b/time/src/time.rs
new file mode 100644
index 000000000..2bd2fefe8
--- /dev/null
+++ b/time/src/time.rs
@@ -0,0 +1,952 @@
+//! The [`Time`] struct and its associated `impl`s.
+
+#[cfg(feature = "formatting")]
+use alloc::string::String;
+use core::fmt;
+use core::ops::{Add, Sub};
+use core::time::Duration as StdDuration;
+#[cfg(feature = "formatting")]
+use std::io;
+
+use deranged::{RangedU32, RangedU8};
+use num_conv::prelude::*;
+use powerfmt::ext::FormatterExt;
+use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
+
+use crate::convert::*;
+#[cfg(feature = "formatting")]
+use crate::formatting::Formattable;
+use crate::internal_macros::{cascade, ensure_ranged, impl_add_assign, impl_sub_assign};
+#[cfg(feature = "parsing")]
+use crate::parsing::Parsable;
+use crate::util::DateAdjustment;
+use crate::{error, Duration};
+
+/// By explicitly inserting this enum where padding is expected, the compiler is able to better
+/// perform niche value optimization.
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) enum Padding {
+    #[allow(clippy::missing_docs_in_private_items)]
+    Optimize,
+}
+
+/// The type of the `hour` field of `Time`.
+type Hours = RangedU8<0, { Hour::per(Day) - 1 }>;
+/// The type of the `minute` field of `Time`.
+type Minutes = RangedU8<0, { Minute::per(Hour) - 1 }>;
+/// The type of the `second` field of `Time`.
+type Seconds = RangedU8<0, { Second::per(Minute) - 1 }>;
+/// The type of the `nanosecond` field of `Time`.
+type Nanoseconds = RangedU32<0, { Nanosecond::per(Second) - 1 }>;
+
+/// The clock time within a given date. Nanosecond precision.
+///
+/// All minutes are assumed to have exactly 60 seconds; no attempt is made to handle leap seconds
+/// (either positive or negative).
+///
+/// When comparing two `Time`s, they are assumed to be in the same calendar date.
+#[derive(Clone, Copy, Eq)]
+#[repr(C)]
+pub struct Time {
+    // The order of this struct's fields matter!
+    // Do not change them.
+
+    // Little endian version
+    #[cfg(target_endian = "little")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    nanosecond: Nanoseconds,
+    #[cfg(target_endian = "little")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    second: Seconds,
+    #[cfg(target_endian = "little")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    minute: Minutes,
+    #[cfg(target_endian = "little")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    hour: Hours,
+    #[cfg(target_endian = "little")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    padding: Padding,
+
+    // Big endian version
+    #[cfg(target_endian = "big")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    padding: Padding,
+    #[cfg(target_endian = "big")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    hour: Hours,
+    #[cfg(target_endian = "big")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    minute: Minutes,
+    #[cfg(target_endian = "big")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    second: Seconds,
+    #[cfg(target_endian = "big")]
+    #[allow(clippy::missing_docs_in_private_items)]
+    nanosecond: Nanoseconds,
+}
+
+impl core::hash::Hash for Time {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.as_u64().hash(state)
+    }
+}
+
+impl PartialEq for Time {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_u64().eq(&other.as_u64())
+    }
+}
+
+impl PartialOrd for Time {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Time {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        self.as_u64().cmp(&other.as_u64())
+    }
+}
+
+impl Time {
+    /// Provides an u64 based representation **of the correct endianness**
+    ///
+    /// This representation can be used to do comparisons equality testing or hashing.
+    const fn as_u64(self) -> u64 {
+        let nano_bytes = self.nanosecond.get().to_ne_bytes();
+
+        #[cfg(target_endian = "big")]
+        return u64::from_be_bytes([
+            self.padding as u8,
+            self.hour.get(),
+            self.minute.get(),
+            self.second.get(),
+            nano_bytes[0],
+            nano_bytes[1],
+            nano_bytes[2],
+            nano_bytes[3],
+        ]);
+
+        #[cfg(target_endian = "little")]
+        return u64::from_le_bytes([
+            nano_bytes[0],
+            nano_bytes[1],
+            nano_bytes[2],
+            nano_bytes[3],
+            self.second.get(),
+            self.minute.get(),
+            self.hour.get(),
+            self.padding as u8,
+        ]);
+    }
+
+    /// Create a `Time` that is exactly midnight.
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// # use time_macros::time;
+    /// assert_eq!(Time::MIDNIGHT, time!(0:00));
+    /// ```
+    pub const MIDNIGHT: Self = Self::MIN;
+
+    /// The smallest value that can be represented by `Time`.
+    ///
+    /// `00:00:00.0`
+    pub(crate) const MIN: Self =
+        Self::from_hms_nanos_ranged(Hours::MIN, Minutes::MIN, Seconds::MIN, Nanoseconds::MIN);
+
+    /// The largest value that can be represented by `Time`.
+    ///
+    /// `23:59:59.999_999_999`
+    pub(crate) const MAX: Self =
+        Self::from_hms_nanos_ranged(Hours::MAX, Minutes::MAX, Seconds::MAX, Nanoseconds::MAX);
+
+    // region: constructors
+    /// Create a `Time` from its components.
+    ///
+    /// # Safety
+    ///
+    /// - `hours` must be in the range `0..=23`.
+    /// - `minutes` must be in the range `0..=59`.
+    /// - `seconds` must be in the range `0..=59`.
+    /// - `nanoseconds` must be in the range `0..=999_999_999`.
+    #[doc(hidden)]
+    pub const unsafe fn __from_hms_nanos_unchecked(
+        hour: u8,
+        minute: u8,
+        second: u8,
+        nanosecond: u32,
+    ) -> Self {
+        // Safety: The caller must uphold the safety invariants.
+        unsafe {
+            Self::from_hms_nanos_ranged(
+                Hours::new_unchecked(hour),
+                Minutes::new_unchecked(minute),
+                Seconds::new_unchecked(second),
+                Nanoseconds::new_unchecked(nanosecond),
+            )
+        }
+    }
+
+    /// Attempt to create a `Time` from the hour, minute, and second.
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms(1, 2, 3).is_ok());
+    /// ```
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms(24, 0, 0).is_err()); // 24 isn't a valid hour.
+    /// assert!(Time::from_hms(0, 60, 0).is_err()); // 60 isn't a valid minute.
+    /// assert!(Time::from_hms(0, 0, 60).is_err()); // 60 isn't a valid second.
+    /// ```
+    pub const fn from_hms(hour: u8, minute: u8, second: u8) -> Result<Self, error::ComponentRange> {
+        Ok(Self::from_hms_nanos_ranged(
+            ensure_ranged!(Hours: hour),
+            ensure_ranged!(Minutes: minute),
+            ensure_ranged!(Seconds: second),
+            Nanoseconds::MIN,
+        ))
+    }
+
+    /// Create a `Time` from the hour, minute, second, and nanosecond.
+    pub(crate) const fn from_hms_nanos_ranged(
+        hour: Hours,
+        minute: Minutes,
+        second: Seconds,
+        nanosecond: Nanoseconds,
+    ) -> Self {
+        Self {
+            hour,
+            minute,
+            second,
+            nanosecond,
+            padding: Padding::Optimize,
+        }
+    }
+
+    /// Attempt to create a `Time` from the hour, minute, second, and millisecond.
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms_milli(1, 2, 3, 4).is_ok());
+    /// ```
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms_milli(24, 0, 0, 0).is_err()); // 24 isn't a valid hour.
+    /// assert!(Time::from_hms_milli(0, 60, 0, 0).is_err()); // 60 isn't a valid minute.
+    /// assert!(Time::from_hms_milli(0, 0, 60, 0).is_err()); // 60 isn't a valid second.
+    /// assert!(Time::from_hms_milli(0, 0, 0, 1_000).is_err()); // 1_000 isn't a valid millisecond.
+    /// ```
+    pub const fn from_hms_milli(
+        hour: u8,
+        minute: u8,
+        second: u8,
+        millisecond: u16,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(Self::from_hms_nanos_ranged(
+            ensure_ranged!(Hours: hour),
+            ensure_ranged!(Minutes: minute),
+            ensure_ranged!(Seconds: second),
+            ensure_ranged!(Nanoseconds: millisecond as u32 * Nanosecond::per(Millisecond)),
+        ))
+    }
+
+    /// Attempt to create a `Time` from the hour, minute, second, and microsecond.
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms_micro(1, 2, 3, 4).is_ok());
+    /// ```
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms_micro(24, 0, 0, 0).is_err()); // 24 isn't a valid hour.
+    /// assert!(Time::from_hms_micro(0, 60, 0, 0).is_err()); // 60 isn't a valid minute.
+    /// assert!(Time::from_hms_micro(0, 0, 60, 0).is_err()); // 60 isn't a valid second.
+    /// assert!(Time::from_hms_micro(0, 0, 0, 1_000_000).is_err()); // 1_000_000 isn't a valid microsecond.
+    /// ```
+    pub const fn from_hms_micro(
+        hour: u8,
+        minute: u8,
+        second: u8,
+        microsecond: u32,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(Self::from_hms_nanos_ranged(
+            ensure_ranged!(Hours: hour),
+            ensure_ranged!(Minutes: minute),
+            ensure_ranged!(Seconds: second),
+            ensure_ranged!(Nanoseconds: microsecond * Nanosecond::per(Microsecond) as u32),
+        ))
+    }
+
+    /// Attempt to create a `Time` from the hour, minute, second, and nanosecond.
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms_nano(1, 2, 3, 4).is_ok());
+    /// ```
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// assert!(Time::from_hms_nano(24, 0, 0, 0).is_err()); // 24 isn't a valid hour.
+    /// assert!(Time::from_hms_nano(0, 60, 0, 0).is_err()); // 60 isn't a valid minute.
+    /// assert!(Time::from_hms_nano(0, 0, 60, 0).is_err()); // 60 isn't a valid second.
+    /// assert!(Time::from_hms_nano(0, 0, 0, 1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond.
+    /// ```
+    pub const fn from_hms_nano(
+        hour: u8,
+        minute: u8,
+        second: u8,
+        nanosecond: u32,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(Self::from_hms_nanos_ranged(
+            ensure_ranged!(Hours: hour),
+            ensure_ranged!(Minutes: minute),
+            ensure_ranged!(Seconds: second),
+            ensure_ranged!(Nanoseconds: nanosecond),
+        ))
+    }
+    // endregion constructors
+
+    // region: getters
+    /// Get the clock hour, minute, and second.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00:00).as_hms(), (0, 0, 0));
+    /// assert_eq!(time!(23:59:59).as_hms(), (23, 59, 59));
+    /// ```
+    pub const fn as_hms(self) -> (u8, u8, u8) {
+        (self.hour.get(), self.minute.get(), self.second.get())
+    }
+
+    /// Get the clock hour, minute, second, and millisecond.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00:00).as_hms_milli(), (0, 0, 0, 0));
+    /// assert_eq!(time!(23:59:59.999).as_hms_milli(), (23, 59, 59, 999));
+    /// ```
+    pub const fn as_hms_milli(self) -> (u8, u8, u8, u16) {
+        (
+            self.hour.get(),
+            self.minute.get(),
+            self.second.get(),
+            (self.nanosecond.get() / Nanosecond::per(Millisecond)) as u16,
+        )
+    }
+
+    /// Get the clock hour, minute, second, and microsecond.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00:00).as_hms_micro(), (0, 0, 0, 0));
+    /// assert_eq!(
+    ///     time!(23:59:59.999_999).as_hms_micro(),
+    ///     (23, 59, 59, 999_999)
+    /// );
+    /// ```
+    pub const fn as_hms_micro(self) -> (u8, u8, u8, u32) {
+        (
+            self.hour.get(),
+            self.minute.get(),
+            self.second.get(),
+            self.nanosecond.get() / Nanosecond::per(Microsecond) as u32,
+        )
+    }
+
+    /// Get the clock hour, minute, second, and nanosecond.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00:00).as_hms_nano(), (0, 0, 0, 0));
+    /// assert_eq!(
+    ///     time!(23:59:59.999_999_999).as_hms_nano(),
+    ///     (23, 59, 59, 999_999_999)
+    /// );
+    /// ```
+    pub const fn as_hms_nano(self) -> (u8, u8, u8, u32) {
+        (
+            self.hour.get(),
+            self.minute.get(),
+            self.second.get(),
+            self.nanosecond.get(),
+        )
+    }
+
+    /// Get the clock hour, minute, second, and nanosecond.
+    #[cfg(feature = "quickcheck")]
+    pub(crate) const fn as_hms_nano_ranged(self) -> (Hours, Minutes, Seconds, Nanoseconds) {
+        (self.hour, self.minute, self.second, self.nanosecond)
+    }
+
+    /// Get the clock hour.
+    ///
+    /// The returned value will always be in the range `0..24`.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00:00).hour(), 0);
+    /// assert_eq!(time!(23:59:59).hour(), 23);
+    /// ```
+    pub const fn hour(self) -> u8 {
+        self.hour.get()
+    }
+
+    /// Get the minute within the hour.
+    ///
+    /// The returned value will always be in the range `0..60`.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00:00).minute(), 0);
+    /// assert_eq!(time!(23:59:59).minute(), 59);
+    /// ```
+    pub const fn minute(self) -> u8 {
+        self.minute.get()
+    }
+
+    /// Get the second within the minute.
+    ///
+    /// The returned value will always be in the range `0..60`.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00:00).second(), 0);
+    /// assert_eq!(time!(23:59:59).second(), 59);
+    /// ```
+    pub const fn second(self) -> u8 {
+        self.second.get()
+    }
+
+    /// Get the milliseconds within the second.
+    ///
+    /// The returned value will always be in the range `0..1_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00).millisecond(), 0);
+    /// assert_eq!(time!(23:59:59.999).millisecond(), 999);
+    /// ```
+    pub const fn millisecond(self) -> u16 {
+        (self.nanosecond.get() / Nanosecond::per(Millisecond)) as _
+    }
+
+    /// Get the microseconds within the second.
+    ///
+    /// The returned value will always be in the range `0..1_000_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00).microsecond(), 0);
+    /// assert_eq!(time!(23:59:59.999_999).microsecond(), 999_999);
+    /// ```
+    pub const fn microsecond(self) -> u32 {
+        self.nanosecond.get() / Nanosecond::per(Microsecond) as u32
+    }
+
+    /// Get the nanoseconds within the second.
+    ///
+    /// The returned value will always be in the range `0..1_000_000_000`.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00).nanosecond(), 0);
+    /// assert_eq!(time!(23:59:59.999_999_999).nanosecond(), 999_999_999);
+    /// ```
+    pub const fn nanosecond(self) -> u32 {
+        self.nanosecond.get()
+    }
+    // endregion getters
+
+    // region: arithmetic helpers
+    /// Add the sub-day time of the [`Duration`] to the `Time`. Wraps on overflow, returning whether
+    /// the date is different.
+    pub(crate) const fn adjusting_add(self, duration: Duration) -> (DateAdjustment, Self) {
+        let mut nanoseconds = self.nanosecond.get() as i32 + duration.subsec_nanoseconds();
+        let mut seconds =
+            self.second.get() as i8 + (duration.whole_seconds() % Second::per(Minute) as i64) as i8;
+        let mut minutes =
+            self.minute.get() as i8 + (duration.whole_minutes() % Minute::per(Hour) as i64) as i8;
+        let mut hours =
+            self.hour.get() as i8 + (duration.whole_hours() % Hour::per(Day) as i64) as i8;
+        let mut date_adjustment = DateAdjustment::None;
+
+        cascade!(nanoseconds in 0..Nanosecond::per(Second) as _ => seconds);
+        cascade!(seconds in 0..Second::per(Minute) as _ => minutes);
+        cascade!(minutes in 0..Minute::per(Hour) as _ => hours);
+        if hours >= Hour::per(Day) as _ {
+            hours -= Hour::per(Day) as i8;
+            date_adjustment = DateAdjustment::Next;
+        } else if hours < 0 {
+            hours += Hour::per(Day) as i8;
+            date_adjustment = DateAdjustment::Previous;
+        }
+
+        (
+            date_adjustment,
+            // Safety: The cascades above ensure the values are in range.
+            unsafe {
+                Self::__from_hms_nanos_unchecked(
+                    hours as _,
+                    minutes as _,
+                    seconds as _,
+                    nanoseconds as _,
+                )
+            },
+        )
+    }
+
+    /// Subtract the sub-day time of the [`Duration`] to the `Time`. Wraps on overflow, returning
+    /// whether the date is different.
+    pub(crate) const fn adjusting_sub(self, duration: Duration) -> (DateAdjustment, Self) {
+        let mut nanoseconds = self.nanosecond.get() as i32 - duration.subsec_nanoseconds();
+        let mut seconds =
+            self.second.get() as i8 - (duration.whole_seconds() % Second::per(Minute) as i64) as i8;
+        let mut minutes =
+            self.minute.get() as i8 - (duration.whole_minutes() % Minute::per(Hour) as i64) as i8;
+        let mut hours =
+            self.hour.get() as i8 - (duration.whole_hours() % Hour::per(Day) as i64) as i8;
+        let mut date_adjustment = DateAdjustment::None;
+
+        cascade!(nanoseconds in 0..Nanosecond::per(Second) as _ => seconds);
+        cascade!(seconds in 0..Second::per(Minute) as _ => minutes);
+        cascade!(minutes in 0..Minute::per(Hour) as _ => hours);
+        if hours >= Hour::per(Day) as _ {
+            hours -= Hour::per(Day) as i8;
+            date_adjustment = DateAdjustment::Next;
+        } else if hours < 0 {
+            hours += Hour::per(Day) as i8;
+            date_adjustment = DateAdjustment::Previous;
+        }
+
+        (
+            date_adjustment,
+            // Safety: The cascades above ensure the values are in range.
+            unsafe {
+                Self::__from_hms_nanos_unchecked(
+                    hours as _,
+                    minutes as _,
+                    seconds as _,
+                    nanoseconds as _,
+                )
+            },
+        )
+    }
+
+    /// Add the sub-day time of the [`std::time::Duration`] to the `Time`. Wraps on overflow,
+    /// returning whether the date is the previous date as the first element of the tuple.
+    pub(crate) const fn adjusting_add_std(self, duration: StdDuration) -> (bool, Self) {
+        let mut nanosecond = self.nanosecond.get() + duration.subsec_nanos();
+        let mut second =
+            self.second.get() + (duration.as_secs() % Second::per(Minute) as u64) as u8;
+        let mut minute = self.minute.get()
+            + ((duration.as_secs() / Second::per(Minute) as u64) % Minute::per(Hour) as u64) as u8;
+        let mut hour = self.hour.get()
+            + ((duration.as_secs() / Second::per(Hour) as u64) % Hour::per(Day) as u64) as u8;
+        let mut is_next_day = false;
+
+        cascade!(nanosecond in 0..Nanosecond::per(Second) => second);
+        cascade!(second in 0..Second::per(Minute) => minute);
+        cascade!(minute in 0..Minute::per(Hour) => hour);
+        if hour >= Hour::per(Day) {
+            hour -= Hour::per(Day);
+            is_next_day = true;
+        }
+
+        (
+            is_next_day,
+            // Safety: The cascades above ensure the values are in range.
+            unsafe { Self::__from_hms_nanos_unchecked(hour, minute, second, nanosecond) },
+        )
+    }
+
+    /// Subtract the sub-day time of the [`std::time::Duration`] to the `Time`. Wraps on overflow,
+    /// returning whether the date is the previous date as the first element of the tuple.
+    pub(crate) const fn adjusting_sub_std(self, duration: StdDuration) -> (bool, Self) {
+        let mut nanosecond = self.nanosecond.get() as i32 - duration.subsec_nanos() as i32;
+        let mut second =
+            self.second.get() as i8 - (duration.as_secs() % Second::per(Minute) as u64) as i8;
+        let mut minute = self.minute.get() as i8
+            - ((duration.as_secs() / Second::per(Minute) as u64) % Minute::per(Hour) as u64) as i8;
+        let mut hour = self.hour.get() as i8
+            - ((duration.as_secs() / Second::per(Hour) as u64) % Hour::per(Day) as u64) as i8;
+        let mut is_previous_day = false;
+
+        cascade!(nanosecond in 0..Nanosecond::per(Second) as _ => second);
+        cascade!(second in 0..Second::per(Minute) as _ => minute);
+        cascade!(minute in 0..Minute::per(Hour) as _ => hour);
+        if hour < 0 {
+            hour += Hour::per(Day) as i8;
+            is_previous_day = true;
+        }
+
+        (
+            is_previous_day,
+            // Safety: The cascades above ensure the values are in range.
+            unsafe {
+                Self::__from_hms_nanos_unchecked(
+                    hour as _,
+                    minute as _,
+                    second as _,
+                    nanosecond as _,
+                )
+            },
+        )
+    }
+    // endregion arithmetic helpers
+
+    // region: replacement
+    /// Replace the clock hour.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(
+    ///     time!(01:02:03.004_005_006).replace_hour(7),
+    ///     Ok(time!(07:02:03.004_005_006))
+    /// );
+    /// assert!(time!(01:02:03.004_005_006).replace_hour(24).is_err()); // 24 isn't a valid hour
+    /// ```
+    #[must_use = "This method does not mutate the original `Time`."]
+    pub const fn replace_hour(mut self, hour: u8) -> Result<Self, error::ComponentRange> {
+        self.hour = ensure_ranged!(Hours: hour);
+        Ok(self)
+    }
+
+    /// Replace the minutes within the hour.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(
+    ///     time!(01:02:03.004_005_006).replace_minute(7),
+    ///     Ok(time!(01:07:03.004_005_006))
+    /// );
+    /// assert!(time!(01:02:03.004_005_006).replace_minute(60).is_err()); // 60 isn't a valid minute
+    /// ```
+    #[must_use = "This method does not mutate the original `Time`."]
+    pub const fn replace_minute(mut self, minute: u8) -> Result<Self, error::ComponentRange> {
+        self.minute = ensure_ranged!(Minutes: minute);
+        Ok(self)
+    }
+
+    /// Replace the seconds within the minute.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(
+    ///     time!(01:02:03.004_005_006).replace_second(7),
+    ///     Ok(time!(01:02:07.004_005_006))
+    /// );
+    /// assert!(time!(01:02:03.004_005_006).replace_second(60).is_err()); // 60 isn't a valid second
+    /// ```
+    #[must_use = "This method does not mutate the original `Time`."]
+    pub const fn replace_second(mut self, second: u8) -> Result<Self, error::ComponentRange> {
+        self.second = ensure_ranged!(Seconds: second);
+        Ok(self)
+    }
+
+    /// Replace the milliseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(
+    ///     time!(01:02:03.004_005_006).replace_millisecond(7),
+    ///     Ok(time!(01:02:03.007))
+    /// );
+    /// assert!(time!(01:02:03.004_005_006).replace_millisecond(1_000).is_err()); // 1_000 isn't a valid millisecond
+    /// ```
+    #[must_use = "This method does not mutate the original `Time`."]
+    pub const fn replace_millisecond(
+        mut self,
+        millisecond: u16,
+    ) -> Result<Self, error::ComponentRange> {
+        self.nanosecond =
+            ensure_ranged!(Nanoseconds: millisecond as u32 * Nanosecond::per(Millisecond));
+        Ok(self)
+    }
+
+    /// Replace the microseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(
+    ///     time!(01:02:03.004_005_006).replace_microsecond(7_008),
+    ///     Ok(time!(01:02:03.007_008))
+    /// );
+    /// assert!(time!(01:02:03.004_005_006).replace_microsecond(1_000_000).is_err()); // 1_000_000 isn't a valid microsecond
+    /// ```
+    #[must_use = "This method does not mutate the original `Time`."]
+    pub const fn replace_microsecond(
+        mut self,
+        microsecond: u32,
+    ) -> Result<Self, error::ComponentRange> {
+        self.nanosecond =
+            ensure_ranged!(Nanoseconds: microsecond * Nanosecond::per(Microsecond) as u32);
+        Ok(self)
+    }
+
+    /// Replace the nanoseconds within the second.
+    ///
+    /// ```rust
+    /// # use time_macros::time;
+    /// assert_eq!(
+    ///     time!(01:02:03.004_005_006).replace_nanosecond(7_008_009),
+    ///     Ok(time!(01:02:03.007_008_009))
+    /// );
+    /// assert!(time!(01:02:03.004_005_006).replace_nanosecond(1_000_000_000).is_err()); // 1_000_000_000 isn't a valid nanosecond
+    /// ```
+    #[must_use = "This method does not mutate the original `Time`."]
+    pub const fn replace_nanosecond(
+        mut self,
+        nanosecond: u32,
+    ) -> Result<Self, error::ComponentRange> {
+        self.nanosecond = ensure_ranged!(Nanoseconds: nanosecond);
+        Ok(self)
+    }
+    // endregion replacement
+}
+
+// region: formatting & parsing
+#[cfg(feature = "formatting")]
+impl Time {
+    /// Format the `Time` using the provided [format description](crate::format_description).
+    pub fn format_into(
+        self,
+        output: &mut impl io::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<usize, error::Format> {
+        format.format_into(output, None, Some(self), None)
+    }
+
+    /// Format the `Time` using the provided [format description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::format_description;
+    /// # use time_macros::time;
+    /// let format = format_description::parse("[hour]:[minute]:[second]")?;
+    /// assert_eq!(time!(12:00).format(&format)?, "12:00:00");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format(self, format: &(impl Formattable + ?Sized)) -> Result<String, error::Format> {
+        format.format(None, Some(self), None)
+    }
+}
+
+#[cfg(feature = "parsing")]
+impl Time {
+    /// Parse a `Time` from the input using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::Time;
+    /// # use time_macros::{time, format_description};
+    /// let format = format_description!("[hour]:[minute]:[second]");
+    /// assert_eq!(Time::parse("12:00:00", &format)?, time!(12:00));
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn parse(
+        input: &str,
+        description: &(impl Parsable + ?Sized),
+    ) -> Result<Self, error::Parse> {
+        description.parse_time(input.as_bytes())
+    }
+}
+
+mod private {
+    #[non_exhaustive]
+    #[derive(Debug, Clone, Copy)]
+    pub struct TimeMetadata {
+        /// How many characters wide the formatted subsecond is.
+        pub(super) subsecond_width: u8,
+        /// The value to use when formatting the subsecond. Leading zeroes will be added as
+        /// necessary.
+        pub(super) subsecond_value: u32,
+    }
+}
+use private::TimeMetadata;
+
+impl SmartDisplay for Time {
+    type Metadata = TimeMetadata;
+
+    fn metadata(&self, _: FormatterOptions) -> Metadata<Self> {
+        let (subsecond_value, subsecond_width) = match self.nanosecond() {
+            nanos if nanos % 10 != 0 => (nanos, 9),
+            nanos if (nanos / 10) % 10 != 0 => (nanos / 10, 8),
+            nanos if (nanos / 100) % 10 != 0 => (nanos / 100, 7),
+            nanos if (nanos / 1_000) % 10 != 0 => (nanos / 1_000, 6),
+            nanos if (nanos / 10_000) % 10 != 0 => (nanos / 10_000, 5),
+            nanos if (nanos / 100_000) % 10 != 0 => (nanos / 100_000, 4),
+            nanos if (nanos / 1_000_000) % 10 != 0 => (nanos / 1_000_000, 3),
+            nanos if (nanos / 10_000_000) % 10 != 0 => (nanos / 10_000_000, 2),
+            nanos => (nanos / 100_000_000, 1),
+        };
+
+        let formatted_width = smart_display::padded_width_of!(
+            self.hour.get(),
+            ":",
+            self.minute.get() => width(2) fill('0'),
+            ":",
+            self.second.get() => width(2) fill('0'),
+            ".",
+        ) + subsecond_width;
+
+        Metadata::new(
+            formatted_width,
+            self,
+            TimeMetadata {
+                subsecond_width: subsecond_width.truncate(),
+                subsecond_value,
+            },
+        )
+    }
+
+    fn fmt_with_metadata(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        metadata: Metadata<Self>,
+    ) -> fmt::Result {
+        let subsecond_width = metadata.subsecond_width.extend();
+        let subsecond_value = metadata.subsecond_value;
+
+        f.pad_with_width(
+            metadata.unpadded_width(),
+            format_args!(
+                "{}:{:02}:{:02}.{subsecond_value:0subsecond_width$}",
+                self.hour, self.minute, self.second
+            ),
+        )
+    }
+}
+
+impl fmt::Display for Time {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        SmartDisplay::fmt(self, f)
+    }
+}
+
+impl fmt::Debug for Time {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+// endregion formatting & parsing
+
+// region: trait impls
+impl Add<Duration> for Time {
+    type Output = Self;
+
+    /// Add the sub-day time of the [`Duration`] to the `Time`. Wraps on overflow.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// # use time_macros::time;
+    /// assert_eq!(time!(12:00) + 2.hours(), time!(14:00));
+    /// assert_eq!(time!(0:00:01) + (-2).seconds(), time!(23:59:59));
+    /// ```
+    fn add(self, duration: Duration) -> Self::Output {
+        self.adjusting_add(duration).1
+    }
+}
+
+impl Add<StdDuration> for Time {
+    type Output = Self;
+
+    /// Add the sub-day time of the [`std::time::Duration`] to the `Time`. Wraps on overflow.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalStdDuration;
+    /// # use time_macros::time;
+    /// assert_eq!(time!(12:00) + 2.std_hours(), time!(14:00));
+    /// assert_eq!(time!(23:59:59) + 2.std_seconds(), time!(0:00:01));
+    /// ```
+    fn add(self, duration: StdDuration) -> Self::Output {
+        self.adjusting_add_std(duration).1
+    }
+}
+
+impl_add_assign!(Time: Duration, StdDuration);
+
+impl Sub<Duration> for Time {
+    type Output = Self;
+
+    /// Subtract the sub-day time of the [`Duration`] from the `Time`. Wraps on overflow.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// # use time_macros::time;
+    /// assert_eq!(time!(14:00) - 2.hours(), time!(12:00));
+    /// assert_eq!(time!(23:59:59) - (-2).seconds(), time!(0:00:01));
+    /// ```
+    fn sub(self, duration: Duration) -> Self::Output {
+        self.adjusting_sub(duration).1
+    }
+}
+
+impl Sub<StdDuration> for Time {
+    type Output = Self;
+
+    /// Subtract the sub-day time of the [`std::time::Duration`] from the `Time`. Wraps on overflow.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalStdDuration;
+    /// # use time_macros::time;
+    /// assert_eq!(time!(14:00) - 2.std_hours(), time!(12:00));
+    /// assert_eq!(time!(0:00:01) - 2.std_seconds(), time!(23:59:59));
+    /// ```
+    fn sub(self, duration: StdDuration) -> Self::Output {
+        self.adjusting_sub_std(duration).1
+    }
+}
+
+impl_sub_assign!(Time: Duration, StdDuration);
+
+impl Sub for Time {
+    type Output = Duration;
+
+    /// Subtract two `Time`s, returning the [`Duration`] between. This assumes both `Time`s are in
+    /// the same calendar day.
+    ///
+    /// ```rust
+    /// # use time::ext::NumericalDuration;
+    /// # use time_macros::time;
+    /// assert_eq!(time!(0:00) - time!(0:00), 0.seconds());
+    /// assert_eq!(time!(1:00) - time!(0:00), 1.hours());
+    /// assert_eq!(time!(0:00) - time!(1:00), (-1).hours());
+    /// assert_eq!(time!(0:00) - time!(23:00), (-23).hours());
+    /// ```
+    fn sub(self, rhs: Self) -> Self::Output {
+        let hour_diff = self.hour.get().cast_signed() - rhs.hour.get().cast_signed();
+        let minute_diff = self.minute.get().cast_signed() - rhs.minute.get().cast_signed();
+        let second_diff = self.second.get().cast_signed() - rhs.second.get().cast_signed();
+        let nanosecond_diff =
+            self.nanosecond.get().cast_signed() - rhs.nanosecond.get().cast_signed();
+
+        let seconds = hour_diff.extend::<i64>() * Second::per(Hour).cast_signed().extend::<i64>()
+            + minute_diff.extend::<i64>() * Second::per(Minute).cast_signed().extend::<i64>()
+            + second_diff.extend::<i64>();
+
+        let (seconds, nanoseconds) = if seconds > 0 && nanosecond_diff < 0 {
+            (
+                seconds - 1,
+                nanosecond_diff + Nanosecond::per(Second).cast_signed(),
+            )
+        } else if seconds < 0 && nanosecond_diff > 0 {
+            (
+                seconds + 1,
+                nanosecond_diff - Nanosecond::per(Second).cast_signed(),
+            )
+        } else {
+            (seconds, nanosecond_diff)
+        };
+
+        // Safety: `nanoseconds` is in range due to the overflow handling.
+        unsafe { Duration::new_unchecked(seconds, nanoseconds) }
+    }
+}
+// endregion trait impls
diff --git a/time/src/utc_offset.rs b/time/src/utc_offset.rs
new file mode 100644
index 000000000..7cf24d141
--- /dev/null
+++ b/time/src/utc_offset.rs
@@ -0,0 +1,477 @@
+//! The [`UtcOffset`] struct and its associated `impl`s.
+
+#[cfg(feature = "formatting")]
+use alloc::string::String;
+use core::fmt;
+use core::ops::Neg;
+#[cfg(feature = "formatting")]
+use std::io;
+
+use deranged::{RangedI32, RangedI8};
+use powerfmt::ext::FormatterExt;
+use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
+
+use crate::convert::*;
+use crate::error;
+#[cfg(feature = "formatting")]
+use crate::formatting::Formattable;
+use crate::internal_macros::ensure_ranged;
+#[cfg(feature = "parsing")]
+use crate::parsing::Parsable;
+#[cfg(feature = "local-offset")]
+use crate::sys::local_offset_at;
+#[cfg(feature = "local-offset")]
+use crate::OffsetDateTime;
+
+/// The type of the `hours` field of `UtcOffset`.
+type Hours = RangedI8<-25, 25>;
+/// The type of the `minutes` field of `UtcOffset`.
+type Minutes = RangedI8<{ -(Minute::per(Hour) as i8 - 1) }, { Minute::per(Hour) as i8 - 1 }>;
+/// The type of the `seconds` field of `UtcOffset`.
+type Seconds = RangedI8<{ -(Second::per(Minute) as i8 - 1) }, { Second::per(Minute) as i8 - 1 }>;
+/// The type capable of storing the range of whole seconds that a `UtcOffset` can encompass.
+type WholeSeconds = RangedI32<
+    {
+        Hours::MIN.get() as i32 * Second::per(Hour) as i32
+            + Minutes::MIN.get() as i32 * Second::per(Minute) as i32
+            + Seconds::MIN.get() as i32
+    },
+    {
+        Hours::MAX.get() as i32 * Second::per(Hour) as i32
+            + Minutes::MAX.get() as i32 * Second::per(Minute) as i32
+            + Seconds::MAX.get() as i32
+    },
+>;
+
+/// An offset from UTC.
+///
+/// This struct can store values up to ±25:59:59. If you need support outside this range, please
+/// file an issue with your use case.
+// All three components _must_ have the same sign.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct UtcOffset {
+    #[allow(clippy::missing_docs_in_private_items)]
+    hours: Hours,
+    #[allow(clippy::missing_docs_in_private_items)]
+    minutes: Minutes,
+    #[allow(clippy::missing_docs_in_private_items)]
+    seconds: Seconds,
+}
+
+impl UtcOffset {
+    /// A `UtcOffset` that is UTC.
+    ///
+    /// ```rust
+    /// # use time::UtcOffset;
+    /// # use time_macros::offset;
+    /// assert_eq!(UtcOffset::UTC, offset!(UTC));
+    /// ```
+    pub const UTC: Self = Self::from_whole_seconds_ranged(WholeSeconds::new_static::<0>());
+
+    // region: constructors
+    /// Create a `UtcOffset` representing an offset of the hours, minutes, and seconds provided, the
+    /// validity of which must be guaranteed by the caller. All three parameters must have the same
+    /// sign.
+    ///
+    /// # Safety
+    ///
+    /// - Hours must be in the range `-25..=25`.
+    /// - Minutes must be in the range `-59..=59`.
+    /// - Seconds must be in the range `-59..=59`.
+    ///
+    /// While the signs of the parameters are required to match to avoid bugs, this is not a safety
+    /// invariant.
+    #[doc(hidden)]
+    pub const unsafe fn __from_hms_unchecked(hours: i8, minutes: i8, seconds: i8) -> Self {
+        // Safety: The caller must uphold the safety invariants.
+        unsafe {
+            Self::from_hms_ranged_unchecked(
+                Hours::new_unchecked(hours),
+                Minutes::new_unchecked(minutes),
+                Seconds::new_unchecked(seconds),
+            )
+        }
+    }
+
+    /// Create a `UtcOffset` representing an offset by the number of hours, minutes, and seconds
+    /// provided.
+    ///
+    /// The sign of all three components should match. If they do not, all smaller components will
+    /// have their signs flipped.
+    ///
+    /// ```rust
+    /// # use time::UtcOffset;
+    /// assert_eq!(UtcOffset::from_hms(1, 2, 3)?.as_hms(), (1, 2, 3));
+    /// assert_eq!(UtcOffset::from_hms(1, -2, -3)?.as_hms(), (1, 2, 3));
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub const fn from_hms(
+        hours: i8,
+        minutes: i8,
+        seconds: i8,
+    ) -> Result<Self, error::ComponentRange> {
+        Ok(Self::from_hms_ranged(
+            ensure_ranged!(Hours: hours),
+            ensure_ranged!(Minutes: minutes),
+            ensure_ranged!(Seconds: seconds),
+        ))
+    }
+
+    /// Create a `UtcOffset` representing an offset of the hours, minutes, and seconds provided. All
+    /// three parameters must have the same sign.
+    ///
+    /// While the signs of the parameters are required to match, this is not a safety invariant.
+    pub(crate) const fn from_hms_ranged_unchecked(
+        hours: Hours,
+        minutes: Minutes,
+        seconds: Seconds,
+    ) -> Self {
+        if hours.get() < 0 {
+            debug_assert!(minutes.get() <= 0);
+            debug_assert!(seconds.get() <= 0);
+        } else if hours.get() > 0 {
+            debug_assert!(minutes.get() >= 0);
+            debug_assert!(seconds.get() >= 0);
+        }
+        if minutes.get() < 0 {
+            debug_assert!(seconds.get() <= 0);
+        } else if minutes.get() > 0 {
+            debug_assert!(seconds.get() >= 0);
+        }
+
+        Self {
+            hours,
+            minutes,
+            seconds,
+        }
+    }
+
+    /// Create a `UtcOffset` representing an offset by the number of hours, minutes, and seconds
+    /// provided.
+    ///
+    /// The sign of all three components should match. If they do not, all smaller components will
+    /// have their signs flipped.
+    pub(crate) const fn from_hms_ranged(
+        hours: Hours,
+        mut minutes: Minutes,
+        mut seconds: Seconds,
+    ) -> Self {
+        if (hours.get() > 0 && minutes.get() < 0) || (hours.get() < 0 && minutes.get() > 0) {
+            minutes = minutes.neg();
+        }
+        if (hours.get() > 0 && seconds.get() < 0)
+            || (hours.get() < 0 && seconds.get() > 0)
+            || (minutes.get() > 0 && seconds.get() < 0)
+            || (minutes.get() < 0 && seconds.get() > 0)
+        {
+            seconds = seconds.neg();
+        }
+
+        Self {
+            hours,
+            minutes,
+            seconds,
+        }
+    }
+
+    /// Create a `UtcOffset` representing an offset by the number of seconds provided.
+    ///
+    /// ```rust
+    /// # use time::UtcOffset;
+    /// assert_eq!(UtcOffset::from_whole_seconds(3_723)?.as_hms(), (1, 2, 3));
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub const fn from_whole_seconds(seconds: i32) -> Result<Self, error::ComponentRange> {
+        Ok(Self::from_whole_seconds_ranged(
+            ensure_ranged!(WholeSeconds: seconds),
+        ))
+    }
+
+    /// Create a `UtcOffset` representing an offset by the number of seconds provided.
+    // ignore because the function is crate-private
+    /// ```rust,ignore
+    /// # use time::UtcOffset;
+    /// # use deranged::RangedI32;
+    /// assert_eq!(
+    ///     UtcOffset::from_whole_seconds_ranged(RangedI32::new_static::<3_723>()).as_hms(),
+    ///     (1, 2, 3)
+    /// );
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub(crate) const fn from_whole_seconds_ranged(seconds: WholeSeconds) -> Self {
+        // Safety: The type of `seconds` guarantees that all values are in range.
+        unsafe {
+            Self::__from_hms_unchecked(
+                (seconds.get() / Second::per(Hour) as i32) as _,
+                ((seconds.get() % Second::per(Hour) as i32) / Minute::per(Hour) as i32) as _,
+                (seconds.get() % Second::per(Minute) as i32) as _,
+            )
+        }
+    }
+    // endregion constructors
+
+    // region: getters
+    /// Obtain the UTC offset as its hours, minutes, and seconds. The sign of all three components
+    /// will always match. A positive value indicates an offset to the east; a negative to the west.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert_eq!(offset!(+1:02:03).as_hms(), (1, 2, 3));
+    /// assert_eq!(offset!(-1:02:03).as_hms(), (-1, -2, -3));
+    /// ```
+    pub const fn as_hms(self) -> (i8, i8, i8) {
+        (self.hours.get(), self.minutes.get(), self.seconds.get())
+    }
+
+    /// Obtain the UTC offset as its hours, minutes, and seconds. The sign of all three components
+    /// will always match. A positive value indicates an offset to the east; a negative to the west.
+    #[cfg(feature = "quickcheck")]
+    pub(crate) const fn as_hms_ranged(self) -> (Hours, Minutes, Seconds) {
+        (self.hours, self.minutes, self.seconds)
+    }
+
+    /// Obtain the number of whole hours the offset is from UTC. A positive value indicates an
+    /// offset to the east; a negative to the west.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert_eq!(offset!(+1:02:03).whole_hours(), 1);
+    /// assert_eq!(offset!(-1:02:03).whole_hours(), -1);
+    /// ```
+    pub const fn whole_hours(self) -> i8 {
+        self.hours.get()
+    }
+
+    /// Obtain the number of whole minutes the offset is from UTC. A positive value indicates an
+    /// offset to the east; a negative to the west.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert_eq!(offset!(+1:02:03).whole_minutes(), 62);
+    /// assert_eq!(offset!(-1:02:03).whole_minutes(), -62);
+    /// ```
+    pub const fn whole_minutes(self) -> i16 {
+        self.hours.get() as i16 * Minute::per(Hour) as i16 + self.minutes.get() as i16
+    }
+
+    /// Obtain the number of minutes past the hour the offset is from UTC. A positive value
+    /// indicates an offset to the east; a negative to the west.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert_eq!(offset!(+1:02:03).minutes_past_hour(), 2);
+    /// assert_eq!(offset!(-1:02:03).minutes_past_hour(), -2);
+    /// ```
+    pub const fn minutes_past_hour(self) -> i8 {
+        self.minutes.get()
+    }
+
+    /// Obtain the number of whole seconds the offset is from UTC. A positive value indicates an
+    /// offset to the east; a negative to the west.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert_eq!(offset!(+1:02:03).whole_seconds(), 3723);
+    /// assert_eq!(offset!(-1:02:03).whole_seconds(), -3723);
+    /// ```
+    // This may be useful for anyone manually implementing arithmetic, as it
+    // would let them construct a `Duration` directly.
+    pub const fn whole_seconds(self) -> i32 {
+        self.hours.get() as i32 * Second::per(Hour) as i32
+            + self.minutes.get() as i32 * Second::per(Minute) as i32
+            + self.seconds.get() as i32
+    }
+
+    /// Obtain the number of seconds past the minute the offset is from UTC. A positive value
+    /// indicates an offset to the east; a negative to the west.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert_eq!(offset!(+1:02:03).seconds_past_minute(), 3);
+    /// assert_eq!(offset!(-1:02:03).seconds_past_minute(), -3);
+    /// ```
+    pub const fn seconds_past_minute(self) -> i8 {
+        self.seconds.get()
+    }
+    // endregion getters
+
+    // region: is_{sign}
+    /// Check if the offset is exactly UTC.
+    ///
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert!(!offset!(+1:02:03).is_utc());
+    /// assert!(!offset!(-1:02:03).is_utc());
+    /// assert!(offset!(UTC).is_utc());
+    /// ```
+    pub const fn is_utc(self) -> bool {
+        self.hours.get() == 0 && self.minutes.get() == 0 && self.seconds.get() == 0
+    }
+
+    /// Check if the offset is positive, or east of UTC.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert!(offset!(+1:02:03).is_positive());
+    /// assert!(!offset!(-1:02:03).is_positive());
+    /// assert!(!offset!(UTC).is_positive());
+    /// ```
+    pub const fn is_positive(self) -> bool {
+        self.hours.get() > 0 || self.minutes.get() > 0 || self.seconds.get() > 0
+    }
+
+    /// Check if the offset is negative, or west of UTC.
+    ///
+    /// ```rust
+    /// # use time_macros::offset;
+    /// assert!(!offset!(+1:02:03).is_negative());
+    /// assert!(offset!(-1:02:03).is_negative());
+    /// assert!(!offset!(UTC).is_negative());
+    /// ```
+    pub const fn is_negative(self) -> bool {
+        self.hours.get() < 0 || self.minutes.get() < 0 || self.seconds.get() < 0
+    }
+    // endregion is_{sign}
+
+    // region: local offset
+    /// Attempt to obtain the system's UTC offset at a known moment in time. If the offset cannot be
+    /// determined, an error is returned.
+    ///
+    /// ```rust
+    /// # use time::{UtcOffset, OffsetDateTime};
+    /// let local_offset = UtcOffset::local_offset_at(OffsetDateTime::UNIX_EPOCH);
+    /// # if false {
+    /// assert!(local_offset.is_ok());
+    /// # }
+    /// ```
+    #[cfg(feature = "local-offset")]
+    pub fn local_offset_at(datetime: OffsetDateTime) -> Result<Self, error::IndeterminateOffset> {
+        local_offset_at(datetime).ok_or(error::IndeterminateOffset)
+    }
+
+    /// Attempt to obtain the system's current UTC offset. If the offset cannot be determined, an
+    /// error is returned.
+    ///
+    /// ```rust
+    /// # use time::UtcOffset;
+    /// let local_offset = UtcOffset::current_local_offset();
+    /// # if false {
+    /// assert!(local_offset.is_ok());
+    /// # }
+    /// ```
+    #[cfg(feature = "local-offset")]
+    pub fn current_local_offset() -> Result<Self, error::IndeterminateOffset> {
+        let now = OffsetDateTime::now_utc();
+        local_offset_at(now).ok_or(error::IndeterminateOffset)
+    }
+    // endregion: local offset
+}
+
+// region: formatting & parsing
+#[cfg(feature = "formatting")]
+impl UtcOffset {
+    /// Format the `UtcOffset` using the provided [format description](crate::format_description).
+    pub fn format_into(
+        self,
+        output: &mut impl io::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<usize, error::Format> {
+        format.format_into(output, None, None, Some(self))
+    }
+
+    /// Format the `UtcOffset` using the provided [format description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::format_description;
+    /// # use time_macros::offset;
+    /// let format = format_description::parse("[offset_hour sign:mandatory]:[offset_minute]")?;
+    /// assert_eq!(offset!(+1).format(&format)?, "+01:00");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format(self, format: &(impl Formattable + ?Sized)) -> Result<String, error::Format> {
+        format.format(None, None, Some(self))
+    }
+}
+
+#[cfg(feature = "parsing")]
+impl UtcOffset {
+    /// Parse a `UtcOffset` from the input using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// ```rust
+    /// # use time::UtcOffset;
+    /// # use time_macros::{offset, format_description};
+    /// let format = format_description!("[offset_hour]:[offset_minute]");
+    /// assert_eq!(UtcOffset::parse("-03:42", &format)?, offset!(-3:42));
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn parse(
+        input: &str,
+        description: &(impl Parsable + ?Sized),
+    ) -> Result<Self, error::Parse> {
+        description.parse_offset(input.as_bytes())
+    }
+}
+
+mod private {
+    #[non_exhaustive]
+    #[derive(Debug, Clone, Copy)]
+    pub struct UtcOffsetMetadata;
+}
+use private::UtcOffsetMetadata;
+
+impl SmartDisplay for UtcOffset {
+    type Metadata = UtcOffsetMetadata;
+
+    fn metadata(&self, _: FormatterOptions) -> Metadata<Self> {
+        let sign = if self.is_negative() { '-' } else { '+' };
+        let width = smart_display::padded_width_of!(
+            sign,
+            self.hours.abs() => width(2),
+            ":",
+            self.minutes.abs() => width(2),
+            ":",
+            self.seconds.abs() => width(2),
+        );
+        Metadata::new(width, self, UtcOffsetMetadata)
+    }
+
+    fn fmt_with_metadata(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        metadata: Metadata<Self>,
+    ) -> fmt::Result {
+        f.pad_with_width(
+            metadata.unpadded_width(),
+            format_args!(
+                "{}{:02}:{:02}:{:02}",
+                if self.is_negative() { '-' } else { '+' },
+                self.hours.abs(),
+                self.minutes.abs(),
+                self.seconds.abs(),
+            ),
+        )
+    }
+}
+
+impl fmt::Display for UtcOffset {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        SmartDisplay::fmt(self, f)
+    }
+}
+
+impl fmt::Debug for UtcOffset {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+// endregion formatting & parsing
+
+impl Neg for UtcOffset {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self::from_hms_ranged(self.hours.neg(), self.minutes.neg(), self.seconds.neg())
+    }
+}
diff --git a/time/src/util.rs b/time/src/util.rs
new file mode 100644
index 000000000..9bb9b0404
--- /dev/null
+++ b/time/src/util.rs
@@ -0,0 +1,99 @@
+//! Utility functions.
+
+pub use time_core::util::{days_in_year, is_leap_year, weeks_in_year};
+
+use crate::Month;
+
+/// Whether to adjust the date, and in which direction. Useful when implementing arithmetic.
+pub(crate) enum DateAdjustment {
+    /// The previous day should be used.
+    Previous,
+    /// The next day should be used.
+    Next,
+    /// The date should be used as-is.
+    None,
+}
+
+/// Get the number of days in the month of a given year.
+///
+/// ```rust
+/// # use time::{Month, util};
+/// assert_eq!(util::days_in_year_month(2020, Month::February), 29);
+/// ```
+pub const fn days_in_year_month(year: i32, month: Month) -> u8 {
+    use Month::*;
+    match month {
+        January | March | May | July | August | October | December => 31,
+        April | June | September | November => 30,
+        February if is_leap_year(year) => 29,
+        February => 28,
+    }
+}
+
+#[cfg(feature = "local-offset")]
+/// Utility functions relating to the local UTC offset.
+pub mod local_offset {
+    use core::sync::atomic::{AtomicBool, Ordering};
+
+    /// Whether obtaining the local UTC offset is required to be sound.
+    static LOCAL_OFFSET_IS_SOUND: AtomicBool = AtomicBool::new(true);
+
+    /// The soundness of obtaining the local UTC offset.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub enum Soundness {
+        /// Obtaining the local UTC offset is required to be sound. Undefined behavior will never
+        /// occur. This is the default.
+        Sound,
+        /// Obtaining the local UTC offset is allowed to invoke undefined behavior. **Setting this
+        /// value is strongly discouraged.** To do so, you must comply with the safety requirements
+        /// of [`time::local_offset::set_soundness`](set_soundness).
+        Unsound,
+    }
+
+    /// Set whether obtaining the local UTC offset is allowed to invoke undefined behavior. **Use of
+    /// this function is heavily discouraged.**
+    ///
+    /// # Safety
+    ///
+    /// If this method is called with [`Soundness::Sound`], the call is always sound. If this method
+    /// is called with [`Soundness::Unsound`], the following conditions apply.
+    ///
+    /// - If the operating system provides a thread-safe environment, the call is sound.
+    /// - If the process is single-threaded, the call is sound.
+    /// - If the process is multi-threaded, no other thread may mutate the environment in any way at
+    ///   the same time a call to a method that obtains the local UTC offset. This includes adding,
+    ///   removing, or modifying an environment variable.
+    ///
+    /// The first two conditions are automatically checked by `time`, such that you do not need to
+    /// declare your code unsound. Currently, the only known operating systems that does _not_
+    /// provide a thread-safe environment are some Unix-like OS's. All other operating systems
+    /// should succeed when attempting to obtain the local UTC offset.
+    ///
+    /// Note that you must not only verify this safety condition for your code, but for **all** code
+    /// that will be included in the final binary. Notably, it applies to both direct and transitive
+    /// dependencies and to both Rust and non-Rust code. **For this reason it is not possible to
+    /// soundly pass [`Soundness::Unsound`] to this method if you are writing a library that may
+    /// used by others.**
+    ///
+    /// If using this method is absolutely necessary, it is recommended to keep the time between
+    /// setting the soundness to [`Soundness::Unsound`] and setting it back to [`Soundness::Sound`]
+    /// as short as possible.
+    ///
+    /// The following methods currently obtain the local UTC offset:
+    ///
+    /// - [`OffsetDateTime::now_local`](crate::OffsetDateTime::now_local)
+    /// - [`UtcOffset::local_offset_at`](crate::UtcOffset::local_offset_at)
+    /// - [`UtcOffset::current_local_offset`](crate::UtcOffset::current_local_offset)
+    pub unsafe fn set_soundness(soundness: Soundness) {
+        LOCAL_OFFSET_IS_SOUND.store(soundness == Soundness::Sound, Ordering::Release);
+    }
+
+    /// Obtains the soundness of obtaining the local UTC offset. If it is [`Soundness::Unsound`],
+    /// it is allowed to invoke undefined behavior when obtaining the local UTC offset.
+    pub fn get_soundness() -> Soundness {
+        match LOCAL_OFFSET_IS_SOUND.load(Ordering::Acquire) {
+            false => Soundness::Unsound,
+            true => Soundness::Sound,
+        }
+    }
+}
diff --git a/time/src/weekday.rs b/time/src/weekday.rs
new file mode 100644
index 000000000..543ecb22c
--- /dev/null
+++ b/time/src/weekday.rs
@@ -0,0 +1,220 @@
+//! Days of the week.
+
+use core::fmt;
+use core::str::FromStr;
+
+use powerfmt::smart_display::{FormatterOptions, Metadata, SmartDisplay};
+
+use self::Weekday::*;
+use crate::error;
+
+/// Days of the week.
+///
+/// As order is dependent on context (Sunday could be either two days after or five days before
+/// Friday), this type does not implement `PartialOrd` or `Ord`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Weekday {
+    #[allow(missing_docs)]
+    Monday,
+    #[allow(missing_docs)]
+    Tuesday,
+    #[allow(missing_docs)]
+    Wednesday,
+    #[allow(missing_docs)]
+    Thursday,
+    #[allow(missing_docs)]
+    Friday,
+    #[allow(missing_docs)]
+    Saturday,
+    #[allow(missing_docs)]
+    Sunday,
+}
+
+impl Weekday {
+    /// Get the previous weekday.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Tuesday.previous(), Weekday::Monday);
+    /// ```
+    pub const fn previous(self) -> Self {
+        match self {
+            Monday => Sunday,
+            Tuesday => Monday,
+            Wednesday => Tuesday,
+            Thursday => Wednesday,
+            Friday => Thursday,
+            Saturday => Friday,
+            Sunday => Saturday,
+        }
+    }
+
+    /// Get the next weekday.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Monday.next(), Weekday::Tuesday);
+    /// ```
+    pub const fn next(self) -> Self {
+        match self {
+            Monday => Tuesday,
+            Tuesday => Wednesday,
+            Wednesday => Thursday,
+            Thursday => Friday,
+            Friday => Saturday,
+            Saturday => Sunday,
+            Sunday => Monday,
+        }
+    }
+
+    /// Get n-th next day.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Monday.nth_next(1), Weekday::Tuesday);
+    /// assert_eq!(Weekday::Sunday.nth_next(10), Weekday::Wednesday);
+    /// ```
+    pub const fn nth_next(self, n: u8) -> Self {
+        match (self.number_days_from_monday() + n % 7) % 7 {
+            0 => Monday,
+            1 => Tuesday,
+            2 => Wednesday,
+            3 => Thursday,
+            4 => Friday,
+            5 => Saturday,
+            val => {
+                debug_assert!(val == 6);
+                Sunday
+            }
+        }
+    }
+
+    /// Get n-th previous day.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Monday.nth_prev(1), Weekday::Sunday);
+    /// assert_eq!(Weekday::Sunday.nth_prev(10), Weekday::Thursday);
+    /// ```
+    pub const fn nth_prev(self, n: u8) -> Self {
+        match self.number_days_from_monday() as i8 - (n % 7) as i8 {
+            1 | -6 => Tuesday,
+            2 | -5 => Wednesday,
+            3 | -4 => Thursday,
+            4 | -3 => Friday,
+            5 | -2 => Saturday,
+            6 | -1 => Sunday,
+            val => {
+                debug_assert!(val == 0);
+                Monday
+            }
+        }
+    }
+
+    /// Get the one-indexed number of days from Monday.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Monday.number_from_monday(), 1);
+    /// ```
+    #[doc(alias = "iso_weekday_number")]
+    pub const fn number_from_monday(self) -> u8 {
+        self.number_days_from_monday() + 1
+    }
+
+    /// Get the one-indexed number of days from Sunday.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Monday.number_from_sunday(), 2);
+    /// ```
+    pub const fn number_from_sunday(self) -> u8 {
+        self.number_days_from_sunday() + 1
+    }
+
+    /// Get the zero-indexed number of days from Monday.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Monday.number_days_from_monday(), 0);
+    /// ```
+    pub const fn number_days_from_monday(self) -> u8 {
+        self as _
+    }
+
+    /// Get the zero-indexed number of days from Sunday.
+    ///
+    /// ```rust
+    /// # use time::Weekday;
+    /// assert_eq!(Weekday::Monday.number_days_from_sunday(), 1);
+    /// ```
+    pub const fn number_days_from_sunday(self) -> u8 {
+        match self {
+            Monday => 1,
+            Tuesday => 2,
+            Wednesday => 3,
+            Thursday => 4,
+            Friday => 5,
+            Saturday => 6,
+            Sunday => 0,
+        }
+    }
+}
+
+mod private {
+    #[non_exhaustive]
+    #[derive(Debug, Clone, Copy)]
+    pub struct WeekdayMetadata;
+}
+use private::WeekdayMetadata;
+
+impl SmartDisplay for Weekday {
+    type Metadata = WeekdayMetadata;
+
+    fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {
+        match self {
+            Monday => Metadata::new(6, self, WeekdayMetadata),
+            Tuesday => Metadata::new(7, self, WeekdayMetadata),
+            Wednesday => Metadata::new(9, self, WeekdayMetadata),
+            Thursday => Metadata::new(8, self, WeekdayMetadata),
+            Friday => Metadata::new(6, self, WeekdayMetadata),
+            Saturday => Metadata::new(8, self, WeekdayMetadata),
+            Sunday => Metadata::new(6, self, WeekdayMetadata),
+        }
+    }
+
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad(match self {
+            Monday => "Monday",
+            Tuesday => "Tuesday",
+            Wednesday => "Wednesday",
+            Thursday => "Thursday",
+            Friday => "Friday",
+            Saturday => "Saturday",
+            Sunday => "Sunday",
+        })
+    }
+}
+
+impl fmt::Display for Weekday {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        SmartDisplay::fmt(self, f)
+    }
+}
+
+impl FromStr for Weekday {
+    type Err = error::InvalidVariant;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "Monday" => Ok(Monday),
+            "Tuesday" => Ok(Tuesday),
+            "Wednesday" => Ok(Wednesday),
+            "Thursday" => Ok(Thursday),
+            "Friday" => Ok(Friday),
+            "Saturday" => Ok(Saturday),
+            "Sunday" => Ok(Sunday),
+            _ => Err(error::InvalidVariant),
+        }
+    }
+}