diff --git a/Cargo.lock b/Cargo.lock
index ade62e786..abd999200 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -81,7 +81,7 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -91,7 +91,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
 dependencies = [
  "anstyle",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -131,7 +131,7 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -142,7 +142,7 @@ checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -353,7 +353,7 @@ dependencies = [
  "regex",
  "rustc-hash",
  "shlex",
- "syn 2.0.72",
+ "syn 2.0.74",
  "which",
 ]
 
@@ -413,12 +413,13 @@ checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50"
 
 [[package]]
 name = "cc"
-version = "1.1.7"
+version = "1.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26a5c3fd7bfa1ce3897a3a3501d362b2d87b7f2583ebcb4a949ec25911025cbc"
+checksum = "72db2f7947ecee9b03b510377e8bb9077afa27176fdbff55c51027e976fdcc48"
 dependencies = [
  "jobserver",
  "libc",
+ "shlex",
 ]
 
 [[package]]
@@ -459,9 +460,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.13"
+version = "4.5.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fbb260a053428790f3de475e304ff84cdbc4face759ea7a3e64c1edd938a7fc"
+checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -469,9 +470,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.13"
+version = "4.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64b17d7ea74e9f833c7dbf2cbe4fb12ff26783eda4782a8975b72f895c9b4d99"
+checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6"
 dependencies = [
  "anstream",
  "anstyle",
@@ -488,7 +489,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -499,9 +500,9 @@ checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "cmake"
-version = "0.1.50"
+version = "0.1.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31c789563b815f77f4250caee12365734369f942439b7defd71e18a48197130"
+checksum = "fb1e43aa7fd152b1f968787f7dbcdeb306d1867ff373c69955211876c053f91a"
 dependencies = [
  "cc",
 ]
@@ -568,15 +569,15 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad"
 dependencies = [
  "libc",
 ]
@@ -648,7 +649,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -659,7 +660,7 @@ checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -670,7 +671,7 @@ checksum = "4e018fccbeeb50ff26562ece792ed06659b9c2dae79ece77c4456bb10d9bf79b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -694,7 +695,7 @@ checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -832,7 +833,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -985,7 +986,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -1081,7 +1082,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.3.0",
+ "indexmap 2.4.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -1100,7 +1101,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "http 1.1.0",
- "indexmap 2.3.0",
+ "indexmap 2.4.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -1174,7 +1175,7 @@ version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1356,9 +1357,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ab92f4f49ee4fb4f997c784b7a2e0fa70050211e0b6a287f898c3c9785ca956"
+checksum = "cde7055719c54e36e95e8719f95883f22072a48ede39db7fc17a4e1d5281e9b9"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -1402,9 +1403,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3fc2e30ba82dd1b3911c8de1ffc143c74a914a14e99514d7637e3099df5ea0"
+checksum = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c"
 dependencies = [
  "equivalent",
  "hashbrown 0.14.5",
@@ -1477,9 +1478,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -1547,7 +1548,7 @@ dependencies = [
  "rstest",
  "rstest_reuse",
  "snafu 0.8.4",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -1628,7 +1629,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_json",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -1676,9 +1677,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.156"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "a5f43f184355eefb8d17fc948dbecf6c13be3c141f20d834ae842193a448c72a"
 
 [[package]]
 name = "libloading"
@@ -1762,14 +1763,14 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4569e456d394deccd22ce1c1913e6ea0e54519f577285001215d33557431afe4"
+checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
 dependencies = [
  "hermit-abi",
  "libc",
  "wasi",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1863,9 +1864,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.36.2"
+version = "0.36.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f203fa8daa7bb185f760ae12bd8e097f63d17041dcdcaf675ac54cdf863170e"
+checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9"
 dependencies = [
  "memchr",
 ]
@@ -2111,7 +2112,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2142,7 +2143,7 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2200,7 +2201,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
 dependencies = [
  "proc-macro2",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2266,7 +2267,7 @@ dependencies = [
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2389,7 +2390,7 @@ dependencies = [
  "libc",
  "spin",
  "untrusted",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2439,7 +2440,7 @@ dependencies = [
  "regex",
  "relative-path",
  "rustc_version",
- "syn 2.0.72",
+ "syn 2.0.74",
  "unicode-ident",
 ]
 
@@ -2451,7 +2452,7 @@ checksum = "b3a8fb4672e840a587a66fc577a5491375df51ddb88f2a2c2a792598c326fe14"
 dependencies = [
  "quote",
  "rand",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2485,7 +2486,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2529,9 +2530,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d"
+checksum = "fc0a2ce646f8655401bb81e7927b812614bd5d91dbc968696be50603510fcaf0"
 
 [[package]]
 name = "rustls-webpki"
@@ -2563,7 +2564,7 @@ version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2588,7 +2589,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2652,9 +2653,9 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 
 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
 dependencies = [
  "serde_derive",
 ]
@@ -2671,13 +2672,13 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2688,14 +2689,14 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.122"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784b6203951c57ff748476b126ccb5e8e2959a5c19e5c617ab1956be3dbc68da"
+checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
 dependencies = [
  "itoa",
  "memchr",
@@ -2731,7 +2732,7 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.3.0",
+ "indexmap 2.4.0",
  "itoa",
  "ryu",
  "serde",
@@ -2848,7 +2849,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2858,7 +2859,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2946,7 +2947,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "stackable-operator",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -2988,7 +2989,8 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rstest",
- "syn 2.0.72",
+ "strum",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -3040,7 +3042,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -3062,9 +3064,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.72"
+version = "2.0.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc4b9b9bf2add8093d3f2c0204471e951b2285580335de42f9d2534f3ae7a8af"
+checksum = "1fceb41e3d546d0bd83421d3409b1460cc7444cd389341a4c880fe7a042cb3d7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3085,15 +3087,15 @@ checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
 
 [[package]]
 name = "tempfile"
-version = "3.11.0"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fcd239983515c23a32fb82099f97d0b11b8c72f654ed659363a95c3dad7a53"
+checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
 dependencies = [
  "cfg-if",
  "fastrand",
  "once_cell",
  "rustix",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3113,7 +3115,7 @@ checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -3212,7 +3214,7 @@ checksum = "8d9ef545650e79f30233c0003bcc2504d7efac6dad25fca40744de773fe2049c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -3229,7 +3231,7 @@ dependencies = [
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3250,7 +3252,7 @@ checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -3301,7 +3303,7 @@ version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
- "indexmap 2.3.0",
+ "indexmap 2.4.0",
  "toml_datetime",
  "winnow",
 ]
@@ -3375,15 +3377,15 @@ dependencies = [
 
 [[package]]
 name = "tower-layer"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
 
 [[package]]
 name = "tower-service"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
@@ -3417,7 +3419,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -3600,34 +3602,35 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
 dependencies = [
  "cfg-if",
+ "once_cell",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -3635,22 +3638,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
 
 [[package]]
 name = "web-time"
@@ -3705,6 +3708,15 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -3794,9 +3806,9 @@ dependencies = [
 
 [[package]]
 name = "xml-rs"
-version = "0.8.20"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "791978798f0597cfc70478424c2b4fdc2b7a8024aaff78497ef00f24ef674193"
+checksum = "539a77ee7c0de333dcc6da69b177380a0b81e0dacfa4f7344c465a36871ee601"
 
 [[package]]
 name = "zerocopy"
@@ -3816,7 +3828,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
 
 [[package]]
@@ -3836,5 +3848,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.72",
+ "syn 2.0.74",
 ]
diff --git a/crates/stackable-versioned-macros/Cargo.toml b/crates/stackable-versioned-macros/Cargo.toml
index a2552d870..eef09494e 100644
--- a/crates/stackable-versioned-macros/Cargo.toml
+++ b/crates/stackable-versioned-macros/Cargo.toml
@@ -16,6 +16,7 @@ convert_case.workspace = true
 darling.workspace = true
 itertools.workspace = true
 proc-macro2.workspace = true
+strum.workspace = true
 syn.workspace = true
 quote.workspace = true
 
diff --git a/crates/stackable-versioned-macros/src/attrs/common/item.rs b/crates/stackable-versioned-macros/src/attrs/common/item.rs
index 15b2885da..430c6eb3b 100644
--- a/crates/stackable-versioned-macros/src/attrs/common/item.rs
+++ b/crates/stackable-versioned-macros/src/attrs/common/item.rs
@@ -1,13 +1,115 @@
 use darling::{util::SpannedValue, Error, FromMeta};
 use k8s_version::Version;
 use proc_macro2::Span;
-use syn::Path;
+use syn::{spanned::Spanned, Ident, Path};
+
+use crate::{
+    attrs::common::ContainerAttributes,
+    codegen::common::Attributes,
+    consts::{DEPRECATED_FIELD_PREFIX, DEPRECATED_VARIANT_PREFIX},
+};
+
+/// This trait helps to unify attribute validation for both field and variant
+/// attributes.
+///
+/// This trait is implemented using a blanket implementation on types
+/// `T: Attributes`. The [`Attributes`] trait allows access to the common
+/// attributes shared across field and variant attributes.
+pub(crate) trait ValidateVersions<I>
+where
+    I: Spanned,
+{
+    /// Validates that each field action version is present in the declared
+    /// container versions.
+    fn validate_versions(
+        &self,
+        container_attrs: &ContainerAttributes,
+        item: &I,
+    ) -> Result<(), darling::Error>;
+}
+
+impl<I, T> ValidateVersions<I> for T
+where
+    T: Attributes,
+    I: Spanned,
+{
+    fn validate_versions(
+        &self,
+        container_attrs: &ContainerAttributes,
+        item: &I,
+    ) -> Result<(), darling::Error> {
+        // NOTE (@Techassi): Can we maybe optimize this a little?
+
+        let mut errors = Error::accumulator();
+
+        if let Some(added) = &self.common_attrs().added {
+            if !container_attrs
+                .versions
+                .iter()
+                .any(|v| v.name == *added.since)
+            {
+                errors.push(Error::custom(
+                   "variant action `added` uses version which was not declared via #[versioned(version)]")
+                   .with_span(item)
+               );
+            }
+        }
+
+        for rename in &*self.common_attrs().renames {
+            if !container_attrs
+                .versions
+                .iter()
+                .any(|v| v.name == *rename.since)
+            {
+                errors.push(
+                   Error::custom("variant action `renamed` uses version which was not declared via #[versioned(version)]")
+                   .with_span(item)
+               );
+            }
+        }
+
+        if let Some(deprecated) = &self.common_attrs().deprecated {
+            if !container_attrs
+                .versions
+                .iter()
+                .any(|v| v.name == *deprecated.since)
+            {
+                errors.push(Error::custom(
+                   "variant action `deprecated` uses version which was not declared via #[versioned(version)]")
+                   .with_span(item)
+               );
+            }
+        }
+
+        errors.finish()?;
+        Ok(())
+    }
+}
+
+// NOTE (@Techassi): It might be possible (but is it required) to move this
+// functionality into a shared trait, which knows what type of item 'Self' is.
+
+/// This enum is used to run different validation based on the type of item.
+#[derive(Debug, strum::Display)]
+#[strum(serialize_all = "lowercase")]
+pub(crate) enum ItemType {
+    Field,
+    Variant,
+}
 
 /// These attributes are meant to be used in super structs, which add
 /// [`Field`](syn::Field) or [`Variant`](syn::Variant) specific attributes via
 /// darling's flatten feature. This struct only provides shared attributes.
+///
+/// ### Shared Item Rules
+///
+/// - An item can only ever be added once at most. An item not marked as 'added'
+///   is part of the container in every version until renamed or deprecated.
+/// - An item can be renamed many times. That's why renames are stored in a
+///   [`Vec`].
+/// - An item can only be deprecated once. A field not marked as 'deprecated'
+///   will be included up until the latest version.
 #[derive(Debug, FromMeta)]
-#[darling(and_then = ItemAttributes::validate)]
 pub(crate) struct ItemAttributes {
     /// This parses the `added` attribute on items (fields or variants). It can
     /// only be present at most once.
@@ -24,8 +126,12 @@ pub(crate) struct ItemAttributes {
 }
 
 impl ItemAttributes {
-    fn validate(self) -> Result<Self, Error> {
-        // Validate deprecated options
+    pub(crate) fn validate(&self, item_ident: &Ident, item_type: &ItemType) -> Result<(), Error> {
+        // NOTE (@Techassi): This associated function is NOT called by darling's
+        // and_then attribute, but instead by the wrapper, FieldAttributes and
+        // VariantAttributes.
+
+        let mut errors = Error::accumulator();
 
         // TODO (@Techassi): Make the field 'note' optional, because in the
         // future, the macro will generate parts of the deprecation note
@@ -34,12 +140,142 @@ impl ItemAttributes {
 
         if let Some(deprecated) = &self.deprecated {
             if deprecated.note.is_empty() {
-                return Err(Error::custom("deprecation note must not be empty")
-                    .with_span(&deprecated.note.span()));
+                errors.push(
+                    Error::custom("deprecation note must not be empty")
+                        .with_span(&deprecated.note.span()),
+                );
             }
         }
 
-        Ok(self)
+        // Semantic validation
+        errors.handle(self.validate_action_combinations(item_ident, item_type));
+        errors.handle(self.validate_action_order(item_ident, item_type));
+        errors.handle(self.validate_field_name(item_ident, item_type));
+
+        // TODO (@Techassi): Add hint if a field is added in the first version
+        // that it might be clever to remove the 'added' attribute.
+
+        errors.finish()?;
+
+        Ok(())
+    }
+
+    /// This associated function is called by the top-level validation function
+    /// and validates that each item uses a valid combination of actions.
+    /// Invalid combinations are:
+    ///
+    /// - `added` and `deprecated` using the same version: A field cannot be
+    ///   marked as added in a particular version and then marked as deprecated
+    ///   immediately after. Fields must be included for at least one version
+    ///   before being marked deprecated.
+    /// - `added` and `renamed` using the same version: The same reasoning from
+    ///   above applies here as well. Fields must be included for at least one
+    ///   version before being renamed.
+    /// - `renamed` and `deprecated` using the same version: Again, the same
+    ///   rules from above apply here as well.
+    fn validate_action_combinations(
+        &self,
+        item_ident: &Ident,
+        item_type: &ItemType,
+    ) -> Result<(), Error> {
+        match (&self.added, &self.renames, &self.deprecated) {
+            (Some(added), _, Some(deprecated)) if *added.since == *deprecated.since => {
+                Err(Error::custom(format!(
+                    "{item_type} cannot be marked as `added` and `deprecated` in the same version"
+                ))
+                .with_span(item_ident))
+            }
+            (Some(added), renamed, _) if renamed.iter().any(|r| *r.since == *added.since) => {
+                Err(Error::custom(format!(
+                    "{item_type} cannot be marked as `added` and `renamed` in the same version"
+                ))
+                .with_span(item_ident))
+            }
+            (_, renamed, Some(deprecated))
+                if renamed.iter().any(|r| *r.since == *deprecated.since) =>
+            {
+                Err(Error::custom(
+                    "field cannot be marked as `deprecated` and `renamed` in the same version",
+                )
+                .with_span(item_ident))
+            }
+            _ => Ok(()),
+        }
+    }
+
+    /// This associated function is called by the top-level validation function
+    /// and validates that actions use a chronologically sound chain of
+    /// versions.
+    ///
+    /// The following rules apply:
+    ///
+    /// - `deprecated` must use a greater version than `added`: This function
+    ///   ensures that these versions are chronologically sound, that means,
+    ///   that the version of the deprecated action must be greater than the
+    ///   version of the added action.
+    /// - All `renamed` actions must use a greater version than `added` but a
+    ///   lesser version than `deprecated`.
+    fn validate_action_order(&self, item_ident: &Ident, item_type: &ItemType) -> Result<(), Error> {
+        let added_version = self.added.as_ref().map(|a| *a.since);
+        let deprecated_version = self.deprecated.as_ref().map(|d| *d.since);
+
+        // First, validate that the added version is less than the deprecated
+        // version.
+        // NOTE (@Techassi): Is this already covered by the code below?
+        if let (Some(added_version), Some(deprecated_version)) = (added_version, deprecated_version)
+        {
+            if added_version > deprecated_version {
+                return Err(Error::custom(format!(
+                    "{item_type} was marked as `added` in version `{added_version}` while being marked as `deprecated` in an earlier version `{deprecated_version}`"
+                )).with_span(item_ident));
+            }
+        }
+
+        // Now, iterate over all renames and ensure that their versions are
+        // between the added and deprecated version.
+        if !self.renames.iter().all(|r| {
+            added_version.map_or(true, |a| a < *r.since)
+                && deprecated_version.map_or(true, |d| d > *r.since)
+        }) {
+            return Err(Error::custom(
+                "all renames must use versions higher than `added` and lower than `deprecated`",
+            )
+            .with_span(item_ident));
+        }
+
+        Ok(())
+    }
+
+    /// This associated function is called by the top-level validation function
+    /// and validates that items use correct names depending on attached
+    /// actions.
+    ///
+    /// The following naming rules apply:
+    ///
+    /// - Fields marked as deprecated need to include the 'deprecated_' prefix
+    ///   in their name. The prefix must not be included for fields which are
+    ///   not deprecated.
+    fn validate_field_name(&self, item_ident: &Ident, item_type: &ItemType) -> Result<(), Error> {
+        let prefix = match item_type {
+            ItemType::Field => DEPRECATED_FIELD_PREFIX,
+            ItemType::Variant => DEPRECATED_VARIANT_PREFIX,
+        };
+
+        let starts_with_deprecated = item_ident.to_string().starts_with(prefix);
+
+        if self.deprecated.is_some() && !starts_with_deprecated {
+            return Err(Error::custom(
+                format!("{item_type} was marked as `deprecated` and thus must include the `{prefix}` prefix in its name")
+            ).with_span(item_ident));
+        }
+
+        if self.deprecated.is_none() && starts_with_deprecated {
+            return Err(Error::custom(
+                format!("{item_type} includes the `{prefix}` prefix in its name but is not marked as `deprecated`")
+            ).with_span(item_ident));
+        }
+
+        Ok(())
     }
 }
 
diff --git a/crates/stackable-versioned-macros/src/attrs/field.rs b/crates/stackable-versioned-macros/src/attrs/field.rs
index 94851a8d1..0f1e017b4 100644
--- a/crates/stackable-versioned-macros/src/attrs/field.rs
+++ b/crates/stackable-versioned-macros/src/attrs/field.rs
@@ -1,10 +1,7 @@
 use darling::{Error, FromField};
-use syn::{Field, Ident};
+use syn::Ident;
 
-use crate::{
-    attrs::common::{ContainerAttributes, ItemAttributes},
-    consts::DEPRECATED_FIELD_PREFIX,
-};
+use crate::attrs::common::{ItemAttributes, ItemType};
 
 /// This struct describes all available field attributes, as well as the field
 /// name to display better diagnostics.
@@ -12,17 +9,13 @@ use crate::{
 /// Data stored in this struct is validated using darling's `and_then` attribute.
 /// During darlings validation, it is not possible to validate that action
 /// versions match up with declared versions on the container. This validation
-/// can be done using the associated [`FieldAttributes::validate_versions`]
+/// can be done using the associated [`ValidateVersions::validate_versions`][1]
 /// function.
 ///
-/// ### Field Rules
+/// Rules shared across fields and variants can be found [here][2].
 ///
-/// - A field can only ever be added once at most. A field not marked as 'added'
-///   is part of the struct in every version until renamed or deprecated.
-/// - A field can be renamed many times. That's why renames are stored in a
-///   [`Vec`].
-/// - A field can only be deprecated once. A field not marked as 'deprecated'
-///   will be included up until the latest version.
+/// [1]: crate::attrs::common::ValidateVersions::validate_versions
+/// [2]: crate::attrs::common::ItemAttributes
 #[derive(Debug, FromField)]
 #[darling(
     attributes(versioned),
@@ -40,14 +33,6 @@ pub(crate) struct FieldAttributes {
 }
 
 impl FieldAttributes {
-    // NOTE (@Techassi): Ideally, these validations should be moved to the
-    // ItemAttributes impl, because common validation like action combinations
-    // and action order can be validated without taking the type of attribute
-    // into account (field vs variant). However, we would loose access to the
-    // field / variant ident and as such, cannot display the error directly on
-    // the affected field / variant. This is a significant decrease in DX.
-    // See https://github.com/TedDriggs/darling/discussions/294
-
     /// This associated function is called by darling (see and_then attribute)
     /// after it successfully parsed the attribute. This allows custom
     /// validation of the attribute which extends the validation already in
@@ -55,188 +40,12 @@ impl FieldAttributes {
     ///
     /// Internally, it calls out to other specialized validation functions.
     fn validate(self) -> Result<Self, Error> {
-        let mut errors = Error::accumulator();
-
-        // Semantic validation
-        errors.handle(self.validate_action_combinations());
-        errors.handle(self.validate_action_order());
-        errors.handle(self.validate_field_name());
-
-        // TODO (@Techassi): Add hint if a field is added in the first version
-        // that it might be clever to remove the 'added' attribute.
-
-        errors.finish()?;
-        Ok(self)
-    }
-
-    /// This associated function is called by the top-level validation function
-    /// and validates that each field uses a valid combination of actions.
-    /// Invalid combinations are:
-    ///
-    /// - `added` and `deprecated` using the same version: A field cannot be
-    ///   marked as added in a particular version and then marked as deprecated
-    ///   immediately after. Fields must be included for at least one version
-    ///   before being marked deprecated.
-    /// - `added` and `renamed` using the same version: The same reasoning from
-    ///   above applies here as well. Fields must be included for at least one
-    ///   version before being renamed.
-    /// - `renamed` and `deprecated` using the same version: Again, the same
-    ///   rules from above apply here as well.
-    fn validate_action_combinations(&self) -> Result<(), Error> {
-        match (
-            &self.common.added,
-            &self.common.renames,
-            &self.common.deprecated,
-        ) {
-            (Some(added), _, Some(deprecated)) if *added.since == *deprecated.since => {
-                Err(Error::custom(
-                    "field cannot be marked as `added` and `deprecated` in the same version",
-                )
-                .with_span(&self.ident))
-            }
-            (Some(added), renamed, _) if renamed.iter().any(|r| *r.since == *added.since) => {
-                Err(Error::custom(
-                    "field cannot be marked as `added` and `renamed` in the same version",
-                )
-                .with_span(&self.ident))
-            }
-            (_, renamed, Some(deprecated))
-                if renamed.iter().any(|r| *r.since == *deprecated.since) =>
-            {
-                Err(Error::custom(
-                    "field cannot be marked as `deprecated` and `renamed` in the same version",
-                )
-                .with_span(&self.ident))
-            }
-            _ => Ok(()),
-        }
-    }
-
-    /// This associated function is called by the top-level validation function
-    /// and validates that actions use a chronologically sound chain of
-    /// versions.
-    ///
-    /// The following rules apply:
-    ///
-    /// - `deprecated` must use a greater version than `added`: This function
-    ///   ensures that these versions are chronologically sound, that means,
-    ///   that the version of the deprecated action must be greater than the
-    ///   version of the added action.
-    /// - All `renamed` actions must use a greater version than `added` but a
-    ///   lesser version than `deprecated`.
-    fn validate_action_order(&self) -> Result<(), Error> {
-        let added_version = self.common.added.as_ref().map(|a| *a.since);
-        let deprecated_version = self.common.deprecated.as_ref().map(|d| *d.since);
-
-        // First, validate that the added version is less than the deprecated
-        // version.
-        // NOTE (@Techassi): Is this already covered by the code below?
-        if let (Some(added_version), Some(deprecated_version)) = (added_version, deprecated_version)
-        {
-            if added_version > deprecated_version {
-                return Err(Error::custom(format!(
-                    "field was marked as `added` in version `{added_version}` while being marked as `deprecated` in an earlier version `{deprecated_version}`"
-                )).with_span(&self.ident));
-            }
-        }
-
-        // Now, iterate over all renames and ensure that their versions are
-        // between the added and deprecated version.
-        if !self.common.renames.iter().all(|r| {
-            added_version.map_or(true, |a| a < *r.since)
-                && deprecated_version.map_or(true, |d| d > *r.since)
-        }) {
-            return Err(Error::custom(
-                "all renames must use versions higher than `added` and lower than `deprecated`",
-            )
-            .with_span(&self.ident));
-        }
-
-        Ok(())
-    }
-
-    /// This associated function is called by the top-level validation function
-    /// and validates that fields use correct names depending on attached
-    /// actions.
-    ///
-    /// The following naming rules apply:
-    ///
-    /// - Fields marked as deprecated need to include the 'deprecated_' prefix
-    ///   in their name. The prefix must not be included for fields which are
-    ///   not deprecated.
-    fn validate_field_name(&self) -> Result<(), Error> {
-        let starts_with_deprecated = self
+        let ident = self
             .ident
             .as_ref()
-            .expect("internal error: to be validated fields must have a name")
-            .to_string()
-            .starts_with(DEPRECATED_FIELD_PREFIX);
-
-        if self.common.deprecated.is_some() && !starts_with_deprecated {
-            return Err(Error::custom(
-                "field was marked as `deprecated` and thus must include the `deprecated_` prefix in its name"
-            ).with_span(&self.ident));
-        }
-
-        if self.common.deprecated.is_none() && starts_with_deprecated {
-            return Err(Error::custom(
-                "field includes the `deprecated_` prefix in its name but is not marked as `deprecated`"
-            ).with_span(&self.ident));
-        }
+            .expect("internal error: field must have an ident");
+        self.common.validate(ident, &ItemType::Field)?;
 
-        Ok(())
-    }
-
-    /// Validates that each field action version is present in the declared
-    /// container versions.
-    pub(crate) fn validate_versions(
-        &self,
-        container_attrs: &ContainerAttributes,
-        field: &Field,
-    ) -> Result<(), Error> {
-        // NOTE (@Techassi): Can we maybe optimize this a little?
-        let mut errors = Error::accumulator();
-
-        if let Some(added) = &self.common.added {
-            if !container_attrs
-                .versions
-                .iter()
-                .any(|v| v.name == *added.since)
-            {
-                errors.push(Error::custom(
-                    "field action `added` uses version which was not declared via #[versioned(version)]")
-                    .with_span(&field.ident)
-                );
-            }
-        }
-
-        for rename in &self.common.renames {
-            if !container_attrs
-                .versions
-                .iter()
-                .any(|v| v.name == *rename.since)
-            {
-                errors.push(
-                    Error::custom("field action `renamed` uses version which was not declared via #[versioned(version)]")
-                    .with_span(&field.ident)
-                );
-            }
-        }
-
-        if let Some(deprecated) = &self.common.deprecated {
-            if !container_attrs
-                .versions
-                .iter()
-                .any(|v| v.name == *deprecated.since)
-            {
-                errors.push(Error::custom(
-                    "field action `deprecated` uses version which was not declared via #[versioned(version)]")
-                    .with_span(&field.ident)
-                );
-            }
-        }
-
-        errors.finish()?;
-        Ok(())
+        Ok(self)
     }
 }
diff --git a/crates/stackable-versioned-macros/src/attrs/variant.rs b/crates/stackable-versioned-macros/src/attrs/variant.rs
index 75f3ebd59..557e082e4 100644
--- a/crates/stackable-versioned-macros/src/attrs/variant.rs
+++ b/crates/stackable-versioned-macros/src/attrs/variant.rs
@@ -1,12 +1,22 @@
 use convert_case::{Case, Casing};
 use darling::{Error, FromVariant};
-use syn::{Ident, Variant};
-
-use crate::{
-    attrs::common::{ContainerAttributes, ItemAttributes},
-    consts::DEPRECATED_VARIANT_PREFIX,
-};
-
+use syn::Ident;
+
+use crate::attrs::common::{ItemAttributes, ItemType};
+
+/// This struct describes all available variant attributes, as well as the
+/// variant name to display better diagnostics.
+///
+/// Data stored in this struct is validated using darling's `and_then` attribute.
+/// During darlings validation, it is not possible to validate that action
+/// versions match up with declared versions on the container. This validation
+/// can be done using the associated [`ValidateVersions::validate_versions`][1]
+/// function.
+///
+/// Rules shared across fields and variants can be found [here][2].
+///
+/// [1]: crate::attrs::common::ValidateVersions::validate_versions
+/// [2]: crate::attrs::common::ItemAttributes
 #[derive(Debug, FromVariant)]
 #[darling(
     attributes(versioned),
@@ -24,14 +34,6 @@ pub(crate) struct VariantAttributes {
 }
 
 impl VariantAttributes {
-    // NOTE (@Techassi): Ideally, these validations should be moved to the
-    // ItemAttributes impl, because common validation like action combinations
-    // and action order can be validated without taking the type of attribute
-    // into account (field vs variant). However, we would loose access to the
-    // field / variant ident and as such, cannot display the error directly on
-    // the affected field / variant. This is a significant decrease in DX.
-    // See https://github.com/TedDriggs/darling/discussions/294
-
     /// This associated function is called by darling (see and_then attribute)
     /// after it successfully parsed the attribute. This allows custom
     /// validation of the attribute which extends the validation already in
@@ -41,193 +43,19 @@ impl VariantAttributes {
     fn validate(self) -> Result<Self, Error> {
         let mut errors = Error::accumulator();
 
-        // Semantic validation
-        errors.handle(self.validate_action_combinations());
-        errors.handle(self.validate_action_order());
-        errors.handle(self.validate_variant_name());
-
-        // TODO (@Techassi): Add hint if a item is added in the first version
-        // that it might be clever to remove the 'added' attribute.
-
-        errors.finish()?;
-        Ok(self)
-    }
-
-    /// This associated function is called by the top-level validation function
-    /// and validates that each variant uses a valid combination of actions.
-    /// Invalid combinations are:
-    ///
-    /// - `added` and `deprecated` using the same version: A variant cannot be
-    ///   marked as added in a particular version and then marked as deprecated
-    ///   immediately after. Variants must be included for at least one version
-    ///   before being marked deprecated.
-    /// - `added` and `renamed` using the same version: The same reasoning from
-    ///   above applies here as well. Variants must be included for at least one
-    ///   version before being renamed.
-    /// - `renamed` and `deprecated` using the same version: Again, the same
-    ///   rules from above apply here as well.
-    fn validate_action_combinations(&self) -> Result<(), Error> {
-        match (
-            &self.common.added,
-            &self.common.renames,
-            &self.common.deprecated,
-        ) {
-            (Some(added), _, Some(deprecated)) if *added.since == *deprecated.since => {
-                Err(Error::custom(
-                    "variant cannot be marked as `added` and `deprecated` in the same version",
-                )
-                .with_span(&self.ident))
-            }
-            (Some(added), renamed, _) if renamed.iter().any(|r| *r.since == *added.since) => {
-                Err(Error::custom(
-                    "variant cannot be marked as `added` and `renamed` in the same version",
-                )
-                .with_span(&self.ident))
-            }
-            (_, renamed, Some(deprecated))
-                if renamed.iter().any(|r| *r.since == *deprecated.since) =>
-            {
-                Err(Error::custom(
-                    "variant cannot be marked as `deprecated` and `renamed` in the same version",
-                )
-                .with_span(&self.ident))
-            }
-            _ => Ok(()),
-        }
-    }
-
-    /// This associated function is called by the top-level validation function
-    /// and validates that actions use a chronologically sound chain of
-    /// versions.
-    ///
-    /// The following rules apply:
-    ///
-    /// - `deprecated` must use a greater version than `added`: This function
-    ///   ensures that these versions are chronologically sound, that means,
-    ///   that the version of the deprecated action must be greater than the
-    ///   version of the added action.
-    /// - All `renamed` actions must use a greater version than `added` but a
-    ///   lesser version than `deprecated`.
-    fn validate_action_order(&self) -> Result<(), Error> {
-        let added_version = self.common.added.as_ref().map(|a| *a.since);
-        let deprecated_version = self.common.deprecated.as_ref().map(|d| *d.since);
-
-        // First, validate that the added version is less than the deprecated
-        // version.
-        // NOTE (@Techassi): Is this already covered by the code below?
-        if let (Some(added_version), Some(deprecated_version)) = (added_version, deprecated_version)
-        {
-            if added_version > deprecated_version {
-                return Err(Error::custom(format!(
-                    "variant was marked as `added` in version `{added_version}` while being marked as `deprecated` in an earlier version `{deprecated_version}`"
-                )).with_span(&self.ident));
-            }
-        }
-
-        // Now, iterate over all renames and ensure that their versions are
-        // between the added and deprecated version.
-        if !self.common.renames.iter().all(|r| {
-            added_version.map_or(true, |a| a < *r.since)
-                && deprecated_version.map_or(true, |d| d > *r.since)
-        }) {
-            return Err(Error::custom(
-                "all renames must use versions higher than `added` and lower than `deprecated`",
-            )
-            .with_span(&self.ident));
-        }
-
-        Ok(())
-    }
+        errors.handle(self.common.validate(&self.ident, &ItemType::Variant));
 
-    /// This associated function is called by the top-level validation function
-    /// and validates that variants use correct names depending on attached
-    /// actions.
-    ///
-    /// The following naming rules apply:
-    ///
-    /// - Variants marked as deprecated need to include the 'deprecated_' prefix
-    ///   in their name. The prefix must not be included for variants which are
-    ///   not deprecated.
-    fn validate_variant_name(&self) -> Result<(), Error> {
+        // Validate names of renames
         if !self
             .common
             .renames
             .iter()
             .all(|r| r.from.is_case(Case::Pascal))
         {
-            return Err(Error::custom("renamed variants must use PascalCase"));
-        }
-
-        let starts_with_deprecated = self
-            .ident
-            .to_string()
-            .starts_with(DEPRECATED_VARIANT_PREFIX);
-
-        if self.common.deprecated.is_some() && !starts_with_deprecated {
-            return Err(Error::custom(
-                "variant was marked as `deprecated` and thus must include the `Deprecated` prefix in its name"
-            ).with_span(&self.ident));
-        }
-
-        if self.common.deprecated.is_none() && starts_with_deprecated {
-            return Err(Error::custom(
-                "variant includes the `Deprecated` prefix in its name but is not marked as `deprecated`"
-            ).with_span(&self.ident));
-        }
-
-        Ok(())
-    }
-
-    pub(crate) fn validate_versions(
-        &self,
-        container_attrs: &ContainerAttributes,
-        variant: &Variant,
-    ) -> Result<(), Error> {
-        // NOTE (@Techassi): Can we maybe optimize this a little?
-        // TODO (@Techassi): Unify this with the field impl, e.g. by introducing
-        // a T: Spanned bound for the second function parameter.
-        let mut errors = Error::accumulator();
-
-        if let Some(added) = &self.common.added {
-            if !container_attrs
-                .versions
-                .iter()
-                .any(|v| v.name == *added.since)
-            {
-                errors.push(Error::custom(
-                   "variant action `added` uses version which was not declared via #[versioned(version)]")
-                   .with_span(&variant.ident)
-               );
-            }
-        }
-
-        for rename in &*self.common.renames {
-            if !container_attrs
-                .versions
-                .iter()
-                .any(|v| v.name == *rename.since)
-            {
-                errors.push(
-                   Error::custom("variant action `renamed` uses version which was not declared via #[versioned(version)]")
-                   .with_span(&variant.ident)
-               );
-            }
-        }
-
-        if let Some(deprecated) = &self.common.deprecated {
-            if !container_attrs
-                .versions
-                .iter()
-                .any(|v| v.name == *deprecated.since)
-            {
-                errors.push(Error::custom(
-                   "variant action `deprecated` uses version which was not declared via #[versioned(version)]")
-                   .with_span(&variant.ident)
-               );
-            }
+            errors.push(Error::custom("renamed variants must use PascalCase"));
         }
 
         errors.finish()?;
-        Ok(())
+        Ok(self)
     }
 }
diff --git a/crates/stackable-versioned-macros/src/gen/chain.rs b/crates/stackable-versioned-macros/src/codegen/chain.rs
similarity index 86%
rename from crates/stackable-versioned-macros/src/gen/chain.rs
rename to crates/stackable-versioned-macros/src/codegen/chain.rs
index 47675bcb6..097214b69 100644
--- a/crates/stackable-versioned-macros/src/gen/chain.rs
+++ b/crates/stackable-versioned-macros/src/codegen/chain.rs
@@ -14,6 +14,15 @@ impl<K, V> Neighbors<K, V> for BTreeMap<K, V>
 where
     K: Ord + Eq,
 {
+    /// Returns the values of keys which are neighbors of `key`.
+    ///
+    /// Given a map which contains the following keys: 1, 3, 5. Calling this
+    /// function with these keys, results in the following return values:
+    ///
+    /// - Key **0**: `(None, Some(1))`
+    /// - Key **2**: `(Some(1), Some(3))`
+    /// - Key **4**: `(Some(3), Some(5))`
+    /// - Key **6**: `(Some(5), None)`
     fn get_neighbors(&self, key: &K) -> (Option<&V>, Option<&V>) {
         // NOTE (@Techassi): These functions might get added to the standard
         // library at some point. If that's the case, we can use the ones
diff --git a/crates/stackable-versioned-macros/src/codegen/common/container.rs b/crates/stackable-versioned-macros/src/codegen/common/container.rs
new file mode 100644
index 000000000..0e211897a
--- /dev/null
+++ b/crates/stackable-versioned-macros/src/codegen/common/container.rs
@@ -0,0 +1,43 @@
+use std::ops::Deref;
+
+use proc_macro2::TokenStream;
+use syn::Ident;
+
+use crate::{attrs::common::ContainerAttributes, codegen::common::ContainerVersion};
+
+/// This trait helps to unify versioned containers, like structs and enums.
+///
+/// This trait is implemented by wrapper structs, which wrap the generic
+/// [`VersionedContainer`] struct. The generic type parameter `D` describes the
+/// kind of data, like [`DataStruct`](syn::DataStruct) in case of a struct and
+/// [`DataEnum`](syn::DataEnum) in case of an enum.
+/// The type parameter `I` describes the type of the versioned items, like
+/// [`VersionedField`][1] and [`VersionedVariant`][2].
+///
+/// [1]: crate::codegen::vstruct::field::VersionedField
+/// [2]: crate::codegen::venum::variant::VersionedVariant
+pub(crate) trait Container<D, I>
+where
+    Self: Sized + Deref<Target = VersionedContainer<I>>,
+{
+    /// Creates a new versioned container.
+    fn new(ident: Ident, data: D, attributes: ContainerAttributes) -> syn::Result<Self>;
+
+    /// This generates the complete code for a single versioned container.
+    ///
+    /// Internally, it will create a module for each declared version which
+    /// contains the container with the appropriate items (fields or variants)
+    /// Additionally, it generates `From` implementations, which enable
+    /// conversion from an older to a newer version.
+    fn generate_tokens(&self) -> TokenStream;
+}
+
+#[derive(Debug)]
+pub(crate) struct VersionedContainer<I> {
+    pub(crate) versions: Vec<ContainerVersion>,
+    pub(crate) items: Vec<I>,
+    pub(crate) ident: Ident,
+
+    pub(crate) from_ident: Ident,
+    pub(crate) skip_from: bool,
+}
diff --git a/crates/stackable-versioned-macros/src/codegen/common/item.rs b/crates/stackable-versioned-macros/src/codegen/common/item.rs
new file mode 100644
index 000000000..347e22c7c
--- /dev/null
+++ b/crates/stackable-versioned-macros/src/codegen/common/item.rs
@@ -0,0 +1,316 @@
+use std::{collections::BTreeMap, marker::PhantomData, ops::Deref};
+
+use quote::format_ident;
+use syn::{spanned::Spanned, Ident, Path};
+
+use crate::{
+    attrs::common::{ContainerAttributes, ItemAttributes, ValidateVersions},
+    codegen::{
+        chain::Neighbors,
+        common::{ContainerVersion, VersionChain},
+    },
+};
+
+/// This trait describes versioned container items, fields and variants in a
+/// common way.
+///
+/// Shared functionality is implemented in a single place. Code which cannot be
+/// shared is implemented on the wrapping type, like [`VersionedField`][1].
+///
+/// [1]: crate::codegen::vstruct::field::VersionedField
+pub(crate) trait Item<I, A>: Sized
+where
+    A: for<'i> TryFrom<&'i I> + Attributes,
+    I: Named + Spanned,
+{
+    /// Creates a new versioned item (struct field or enum variant) by consuming
+    /// the parsed [Field](syn::Field) or [Variant](syn::Variant) and validating
+    /// the versions of field actions against versions attached on the container.
+    fn new(item: I, container_attrs: &ContainerAttributes) -> syn::Result<Self>;
+
+    /// Inserts container versions not yet present in the status chain.
+    ///
+    /// When initially creating a new versioned item, the code doesn't have
+    /// access to the versions defined on the container. This function inserts
+    /// all non-present container versions and decides which status and ident
+    /// is the right fit based on the status neighbors.
+    ///
+    /// This continuous chain ensures that when generating code (tokens), each
+    /// field can lookup the status (and ident) for a requested version.
+    fn insert_container_versions(&mut self, versions: &[ContainerVersion]);
+
+    /// Returns the ident of the item based on the provided container version.
+    fn get_ident(&self, version: &ContainerVersion) -> Option<&Ident>;
+}
+
+/// This trait enables access to the ident of named items, like fields and
+/// variants.
+///
+/// It additionally provides a function to retrieve the cleaned ident, which
+/// removes the deprecation prefixes.
+pub(crate) trait Named {
+    fn cleaned_ident(&self) -> Ident;
+    fn ident(&self) -> &Ident;
+}
+
+/// This trait enables access to the common attributes across field and variant
+/// attributes.
+pub(crate) trait Attributes {
+    fn common_attrs_owned(self) -> ItemAttributes;
+    fn common_attrs(&self) -> &ItemAttributes;
+}
+
+/// This struct combines common code for versioned fields and variants.
+///
+/// Most of the initial creation of a versioned field and variant are identical.
+/// Currently, the following steps are unified:
+///
+/// - Initial creation of the action chain based on item attributes.
+/// - Insertion of container versions into the chain.
+///
+/// The generic type parameter `I` describes the type of the versioned item,
+/// usually [`Field`](syn::Field) or [`Variant`](syn::Variant). The parameter
+/// `A` indicates the type of item attributes, usually [`FieldAttributes`][1] or
+/// [`VariantAttributes`][2] depending on the used item type. As this type is
+/// only needed during creation of [`Self`](VersionedItem), we must use a
+/// [`PhantomData`] marker.
+///
+/// [1]: crate::attrs::field::FieldAttributes
+/// [2]: crate::attrs::variant::VariantAttributes
+#[derive(Debug)]
+pub(crate) struct VersionedItem<I, A>
+where
+    A: for<'i> TryFrom<&'i I> + Attributes,
+    I: Named + Spanned,
+{
+    pub(crate) chain: Option<VersionChain>,
+    pub(crate) inner: I,
+    _marker: PhantomData<A>,
+}
+
+impl<I, A> Item<I, A> for VersionedItem<I, A>
+where
+    syn::Error: for<'i> From<<A as TryFrom<&'i I>>::Error>,
+    A: for<'i> TryFrom<&'i I> + Attributes + ValidateVersions<I>,
+    I: Named + Spanned,
+{
+    fn new(item: I, container_attrs: &ContainerAttributes) -> syn::Result<Self> {
+        // We use the TryFrom trait here, because the type parameter `A` can use
+        // it as a trait bound. Internally this then calls either `from_field`
+        // for field attributes or `from_variant` for variant attributes. Sadly
+        // darling doesn't provide a "generic" trait which abstracts over the
+        // different `from_` functions.
+        let attrs = A::try_from(&item)?;
+        attrs.validate_versions(container_attrs, &item)?;
+
+        let item_attrs = attrs.common_attrs_owned();
+
+        // Constructing the action chain requires going through the actions
+        // starting at the end, because the container definition always
+        // represents the latest (most up-to-date) version of that struct.
+        // That's why the following code needs to go through the actions in
+        // reverse order, as otherwise it is impossible to extract the item
+        // ident for each version.
+
+        // Deprecating an item is always the last state an item can end up in.
+        // For items which are not deprecated, the last change is either the
+        // latest rename or addition, which is handled below. The ident of the
+        // deprecated item is guaranteed to include the 'deprecated_' or
+        // 'DEPRECATED_' prefix. The ident can thus be used as is.
+        if let Some(deprecated) = item_attrs.deprecated {
+            let deprecated_ident = item.ident();
+
+            // When the item is deprecated, any rename which occurred beforehand
+            // requires access to the item ident to infer the item ident for
+            // the latest rename.
+            let mut ident = item.cleaned_ident();
+            let mut actions = BTreeMap::new();
+
+            actions.insert(
+                *deprecated.since,
+                ItemStatus::Deprecated {
+                    previous_ident: ident.clone(),
+                    ident: deprecated_ident.clone(),
+                    note: deprecated.note.to_string(),
+                },
+            );
+
+            for rename in item_attrs.renames.iter().rev() {
+                let from = format_ident!("{from}", from = *rename.from);
+                actions.insert(
+                    *rename.since,
+                    ItemStatus::Renamed {
+                        from: from.clone(),
+                        to: ident,
+                    },
+                );
+                ident = from;
+            }
+
+            // After the last iteration above (if any) we use the ident for the
+            // added action if there is any.
+            if let Some(added) = item_attrs.added {
+                actions.insert(
+                    *added.since,
+                    ItemStatus::Added {
+                        default_fn: added.default_fn.deref().clone(),
+                        ident,
+                    },
+                );
+            }
+
+            Ok(Self {
+                _marker: PhantomData,
+                chain: Some(actions),
+                inner: item,
+            })
+        } else if !item_attrs.renames.is_empty() {
+            let mut actions = BTreeMap::new();
+            let mut ident = item.ident().clone();
+
+            for rename in item_attrs.renames.iter().rev() {
+                let from = format_ident!("{from}", from = *rename.from);
+                actions.insert(
+                    *rename.since,
+                    ItemStatus::Renamed {
+                        from: from.clone(),
+                        to: ident,
+                    },
+                );
+                ident = from;
+            }
+
+            // After the last iteration above (if any) we use the ident for the
+            // added action if there is any.
+            if let Some(added) = item_attrs.added {
+                actions.insert(
+                    *added.since,
+                    ItemStatus::Added {
+                        default_fn: added.default_fn.deref().clone(),
+                        ident,
+                    },
+                );
+            }
+
+            Ok(Self {
+                _marker: PhantomData,
+                chain: Some(actions),
+                inner: item,
+            })
+        } else {
+            if let Some(added) = item_attrs.added {
+                let mut actions = BTreeMap::new();
+
+                actions.insert(
+                    *added.since,
+                    ItemStatus::Added {
+                        default_fn: added.default_fn.deref().clone(),
+                        ident: item.ident().clone(),
+                    },
+                );
+
+                return Ok(Self {
+                    _marker: PhantomData,
+                    chain: Some(actions),
+                    inner: item,
+                });
+            }
+
+            Ok(Self {
+                _marker: PhantomData,
+                chain: None,
+                inner: item,
+            })
+        }
+    }
+
+    fn insert_container_versions(&mut self, versions: &[ContainerVersion]) {
+        if let Some(chain) = &mut self.chain {
+            for version in versions {
+                if chain.contains_key(&version.inner) {
+                    continue;
+                }
+
+                match chain.get_neighbors(&version.inner) {
+                    (None, Some(status)) => match status {
+                        ItemStatus::Added { .. } => {
+                            chain.insert(version.inner, ItemStatus::NotPresent)
+                        }
+                        ItemStatus::Renamed { from, .. } => {
+                            chain.insert(version.inner, ItemStatus::NoChange(from.clone()))
+                        }
+                        ItemStatus::Deprecated { previous_ident, .. } => chain
+                            .insert(version.inner, ItemStatus::NoChange(previous_ident.clone())),
+                        ItemStatus::NoChange(ident) => {
+                            chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
+                        }
+                        ItemStatus::NotPresent => unreachable!(),
+                    },
+                    (Some(status), None) => {
+                        let ident = match status {
+                            ItemStatus::Added { ident, .. } => ident,
+                            ItemStatus::Renamed { to, .. } => to,
+                            ItemStatus::Deprecated { ident, .. } => ident,
+                            ItemStatus::NoChange(ident) => ident,
+                            ItemStatus::NotPresent => unreachable!(),
+                        };
+
+                        chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
+                    }
+                    (Some(status), Some(_)) => {
+                        let ident = match status {
+                            ItemStatus::Added { ident, .. } => ident,
+                            ItemStatus::Renamed { to, .. } => to,
+                            ItemStatus::NoChange(ident) => ident,
+                            _ => unreachable!(),
+                        };
+
+                        chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
+                    }
+                    _ => unreachable!(),
+                };
+            }
+        }
+    }
+
+    fn get_ident(&self, version: &ContainerVersion) -> Option<&Ident> {
+        match &self.chain {
+            Some(chain) => chain
+                .get(&version.inner)
+                .expect("internal error: chain must contain container version")
+                .get_ident(),
+            None => Some(self.inner.ident()),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum ItemStatus {
+    Added {
+        ident: Ident,
+        default_fn: Path,
+    },
+    Renamed {
+        from: Ident,
+        to: Ident,
+    },
+    Deprecated {
+        previous_ident: Ident,
+        ident: Ident,
+        note: String,
+    },
+    NoChange(Ident),
+    NotPresent,
+}
+
+impl ItemStatus {
+    pub(crate) fn get_ident(&self) -> Option<&Ident> {
+        match &self {
+            ItemStatus::Added { ident, .. } => Some(ident),
+            ItemStatus::Renamed { to, .. } => Some(to),
+            ItemStatus::Deprecated { ident, .. } => Some(ident),
+            ItemStatus::NoChange(ident) => Some(ident),
+            ItemStatus::NotPresent => None,
+        }
+    }
+}
diff --git a/crates/stackable-versioned-macros/src/codegen/common/mod.rs b/crates/stackable-versioned-macros/src/codegen/common/mod.rs
new file mode 100644
index 000000000..93668e768
--- /dev/null
+++ b/crates/stackable-versioned-macros/src/codegen/common/mod.rs
@@ -0,0 +1,75 @@
+use std::collections::BTreeMap;
+
+use k8s_version::Version;
+use proc_macro2::Span;
+use quote::format_ident;
+use syn::Ident;
+
+use crate::{
+    attrs::common::ContainerAttributes,
+    consts::{DEPRECATED_FIELD_PREFIX, DEPRECATED_VARIANT_PREFIX},
+};
+
+mod container;
+mod item;
+
+pub(crate) use container::*;
+pub(crate) use item::*;
+
+/// Type alias to make the type of the version chain easier to handle.
+pub(crate) type VersionChain = BTreeMap<Version, ItemStatus>;
+
+#[derive(Debug, Clone)]
+pub(crate) struct ContainerVersion {
+    /// Indicates that the container version is deprecated.
+    pub(crate) deprecated: bool,
+
+    /// Indicates that the generation of `From<OLD> for NEW` should be skipped.
+    pub(crate) skip_from: bool,
+
+    /// A validated Kubernetes API version.
+    pub(crate) inner: Version,
+
+    /// The ident of the container.
+    pub(crate) ident: Ident,
+}
+
+impl From<&ContainerAttributes> for Vec<ContainerVersion> {
+    fn from(attributes: &ContainerAttributes) -> Self {
+        attributes
+            .versions
+            .iter()
+            .map(|v| ContainerVersion {
+                skip_from: v.skip.as_ref().map_or(false, |s| s.from.is_present()),
+                ident: Ident::new(&v.name.to_string(), Span::call_site()),
+                deprecated: v.deprecated.is_present(),
+                inner: v.name,
+            })
+            .collect()
+    }
+}
+
+/// Returns the container ident used in [`From`] implementations.
+pub(crate) fn format_container_from_ident(ident: &Ident) -> Ident {
+    format_ident!("__sv_{ident}", ident = ident.to_string().to_lowercase())
+}
+
+/// Removes the deprecated prefix from a field ident.
+///
+/// See [`DEPRECATED_FIELD_PREFIX`].
+pub(crate) fn remove_deprecated_field_prefix(ident: &Ident) -> Ident {
+    remove_ident_prefix(ident, DEPRECATED_FIELD_PREFIX)
+}
+
+/// Removes the deprecated prefix from a variant ident.
+///
+/// See [`DEPRECATED_VARIANT_PREFIX`].
+pub(crate) fn remove_deprecated_variant_prefix(ident: &Ident) -> Ident {
+    remove_ident_prefix(ident, DEPRECATED_VARIANT_PREFIX)
+}
+
+/// Removes the provided prefix from an ident and returns the newly created
+/// ident.
+pub(crate) fn remove_ident_prefix(ident: &Ident, prefix: &str) -> Ident {
+    format_ident!("{}", ident.to_string().trim_start_matches(prefix))
+}
diff --git a/crates/stackable-versioned-macros/src/gen/mod.rs b/crates/stackable-versioned-macros/src/codegen/mod.rs
similarity index 94%
rename from crates/stackable-versioned-macros/src/gen/mod.rs
rename to crates/stackable-versioned-macros/src/codegen/mod.rs
index ea069d445..da964e988 100644
--- a/crates/stackable-versioned-macros/src/gen/mod.rs
+++ b/crates/stackable-versioned-macros/src/codegen/mod.rs
@@ -3,7 +3,7 @@ use syn::{spanned::Spanned, Data, DeriveInput, Error, Result};
 
 use crate::{
     attrs::common::ContainerAttributes,
-    gen::{common::Container, venum::VersionedEnum, vstruct::VersionedStruct},
+    codegen::{common::Container, venum::VersionedEnum, vstruct::VersionedStruct},
 };
 
 pub(crate) mod chain;
diff --git a/crates/stackable-versioned-macros/src/gen/venum/mod.rs b/crates/stackable-versioned-macros/src/codegen/venum/mod.rs
similarity index 89%
rename from crates/stackable-versioned-macros/src/gen/venum/mod.rs
rename to crates/stackable-versioned-macros/src/codegen/venum/mod.rs
index 3d417ecef..46db0af71 100644
--- a/crates/stackable-versioned-macros/src/gen/venum/mod.rs
+++ b/crates/stackable-versioned-macros/src/codegen/venum/mod.rs
@@ -7,14 +7,20 @@ use syn::{DataEnum, Error, Ident};
 
 use crate::{
     attrs::common::ContainerAttributes,
-    gen::{
-        common::{format_container_from_ident, Container, ContainerVersion, VersionedContainer},
+    codegen::{
+        common::{
+            format_container_from_ident, Container, ContainerVersion, Item, VersionedContainer,
+        },
         venum::variant::VersionedVariant,
     },
 };
 
-mod variant;
+pub(crate) mod variant;
 
+/// Stores individual versions of a single enum. Each version tracks variant
+/// actions, which describe if the variant was added, renamed or deprecated in
+/// that version. Variants which are not versioned, are included in every
+/// version of the enum.
 #[derive(Debug)]
 pub(crate) struct VersionedEnum(VersionedContainer<VersionedVariant>);
 
@@ -55,7 +61,7 @@ impl Container<DataEnum, VersionedVariant> for VersionedEnum {
             if !items.iter().map(|f| f.get_ident(version)).all_unique() {
                 return Err(Error::new(
                     ident.span(),
-                    format!("struct contains renamed fields which collide with other fields in version {version}", version = version.inner),
+                    format!("Enum contains renamed variants which collide with other variants in version {version}", version = version.inner),
                 ));
             }
         }
@@ -109,7 +115,7 @@ impl VersionedEnum {
             .deprecated
             .then_some(quote! {#[deprecated = #deprecated_note]});
 
-        // Generate tokens for the module and the contained struct
+        // Generate tokens for the module and the contained enum
         token_stream.extend(quote! {
             #[automatically_derived]
             #deprecated_attr
diff --git a/crates/stackable-versioned-macros/src/codegen/venum/variant.rs b/crates/stackable-versioned-macros/src/codegen/venum/variant.rs
new file mode 100644
index 000000000..1a559ca99
--- /dev/null
+++ b/crates/stackable-versioned-macros/src/codegen/venum/variant.rs
@@ -0,0 +1,164 @@
+use std::ops::{Deref, DerefMut};
+
+use darling::FromVariant;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, Variant};
+
+use crate::{
+    attrs::{
+        common::{ContainerAttributes, ItemAttributes},
+        variant::VariantAttributes,
+    },
+    codegen::{
+        chain::BTreeMapExt,
+        common::{
+            remove_deprecated_variant_prefix, Attributes, ContainerVersion, Item, ItemStatus,
+            Named, VersionedItem,
+        },
+    },
+};
+
+/// A versioned variant, which contains contains common [`Variant`] data and a
+/// chain of actions.
+///
+/// The chain of action maps versions to an action and the appropriate variant
+/// name. Additionally, the [`Variant`] data can be used to forward attributes,
+/// generate documentation, etc.
+#[derive(Debug)]
+pub(crate) struct VersionedVariant(VersionedItem<Variant, VariantAttributes>);
+
+impl Deref for VersionedVariant {
+    type Target = VersionedItem<Variant, VariantAttributes>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for VersionedVariant {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl TryFrom<&Variant> for VariantAttributes {
+    type Error = darling::Error;
+
+    fn try_from(variant: &Variant) -> Result<Self, Self::Error> {
+        Self::from_variant(variant)
+    }
+}
+
+impl Attributes for VariantAttributes {
+    fn common_attrs_owned(self) -> ItemAttributes {
+        self.common
+    }
+
+    fn common_attrs(&self) -> &ItemAttributes {
+        &self.common
+    }
+}
+
+impl Named for Variant {
+    fn cleaned_ident(&self) -> Ident {
+        remove_deprecated_variant_prefix(self.ident())
+    }
+
+    fn ident(&self) -> &Ident {
+        &self.ident
+    }
+}
+
+impl VersionedVariant {
+    /// Creates a new versioned variant.
+    ///
+    /// Internally this calls [`VersionedItem::new`] to handle most of the
+    /// common creation code.
+    pub(crate) fn new(
+        variant: Variant,
+        container_attributes: &ContainerAttributes,
+    ) -> syn::Result<Self> {
+        let item = VersionedItem::<_, VariantAttributes>::new(variant, container_attributes)?;
+        Ok(Self(item))
+    }
+
+    /// Generates tokens to be used in a container definition.
+    pub(crate) fn generate_for_container(
+        &self,
+        container_version: &ContainerVersion,
+    ) -> Option<TokenStream> {
+        match &self.chain {
+            // NOTE (@Techassi): https://rust-lang.github.io/rust-clippy/master/index.html#/expect_fun_call
+            Some(chain) => match chain.get(&container_version.inner).unwrap_or_else(|| {
+                panic!(
+                    "internal error: chain must contain container version {}",
+                    container_version.inner
+                )
+            }) {
+                ItemStatus::Added { ident, .. } => Some(quote! {
+                    #ident,
+                }),
+                ItemStatus::Renamed { to, .. } => Some(quote! {
+                    #to,
+                }),
+                ItemStatus::Deprecated { ident, .. } => Some(quote! {
+                    #[deprecated]
+                    #ident,
+                }),
+                ItemStatus::NoChange(ident) => Some(quote! {
+                    #ident,
+                }),
+                ItemStatus::NotPresent => None,
+            },
+            None => {
+                // If there is no chain of variant actions, the variant is not
+                // versioned and code generation is straight forward.
+                // Unversioned variants are always included in versioned enums.
+                let variant_ident = &self.inner.ident;
+
+                Some(quote! {
+                    #variant_ident,
+                })
+            }
+        }
+    }
+
+    /// Generates tokens to be used in a [`From`] implementation.
+    pub(crate) fn generate_for_from_impl(
+        &self,
+        module_name: &Ident,
+        next_module_name: &Ident,
+        version: &ContainerVersion,
+        next_version: &ContainerVersion,
+        enum_ident: &Ident,
+    ) -> TokenStream {
+        match &self.chain {
+            Some(chain) => match (
+                chain.get_expect(&version.inner),
+                chain.get_expect(&next_version.inner),
+            ) {
+                (_, ItemStatus::Added { .. }) => quote! {},
+                (old, next) => {
+                    let old_variant_ident = old
+                        .get_ident()
+                        .expect("internal error: old variant must have a name");
+                    let next_variant_ident = next
+                        .get_ident()
+                        .expect("internal error: next variant must have a name");
+
+                    quote! {
+                        #module_name::#enum_ident::#old_variant_ident => #next_module_name::#enum_ident::#next_variant_ident,
+                    }
+                }
+            },
+            None => {
+                let variant_ident = &self.inner.ident;
+
+                quote! {
+                    #module_name::#enum_ident::#variant_ident => #next_module_name::#enum_ident::#variant_ident,
+                }
+            }
+        }
+    }
+}
diff --git a/crates/stackable-versioned-macros/src/codegen/vstruct/field.rs b/crates/stackable-versioned-macros/src/codegen/vstruct/field.rs
new file mode 100644
index 000000000..17bb3eafc
--- /dev/null
+++ b/crates/stackable-versioned-macros/src/codegen/vstruct/field.rs
@@ -0,0 +1,188 @@
+use std::ops::{Deref, DerefMut};
+
+use darling::FromField;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Field, Ident};
+
+use crate::{
+    attrs::{
+        common::{ContainerAttributes, ItemAttributes},
+        field::FieldAttributes,
+    },
+    codegen::common::{
+        remove_deprecated_field_prefix, Attributes, ContainerVersion, Item, ItemStatus, Named,
+        VersionedItem,
+    },
+};
+
+/// A versioned field, which contains common [`Field`] data and a chain of
+/// actions.
+///
+/// The chain of actions maps versions to an action and the appropriate field
+/// name.
+///
+/// Additionally, the [`Field`] data can be used to forward attributes, generate
+/// documentation, etc.
+#[derive(Debug)]
+pub(crate) struct VersionedField(VersionedItem<Field, FieldAttributes>);
+
+impl Deref for VersionedField {
+    type Target = VersionedItem<Field, FieldAttributes>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for VersionedField {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl TryFrom<&Field> for FieldAttributes {
+    type Error = darling::Error;
+
+    fn try_from(field: &Field) -> Result<Self, Self::Error> {
+        Self::from_field(field)
+    }
+}
+
+impl Attributes for FieldAttributes {
+    fn common_attrs_owned(self) -> ItemAttributes {
+        self.common
+    }
+
+    fn common_attrs(&self) -> &ItemAttributes {
+        &self.common
+    }
+}
+
+impl Named for Field {
+    fn cleaned_ident(&self) -> Ident {
+        let ident = self.ident();
+        remove_deprecated_field_prefix(ident)
+    }
+
+    fn ident(&self) -> &Ident {
+        self.ident
+            .as_ref()
+            .expect("internal error: field must have an ident")
+    }
+}
+
+impl VersionedField {
+    /// Creates a new versioned field.
+    ///
+    /// Internally this calls [`VersionedItem::new`] to handle most of the
+    /// common creation code.
+    pub(crate) fn new(
+        field: Field,
+        container_attributes: &ContainerAttributes,
+    ) -> syn::Result<Self> {
+        let item = VersionedItem::<_, FieldAttributes>::new(field, container_attributes)?;
+        Ok(Self(item))
+    }
+
+    /// Generates tokens to be used in a container definition.
+    pub(crate) fn generate_for_container(
+        &self,
+        container_version: &ContainerVersion,
+    ) -> Option<TokenStream> {
+        match &self.chain {
+            Some(chain) => {
+                // Check if the provided container version is present in the map
+                // of actions. If it is, some action occurred in exactly that
+                // version and thus code is generated for that field based on
+                // the type of action.
+                // If not, the provided version has no action attached to it.
+                // The code generation then depends on the relation to other
+                // versions (with actions).
+
+                let field_type = &self.inner.ty;
+
+                // NOTE (@Techassi): https://rust-lang.github.io/rust-clippy/master/index.html#/expect_fun_call
+                match chain.get(&container_version.inner).unwrap_or_else(|| {
+                    panic!(
+                        "internal error: chain must contain container version {}",
+                        container_version.inner
+                    )
+                }) {
+                    ItemStatus::Added { ident, .. } => Some(quote! {
+                        pub #ident: #field_type,
+                    }),
+                    ItemStatus::Renamed { to, .. } => Some(quote! {
+                        pub #to: #field_type,
+                    }),
+                    ItemStatus::Deprecated {
+                        ident: field_ident,
+                        note,
+                        ..
+                    } => Some(quote! {
+                        #[deprecated = #note]
+                        pub #field_ident: #field_type,
+                    }),
+                    ItemStatus::NotPresent => None,
+                    ItemStatus::NoChange(field_ident) => Some(quote! {
+                        pub #field_ident: #field_type,
+                    }),
+                }
+            }
+            None => {
+                // If there is no chain of field actions, the field is not
+                // versioned and therefore included in all versions.
+                let field_ident = &self.inner.ident;
+                let field_type = &self.inner.ty;
+
+                Some(quote! {
+                    pub #field_ident: #field_type,
+                })
+            }
+        }
+    }
+
+    /// Generates tokens to be used in a [`From`] implementation.
+    pub(crate) fn generate_for_from_impl(
+        &self,
+        version: &ContainerVersion,
+        next_version: &ContainerVersion,
+        from_ident: &Ident,
+    ) -> TokenStream {
+        match &self.chain {
+            Some(chain) => {
+                match (
+                    chain
+                        .get(&version.inner)
+                        .expect("internal error: chain must contain container version"),
+                    chain
+                        .get(&next_version.inner)
+                        .expect("internal error: chain must contain container version"),
+                ) {
+                    (_, ItemStatus::Added { ident, default_fn }) => quote! {
+                        #ident: #default_fn(),
+                    },
+                    (old, next) => {
+                        let old_field_ident = old
+                            .get_ident()
+                            .expect("internal error: old field must have a name");
+
+                        let next_field_ident = next
+                            .get_ident()
+                            .expect("internal error: new field must have a name");
+
+                        quote! {
+                            #next_field_ident: #from_ident.#old_field_ident,
+                        }
+                    }
+                }
+            }
+            None => {
+                let field_ident = &self.inner.ident;
+                quote! {
+                    #field_ident: #from_ident.#field_ident,
+                }
+            }
+        }
+    }
+}
diff --git a/crates/stackable-versioned-macros/src/gen/vstruct/mod.rs b/crates/stackable-versioned-macros/src/codegen/vstruct/mod.rs
similarity index 97%
rename from crates/stackable-versioned-macros/src/gen/vstruct/mod.rs
rename to crates/stackable-versioned-macros/src/codegen/vstruct/mod.rs
index 6bbf6b98e..b0fefaa5d 100644
--- a/crates/stackable-versioned-macros/src/gen/vstruct/mod.rs
+++ b/crates/stackable-versioned-macros/src/codegen/vstruct/mod.rs
@@ -7,13 +7,15 @@ use syn::{DataStruct, Error, Ident};
 
 use crate::{
     attrs::common::ContainerAttributes,
-    gen::{
-        common::{format_container_from_ident, Container, ContainerVersion, VersionedContainer},
+    codegen::{
+        common::{
+            format_container_from_ident, Container, ContainerVersion, Item, VersionedContainer,
+        },
         vstruct::field::VersionedField,
     },
 };
 
-mod field;
+pub(crate) mod field;
 
 /// Stores individual versions of a single struct. Each version tracks field
 /// actions, which describe if the field was added, renamed or deprecated in
diff --git a/crates/stackable-versioned-macros/src/gen/common.rs b/crates/stackable-versioned-macros/src/gen/common.rs
deleted file mode 100644
index 298b85c11..000000000
--- a/crates/stackable-versioned-macros/src/gen/common.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use std::{collections::BTreeMap, ops::Deref};
-
-use k8s_version::Version;
-use proc_macro2::{Span, TokenStream};
-use quote::format_ident;
-use syn::{Ident, Path};
-
-use crate::{
-    attrs::common::ContainerAttributes,
-    consts::{DEPRECATED_FIELD_PREFIX, DEPRECATED_VARIANT_PREFIX},
-};
-
-pub(crate) type VersionChain = BTreeMap<Version, ItemStatus>;
-
-#[derive(Debug, Clone)]
-pub(crate) struct ContainerVersion {
-    pub(crate) deprecated: bool,
-    pub(crate) skip_from: bool,
-    pub(crate) inner: Version,
-    pub(crate) ident: Ident,
-}
-
-impl From<&ContainerAttributes> for Vec<ContainerVersion> {
-    fn from(attributes: &ContainerAttributes) -> Self {
-        attributes
-            .versions
-            .iter()
-            .map(|v| ContainerVersion {
-                skip_from: v.skip.as_ref().map_or(false, |s| s.from.is_present()),
-                ident: Ident::new(&v.name.to_string(), Span::call_site()),
-                deprecated: v.deprecated.is_present(),
-                inner: v.name,
-            })
-            .collect()
-    }
-}
-
-pub(crate) trait Container<D, I>
-where
-    Self: Sized + Deref<Target = VersionedContainer<I>>,
-{
-    fn new(ident: Ident, data: D, attributes: ContainerAttributes) -> syn::Result<Self>;
-
-    /// This generates the complete code for a single versioned container.
-    ///
-    /// Internally, it will create a module for each declared version which
-    /// contains the container with the appropriate items (fields or variants)
-    /// Additionally, it generates `From` implementations, which enable
-    /// conversion from an older to a newer version.
-    fn generate_tokens(&self) -> TokenStream;
-}
-
-#[derive(Debug)]
-pub(crate) struct VersionedContainer<I> {
-    pub(crate) versions: Vec<ContainerVersion>,
-    pub(crate) items: Vec<I>,
-    pub(crate) ident: Ident,
-
-    pub(crate) from_ident: Ident,
-    pub(crate) skip_from: bool,
-}
-
-#[derive(Debug)]
-pub(crate) enum ItemStatus {
-    Added {
-        ident: Ident,
-        default_fn: Path,
-    },
-    Renamed {
-        from: Ident,
-        to: Ident,
-    },
-    Deprecated {
-        previous_ident: Ident,
-        ident: Ident,
-        note: String,
-    },
-    NoChange(Ident),
-    NotPresent,
-}
-
-impl ItemStatus {
-    pub(crate) fn get_ident(&self) -> Option<&Ident> {
-        match &self {
-            ItemStatus::Added { ident, .. } => Some(ident),
-            ItemStatus::Renamed { to, .. } => Some(to),
-            ItemStatus::Deprecated { ident, .. } => Some(ident),
-            ItemStatus::NoChange(ident) => Some(ident),
-            ItemStatus::NotPresent => None,
-        }
-    }
-}
-
-/// Returns the container ident used in [`From`] implementations.
-pub(crate) fn format_container_from_ident(ident: &Ident) -> Ident {
-    format_ident!("__sv_{ident}", ident = ident.to_string().to_lowercase())
-}
-
-/// Removes the deprecated prefix from field ident.
-pub(crate) fn remove_deprecated_field_prefix(ident: &Ident) -> Ident {
-    remove_ident_prefix(ident, DEPRECATED_FIELD_PREFIX)
-}
-
-pub(crate) fn remove_deprecated_variant_prefix(ident: &Ident) -> Ident {
-    remove_ident_prefix(ident, DEPRECATED_VARIANT_PREFIX)
-}
-
-pub(crate) fn remove_ident_prefix(ident: &Ident, prefix: &str) -> Ident {
-    format_ident!("{}", ident.to_string().trim_start_matches(prefix))
-}
diff --git a/crates/stackable-versioned-macros/src/gen/venum/variant.rs b/crates/stackable-versioned-macros/src/gen/venum/variant.rs
deleted file mode 100644
index d06c29651..000000000
--- a/crates/stackable-versioned-macros/src/gen/venum/variant.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-use std::{collections::BTreeMap, ops::Deref};
-
-use darling::FromVariant;
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-use syn::{Ident, Variant};
-
-use crate::{
-    attrs::{common::ContainerAttributes, variant::VariantAttributes},
-    gen::{
-        chain::{BTreeMapExt, Neighbors},
-        common::{remove_deprecated_variant_prefix, ContainerVersion, ItemStatus, VersionChain},
-    },
-};
-
-#[derive(Debug)]
-pub(crate) struct VersionedVariant {
-    chain: Option<VersionChain>,
-    inner: Variant,
-}
-
-// TODO (@Techassi): Figure out a way to be able to only write the following code
-// once for both a versioned field and variant, because the are practically
-// identical.
-
-impl VersionedVariant {
-    pub(crate) fn new(
-        variant: Variant,
-        container_attrs: &ContainerAttributes,
-    ) -> syn::Result<Self> {
-        // NOTE (@Techassi): This is straight up copied from the VersionedField
-        // impl. As mentioned above, unify this.
-
-        let variant_attrs = VariantAttributes::from_variant(&variant)?;
-        variant_attrs.validate_versions(container_attrs, &variant)?;
-
-        if let Some(deprecated) = variant_attrs.common.deprecated {
-            let deprecated_ident = &variant.ident;
-
-            // When the variant is deprecated, any rename which occurred beforehand
-            // requires access to the variant ident to infer the variant ident for
-            // the latest rename.
-            let mut ident = remove_deprecated_variant_prefix(deprecated_ident);
-            let mut actions = BTreeMap::new();
-
-            actions.insert(
-                *deprecated.since,
-                ItemStatus::Deprecated {
-                    previous_ident: ident.clone(),
-                    ident: deprecated_ident.clone(),
-                    note: deprecated.note.to_string(),
-                },
-            );
-
-            for rename in variant_attrs.common.renames.iter().rev() {
-                let from = format_ident!("{from}", from = *rename.from);
-                actions.insert(
-                    *rename.since,
-                    ItemStatus::Renamed {
-                        from: from.clone(),
-                        to: ident,
-                    },
-                );
-                ident = from;
-            }
-
-            // After the last iteration above (if any) we use the ident for the
-            // added action if there is any.
-            if let Some(added) = variant_attrs.common.added {
-                actions.insert(
-                    *added.since,
-                    ItemStatus::Added {
-                        default_fn: added.default_fn.deref().clone(),
-                        ident,
-                    },
-                );
-            }
-
-            Ok(Self {
-                chain: Some(actions),
-                inner: variant,
-            })
-        } else if !variant_attrs.common.renames.is_empty() {
-            let mut actions = BTreeMap::new();
-            let mut ident = variant.ident.clone();
-
-            for rename in variant_attrs.common.renames.iter().rev() {
-                let from = format_ident!("{from}", from = *rename.from);
-                actions.insert(
-                    *rename.since,
-                    ItemStatus::Renamed {
-                        from: from.clone(),
-                        to: ident,
-                    },
-                );
-                ident = from;
-            }
-
-            // After the last iteration above (if any) we use the ident for the
-            // added action if there is any.
-            if let Some(added) = variant_attrs.common.added {
-                actions.insert(
-                    *added.since,
-                    ItemStatus::Added {
-                        default_fn: added.default_fn.deref().clone(),
-                        ident,
-                    },
-                );
-            }
-
-            Ok(Self {
-                chain: Some(actions),
-                inner: variant,
-            })
-        } else {
-            if let Some(added) = variant_attrs.common.added {
-                let mut actions = BTreeMap::new();
-
-                actions.insert(
-                    *added.since,
-                    ItemStatus::Added {
-                        default_fn: added.default_fn.deref().clone(),
-                        ident: variant.ident.clone(),
-                    },
-                );
-
-                return Ok(Self {
-                    chain: Some(actions),
-                    inner: variant,
-                });
-            }
-
-            Ok(Self {
-                chain: None,
-                inner: variant,
-            })
-        }
-    }
-
-    /// Inserts container versions not yet present in the status chain.
-    ///
-    /// When initially creating a new versioned item, the code doesn't have
-    /// access to the versions defined on the container. This function inserts
-    /// all non-present container versions and decides which status and ident
-    /// is the right fit based on the status neighbors.
-    ///
-    /// This continuous chain ensures that when generating code (tokens), each
-    /// variant can lookup the status (and ident) for a requested version.
-    pub(crate) fn insert_container_versions(&mut self, versions: &[ContainerVersion]) {
-        if let Some(chain) = &mut self.chain {
-            for version in versions {
-                if chain.contains_key(&version.inner) {
-                    continue;
-                }
-
-                match chain.get_neighbors(&version.inner) {
-                    (None, Some(status)) => match status {
-                        ItemStatus::Added { .. } => {
-                            chain.insert(version.inner, ItemStatus::NotPresent)
-                        }
-                        ItemStatus::Renamed { from, .. } => {
-                            chain.insert(version.inner, ItemStatus::NoChange(from.clone()))
-                        }
-                        ItemStatus::Deprecated { previous_ident, .. } => chain
-                            .insert(version.inner, ItemStatus::NoChange(previous_ident.clone())),
-                        ItemStatus::NoChange(ident) => {
-                            chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
-                        }
-                        ItemStatus::NotPresent => unreachable!(),
-                    },
-                    (Some(status), None) => {
-                        let ident = match status {
-                            ItemStatus::Added { ident, .. } => ident,
-                            ItemStatus::Renamed { to, .. } => to,
-                            ItemStatus::Deprecated { ident, .. } => ident,
-                            ItemStatus::NoChange(ident) => ident,
-                            ItemStatus::NotPresent => unreachable!(),
-                        };
-
-                        chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
-                    }
-                    (Some(status), Some(_)) => {
-                        let ident = match status {
-                            ItemStatus::Added { ident, .. } => ident,
-                            ItemStatus::Renamed { to, .. } => to,
-                            ItemStatus::NoChange(ident) => ident,
-                            _ => unreachable!(),
-                        };
-
-                        chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
-                    }
-                    _ => unreachable!(),
-                };
-            }
-        }
-    }
-
-    pub(crate) fn generate_for_container(
-        &self,
-        container_version: &ContainerVersion,
-    ) -> Option<TokenStream> {
-        match &self.chain {
-            Some(chain) => match chain
-                .get(&container_version.inner)
-                .expect("internal error: chain must contain container version")
-            {
-                ItemStatus::Added { ident, .. } => Some(quote! {
-                    #ident,
-                }),
-                ItemStatus::Renamed { to, .. } => Some(quote! {
-                    #to,
-                }),
-                ItemStatus::Deprecated { ident, .. } => Some(quote! {
-                    #[deprecated]
-                    #ident,
-                }),
-                ItemStatus::NoChange(ident) => Some(quote! {
-                    #ident,
-                }),
-                ItemStatus::NotPresent => None,
-            },
-            None => {
-                // If there is no chain of variant actions, the variant is not
-                // versioned and code generation is straight forward.
-                // Unversioned variants are always included in versioned enums.
-                let variant_ident = &self.inner.ident;
-
-                Some(quote! {
-                    #variant_ident,
-                })
-            }
-        }
-    }
-
-    pub(crate) fn generate_for_from_impl(
-        &self,
-        module_name: &Ident,
-        next_module_name: &Ident,
-        version: &ContainerVersion,
-        next_version: &ContainerVersion,
-        enum_ident: &Ident,
-    ) -> TokenStream {
-        match &self.chain {
-            Some(chain) => match (
-                chain.get_expect(&version.inner),
-                chain.get_expect(&next_version.inner),
-            ) {
-                (_, ItemStatus::Added { .. }) => quote! {},
-                (old, next) => {
-                    let old_variant_ident = old
-                        .get_ident()
-                        .expect("internal error: old variant must have a name");
-                    let next_variant_ident = next
-                        .get_ident()
-                        .expect("internal error: next variant must have a name");
-
-                    quote! {
-                        #module_name::#enum_ident::#old_variant_ident => #next_module_name::#enum_ident::#next_variant_ident,
-                    }
-                }
-            },
-            None => {
-                let variant_ident = &self.inner.ident;
-
-                quote! {
-                    #module_name::#enum_ident::#variant_ident => #next_module_name::#enum_ident::#variant_ident,
-                }
-            }
-        }
-    }
-
-    pub(crate) fn get_ident(&self, version: &ContainerVersion) -> Option<&syn::Ident> {
-        match &self.chain {
-            Some(chain) => chain
-                .get(&version.inner)
-                .expect("internal error: chain must contain container version")
-                .get_ident(),
-            None => Some(&self.inner.ident),
-        }
-    }
-}
diff --git a/crates/stackable-versioned-macros/src/gen/vstruct/field.rs b/crates/stackable-versioned-macros/src/gen/vstruct/field.rs
deleted file mode 100644
index c3b77a7e7..000000000
--- a/crates/stackable-versioned-macros/src/gen/vstruct/field.rs
+++ /dev/null
@@ -1,327 +0,0 @@
-use std::{collections::BTreeMap, ops::Deref};
-
-use darling::FromField;
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-use syn::{Field, Ident};
-
-use crate::{
-    attrs::{common::ContainerAttributes, field::FieldAttributes},
-    gen::{
-        chain::Neighbors,
-        common::{remove_deprecated_field_prefix, ContainerVersion, ItemStatus, VersionChain},
-    },
-};
-
-/// A versioned field, which contains contains common [`Field`] data and a chain
-/// of actions.
-///
-/// The chain of action maps versions to an action and the appropriate field
-/// name. Additionally, the [`Field`] data can be used to forward attributes,
-/// generate documentation, etc.
-#[derive(Debug)]
-pub(crate) struct VersionedField {
-    pub(crate) chain: Option<VersionChain>,
-    pub(crate) inner: Field,
-}
-
-// TODO (@Techassi): Figure out a way to be able to only write the following code
-// once for both a versioned field and variant, because the are practically
-// identical.
-
-impl VersionedField {
-    /// Create a new versioned field (of a versioned struct) by consuming the
-    /// parsed [Field] and validating the versions of field actions against
-    /// versions attached on the container.
-    pub(crate) fn new(field: Field, container_attrs: &ContainerAttributes) -> syn::Result<Self> {
-        let field_attrs = FieldAttributes::from_field(&field)?;
-        field_attrs.validate_versions(container_attrs, &field)?;
-
-        // Constructing the action chain requires going through the actions from
-        // the end, because the base struct always represents the latest (most
-        // up-to-date) version of that struct. That's why the following code
-        // needs to go through the actions in reverse order, as otherwise it is
-        // impossible to extract the field ident for each version.
-
-        // Deprecating a field is always the last state a field can end up in. For
-        // fields which are not deprecated, the last change is either the latest
-        // rename or addition, which is handled below.
-        // The ident of the deprecated field is guaranteed to include the
-        // 'deprecated_' prefix. The ident can thus be used as is.
-        if let Some(deprecated) = field_attrs.common.deprecated {
-            let deprecated_ident = field
-                .ident
-                .as_ref()
-                .expect("internal error: field must have an ident");
-
-            // When the field is deprecated, any rename which occurred beforehand
-            // requires access to the field ident to infer the field ident for
-            // the latest rename.
-            let mut ident = remove_deprecated_field_prefix(deprecated_ident);
-            let mut actions = BTreeMap::new();
-
-            actions.insert(
-                *deprecated.since,
-                ItemStatus::Deprecated {
-                    previous_ident: ident.clone(),
-                    ident: deprecated_ident.clone(),
-                    note: deprecated.note.to_string(),
-                },
-            );
-
-            for rename in field_attrs.common.renames.iter().rev() {
-                let from = format_ident!("{from}", from = *rename.from);
-                actions.insert(
-                    *rename.since,
-                    ItemStatus::Renamed {
-                        from: from.clone(),
-                        to: ident,
-                    },
-                );
-                ident = from;
-            }
-
-            // After the last iteration above (if any) we use the ident for the
-            // added action if there is any.
-            if let Some(added) = field_attrs.common.added {
-                actions.insert(
-                    *added.since,
-                    ItemStatus::Added {
-                        default_fn: added.default_fn.deref().clone(),
-                        ident,
-                    },
-                );
-            }
-
-            Ok(Self {
-                chain: Some(actions),
-                inner: field,
-            })
-        } else if !field_attrs.common.renames.is_empty() {
-            let mut actions = BTreeMap::new();
-            let mut ident = field
-                .ident
-                .clone()
-                .expect("internal error: field must have an ident");
-
-            for rename in field_attrs.common.renames.iter().rev() {
-                let from = format_ident!("{from}", from = *rename.from);
-                actions.insert(
-                    *rename.since,
-                    ItemStatus::Renamed {
-                        from: from.clone(),
-                        to: ident,
-                    },
-                );
-                ident = from;
-            }
-
-            // After the last iteration above (if any) we use the ident for the
-            // added action if there is any.
-            if let Some(added) = field_attrs.common.added {
-                actions.insert(
-                    *added.since,
-                    ItemStatus::Added {
-                        default_fn: added.default_fn.deref().clone(),
-                        ident,
-                    },
-                );
-            }
-
-            Ok(Self {
-                chain: Some(actions),
-                inner: field,
-            })
-        } else {
-            if let Some(added) = field_attrs.common.added {
-                let mut actions = BTreeMap::new();
-
-                actions.insert(
-                    *added.since,
-                    ItemStatus::Added {
-                        default_fn: added.default_fn.deref().clone(),
-                        ident: field
-                            .ident
-                            .clone()
-                            .expect("internal error: field must have a name"),
-                    },
-                );
-
-                return Ok(Self {
-                    chain: Some(actions),
-                    inner: field,
-                });
-            }
-
-            Ok(Self {
-                chain: None,
-                inner: field,
-            })
-        }
-    }
-
-    /// Inserts container versions not yet present in the status chain.
-    ///
-    /// When initially creating a new versioned item, the code doesn't have
-    /// access to the versions defined on the container. This function inserts
-    /// all non-present container versions and decides which status and ident
-    /// is the right fit based on the status neighbors.
-    ///
-    /// This continuous chain ensures that when generating code (tokens), each
-    /// field can lookup the status (and ident) for a requested version.
-    pub(crate) fn insert_container_versions(&mut self, versions: &[ContainerVersion]) {
-        if let Some(chain) = &mut self.chain {
-            for version in versions {
-                if chain.contains_key(&version.inner) {
-                    continue;
-                }
-
-                match chain.get_neighbors(&version.inner) {
-                    (None, Some(status)) => match status {
-                        ItemStatus::Added { .. } => {
-                            chain.insert(version.inner, ItemStatus::NotPresent)
-                        }
-                        ItemStatus::Renamed { from, .. } => {
-                            chain.insert(version.inner, ItemStatus::NoChange(from.clone()))
-                        }
-                        ItemStatus::Deprecated { previous_ident, .. } => chain
-                            .insert(version.inner, ItemStatus::NoChange(previous_ident.clone())),
-                        ItemStatus::NoChange(ident) => {
-                            chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
-                        }
-                        ItemStatus::NotPresent => unreachable!(),
-                    },
-                    (Some(status), None) => {
-                        let ident = match status {
-                            ItemStatus::Added { ident, .. } => ident,
-                            ItemStatus::Renamed { to, .. } => to,
-                            ItemStatus::Deprecated { ident, .. } => ident,
-                            ItemStatus::NoChange(ident) => ident,
-                            ItemStatus::NotPresent => unreachable!(),
-                        };
-
-                        chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
-                    }
-                    (Some(status), Some(_)) => {
-                        let ident = match status {
-                            ItemStatus::Added { ident, .. } => ident,
-                            ItemStatus::Renamed { to, .. } => to,
-                            ItemStatus::NoChange(ident) => ident,
-                            _ => unreachable!(),
-                        };
-
-                        chain.insert(version.inner, ItemStatus::NoChange(ident.clone()))
-                    }
-                    _ => unreachable!(),
-                };
-            }
-        }
-    }
-
-    pub(crate) fn get_ident(&self, version: &ContainerVersion) -> Option<&Ident> {
-        match &self.chain {
-            Some(chain) => chain
-                .get(&version.inner)
-                .expect("internal error: chain must contain container version")
-                .get_ident(),
-            None => self.inner.ident.as_ref(),
-        }
-    }
-
-    pub(crate) fn generate_for_container(
-        &self,
-        container_version: &ContainerVersion,
-    ) -> Option<TokenStream> {
-        match &self.chain {
-            Some(chain) => {
-                // Check if the provided container version is present in the map
-                // of actions. If it is, some action occurred in exactly that
-                // version and thus code is generated for that field based on
-                // the type of action.
-                // If not, the provided version has no action attached to it.
-                // The code generation then depends on the relation to other
-                // versions (with actions).
-
-                let field_type = &self.inner.ty;
-
-                match chain
-                    .get(&container_version.inner)
-                    .expect("internal error: chain must contain container version")
-                {
-                    ItemStatus::Added { ident, .. } => Some(quote! {
-                        pub #ident: #field_type,
-                    }),
-                    ItemStatus::Renamed { to, .. } => Some(quote! {
-                        pub #to: #field_type,
-                    }),
-                    ItemStatus::Deprecated {
-                        ident: field_ident,
-                        note,
-                        ..
-                    } => Some(quote! {
-                        #[deprecated = #note]
-                        pub #field_ident: #field_type,
-                    }),
-                    ItemStatus::NotPresent => None,
-                    ItemStatus::NoChange(field_ident) => Some(quote! {
-                        pub #field_ident: #field_type,
-                    }),
-                }
-            }
-            None => {
-                // If there is no chain of field actions, the field is not
-                // versioned and code generation is straight forward.
-                // Unversioned fields are always included in versioned structs.
-                let field_ident = &self.inner.ident;
-                let field_type = &self.inner.ty;
-
-                Some(quote! {
-                    pub #field_ident: #field_type,
-                })
-            }
-        }
-    }
-
-    pub(crate) fn generate_for_from_impl(
-        &self,
-        version: &ContainerVersion,
-        next_version: &ContainerVersion,
-        from_ident: &Ident,
-    ) -> TokenStream {
-        match &self.chain {
-            Some(chain) => {
-                match (
-                    chain
-                        .get(&version.inner)
-                        .expect("internal error: chain must contain container version"),
-                    chain
-                        .get(&next_version.inner)
-                        .expect("internal error: chain must contain container version"),
-                ) {
-                    (_, ItemStatus::Added { ident, default_fn }) => quote! {
-                        #ident: #default_fn(),
-                    },
-                    (old, next) => {
-                        let old_field_ident = old
-                            .get_ident()
-                            .expect("internal error: old field must have a name");
-
-                        let next_field_ident = next
-                            .get_ident()
-                            .expect("internal error: new field must have a name");
-
-                        quote! {
-                            #next_field_ident: #from_ident.#old_field_ident,
-                        }
-                    }
-                }
-            }
-            None => {
-                let field_ident = &self.inner.ident;
-                quote! {
-                    #field_ident: #from_ident.#field_ident,
-                }
-            }
-        }
-    }
-}
diff --git a/crates/stackable-versioned-macros/src/lib.rs b/crates/stackable-versioned-macros/src/lib.rs
index 44a8b7e51..479eab5e2 100644
--- a/crates/stackable-versioned-macros/src/lib.rs
+++ b/crates/stackable-versioned-macros/src/lib.rs
@@ -5,8 +5,8 @@ use syn::{DeriveInput, Error};
 use crate::attrs::common::ContainerAttributes;
 
 mod attrs;
+mod codegen;
 mod consts;
-mod gen;
 
 /// This macro enables generating versioned structs.
 ///
@@ -223,7 +223,7 @@ pub fn versioned(attrs: TokenStream, input: TokenStream) -> TokenStream {
     // Module(ItemMod).
     let input = syn::parse_macro_input!(input as DeriveInput);
 
-    gen::expand(attrs, input)
+    codegen::expand(attrs, input)
         .unwrap_or_else(Error::into_compile_error)
         .into()
 }
diff --git a/crates/stackable-versioned/CHANGELOG.md b/crates/stackable-versioned/CHANGELOG.md
index 08a1bda5b..e65e620ad 100644
--- a/crates/stackable-versioned/CHANGELOG.md
+++ b/crates/stackable-versioned/CHANGELOG.md
@@ -14,6 +14,7 @@ All notable changes to this project will be documented in this file.
 
 ### Changed
 
+- Remove duplicated code and unified struct/enum and field/variant code ([#820]).
 - Change from derive macro to attribute macro to be able to generate code
   _in place_ instead of _appending_ new code ([#793]).
 - Improve action chain generation ([#784]).
@@ -24,6 +25,7 @@ All notable changes to this project will be documented in this file.
 [#793]: https://github.com/stackabletech/operator-rs/pull/793
 [#804]: https://github.com/stackabletech/operator-rs/pull/804
 [#813]: https://github.com/stackabletech/operator-rs/pull/813
+[#820]: https://github.com/stackabletech/operator-rs/pull/820
 [#822]: https://github.com/stackabletech/operator-rs/pull/822
 
 ## [0.1.0] - 2024-05-08