feat: Reduced visibility of config structs

feat: Implement useful traits to simplify code
chore: Fix config type annotations
2025-10-22 04:13:54 +02:00 · 2025-10-22 04:09:01 +02:00 · 2025-10-22 03:59:59 +02:00 · 2025-10-22 03:59:40 +02:00 · 2025-10-22 03:24:34 +02:00 · 2025-10-22 03:09:15 +02:00
70 changed files with 3439 additions and 1402 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -57,24 +57,12 @@ repos:
        files: (\.rs|Cargo.lock)$
        pass_filenames: false

-      - id: audit
-        name: audit
-        description: Audit packages
-        entry: cargo audit
-        args: ["--deny", "warnings"]
+      - id: generate_definitions
+        name: generate definitions
+        description: Generate lua definitions
+        entry: cargo run --bin generate_definitions
        language: system
-        pass_filenames: false
-        verbose: true
-        always_run: true
-
-      - id: udeps
-        name: unused
-        description: Check for unused crates
-        entry: cargo udeps
-        args: ["--workspace"]
-        language: system
-        types: [file]
-        files: (\.rs|Cargo.lock)$
+        types: [rust]
        pass_filenames: false

      - id: test
@@ -87,6 +75,26 @@ repos:
        files: (\.rs|Cargo.lock)$
        pass_filenames: false

+      - id: udeps
+        name: unused
+        description: Check for unused crates
+        entry: cargo udeps
+        args: ["--workspace"]
+        language: system
+        types: [file]
+        files: (\.rs|Cargo.lock)$
+        pass_filenames: false
+
+      - id: audit
+        name: audit
+        description: Audit packages
+        entry: cargo audit
+        args: ["--deny", "warnings"]
+        language: system
+        pass_filenames: false
+        verbose: true
+        always_run: true
+
  - repo: https://github.com/hadolint/hadolint
    rev: v2.13.1
    hooks:
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -36,12 +36,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -94,11 +88,13 @@ dependencies = [
 "async-trait",
 "automation_devices",
 "automation_lib",
+ "automation_macro",
 "axum",
 "config",
- "dotenvy",
+ "git-version",
 "google_home",
- "hostname",
+ "inventory",
+ "lua_typed",
 "mlua",
 "reqwest",
 "rumqttc",
@@ -106,6 +102,7 @@ dependencies = [
 "serde_json",
 "thiserror 2.0.16",
 "tokio",
+ "tokio-cron-scheduler",
 "tracing",
 "tracing-subscriber",
 ]
@@ -127,6 +124,8 @@ dependencies = [
 "dyn-clone",
 "eui48",
 "google_home",
+ "inventory",
+ "lua_typed",
 "mlua",
 "reqwest",
 "rumqttc",
@@ -145,20 +144,21 @@ version = "0.1.0"
 dependencies = [
 "async-trait",
 "automation_cast",
+ "automation_macro",
 "bytes",
 "dyn-clone",
 "futures",
 "google_home",
- "indexmap",
+ "hostname",
+ "inventory",
+ "lua_typed",
 "mlua",
 "rumqttc",
 "serde",
 "serde_json",
 "thiserror 2.0.16",
 "tokio",
- "tokio-cron-scheduler",
 "tracing",
- "uuid",
 ]

 [[package]]
@@ -166,6 +166,7 @@ name = "automation_macro"
 version = "0.1.0"
 dependencies = [
 "itertools",
+ "mlua",
 "proc-macro2",
 "quote",
 "syn 2.0.106",
@@ -316,16 +317,25 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"

 [[package]]
 name = "chrono"
-version = "0.4.41"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 dependencies = [
- "android-tzdata",
 "iana-time-zone",
 "js-sys",
 "num-traits",
 "wasm-bindgen",
- "windows-link",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
+dependencies = [
+ "chrono",
+ "phf",
 ]

 [[package]]
@@ -341,6 +351,15 @@ dependencies = [
 "winnow",
 ]

+[[package]]
+name = "convert_case"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -359,11 +378,48 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"

 [[package]]
 name = "croner"
-version = "2.2.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c344b0690c1ad1c7176fe18eb173e0c927008fdaaa256e40dfd43ddd149c0843"
+checksum = "4c007081651a19b42931f86f7d4f74ee1c2a7d0cd2c6636a81695b5ffd4e9990"
 dependencies = [
 "chrono",
+ "derive_builder",
+ "strum",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.106",
 ]

 [[package]]
@@ -407,6 +463,37 @@ dependencies = [
 "thiserror 2.0.16",
 ]

+[[package]]
+name = "derive_builder"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
+dependencies = [
+ "derive_builder_core",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "displaydoc"
 version = "0.2.5"
@@ -418,12 +505,6 @@ dependencies = [
 "syn 2.0.106",
 ]

-[[package]]
-name = "dotenvy"
-version = "0.15.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
-
 [[package]]
 name = "dyn-clone"
 version = "1.0.20"
@@ -457,12 +538,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"

-[[package]]
-name = "equivalent"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
-
 [[package]]
 name = "erased-serde"
 version = "0.4.6"
@@ -480,7 +555,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
 "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -647,6 +722,26 @@ version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"

+[[package]]
+name = "git-version"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad568aa3db0fcbc81f2f116137f263d7304f512a1209b35b85150d3ef88ad19"
+dependencies = [
+ "git-version-macro",
+]
+
+[[package]]
+name = "git-version-macro"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53010ccb100b96a67bc32c0175f0ed1426b31b655d562898e57325f81c023ac0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "google_home"
 version = "0.1.0"
@@ -672,10 +767,10 @@ dependencies = [
 ]

 [[package]]
-name = "hashbrown"
-version = "0.15.5"
+name = "heck"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

 [[package]]
 name = "hex"
@@ -691,7 +786,7 @@ checksum = "a56f203cd1c76362b69e3863fd987520ac36cf70a8c92627449b2f64a8cf7d65"
 dependencies = [
 "cfg-if",
 "libc",
- "windows-link",
+ "windows-link 0.1.3",
 ]

 [[package]]
@@ -805,9 +900,9 @@ dependencies = [

 [[package]]
 name = "iana-time-zone"
-version = "0.1.63"
+version = "0.1.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
 dependencies = [
 "android_system_properties",
 "core-foundation-sys",
@@ -913,6 +1008,12 @@ dependencies = [
 "zerovec",
 ]

+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -935,14 +1036,12 @@ dependencies = [
 ]

 [[package]]
-name = "indexmap"
-version = "2.11.0"
+name = "inventory"
+version = "0.3.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2481980430f9f78649238835720ddccc57e52df14ffce1c6f37391d61b563e9"
+checksum = "bc61209c082fbeb19919bee74b176221b27223e27b65d781eb91af24eb1fb46e"
 dependencies = [
- "equivalent",
- "hashbrown",
- "serde",
+ "rustversion",
 ]

 [[package]]
@@ -1061,6 +1160,27 @@ dependencies = [
 "cc",
 ]

+[[package]]
+name = "lua_typed"
+version = "0.1.0"
+source = "git+https://git.huizinga.dev/Dreaded_X/lua_typed#3d29c9dd143737c8bffe4bacae8e701de3c6ee10"
+dependencies = [
+ "eui48",
+ "lua_typed_macro",
+]
+
+[[package]]
+name = "lua_typed_macro"
+version = "0.1.0"
+source = "git+https://git.huizinga.dev/Dreaded_X/lua_typed#3d29c9dd143737c8bffe4bacae8e701de3c6ee10"
+dependencies = [
+ "convert_case",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "luajit-src"
 version = "210.6.1+f9140a6"
@@ -1148,9 +1268,9 @@ dependencies = [

 [[package]]
 name = "mlua"
-version = "0.11.3"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b3dd94c3c4dea0049b22296397040840a8f6b5b5229f438434ba82df402b42d"
+checksum = "9be1c2bfc684b8a228fbaebf954af7a47a98ec27721986654a4cc2c40a20cc7e"
 dependencies = [
 "bstr",
 "either",
@@ -1288,6 +1408,24 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"

+[[package]]
+name = "phf"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"
+dependencies = [
+ "siphasher",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.16"
@@ -1429,7 +1567,7 @@ dependencies = [
 "once_cell",
 "socket2",
 "tracing",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -1606,7 +1744,7 @@ dependencies = [
 "errno",
 "libc",
 "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -1840,6 +1978,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"

+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+
 [[package]]
 name = "slab"
 version = "0.4.11"
@@ -1877,6 +2021,33 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"

+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -2019,11 +2190,12 @@ dependencies = [

 [[package]]
 name = "tokio-cron-scheduler"
-version = "0.14.0"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c71ce8f810abc9fabebccc30302a952f9e89c6cf246fafaf170fef164063141"
+checksum = "bb73c4033ddcbbf81fd828293fd41a0145cde2cbc30dd782227c5081a523214d"
 dependencies = [
 "chrono",
+ "chrono-tz",
 "croner",
 "num-derive",
 "num-traits",
@@ -2223,6 +2395,12 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"

+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -2412,22 +2590,22 @@ dependencies = [

 [[package]]
 name = "windows-core"
-version = "0.61.2"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
 "windows-implement",
 "windows-interface",
- "windows-link",
+ "windows-link 0.2.1",
 "windows-result",
 "windows-strings",
 ]

 [[package]]
 name = "windows-implement"
-version = "0.60.0"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2436,9 +2614,9 @@ dependencies = [

 [[package]]
 name = "windows-interface"
-version = "0.59.1"
+version = "0.59.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2452,21 +2630,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"

 [[package]]
-name = "windows-result"
-version = "0.3.4"
+name = "windows-link"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
 ]

 [[package]]
 name = "windows-strings"
-version = "0.4.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,7 @@
 name = "automation"
 version = "0.1.0"
 edition = "2024"
+default-run = "automation"

 [workspace]
 members = [
@@ -23,7 +24,6 @@ automation_lib = { path = "./automation_lib" }
 automation_macro = { path = "./automation_macro" }
 axum = "0.8.4"
 bytes = "1.10.1"
-dotenvy = "0.15.7"
 dyn-clone = "1.0.20"
 eui48 = { version = "1.1.0", features = [
  "disp_hexstring",
@@ -33,9 +33,10 @@ futures = "0.3.31"
 google_home = { path = "./google_home/google_home" }
 google_home_macro = { path = "./google_home/google_home_macro" }
 hostname = "0.4.1"
-indexmap = { version = "2.11.0", features = ["serde"] }
+inventory = "0.3.21"
 itertools = "0.14.0"
 json_value_merge = "2.0.1"
+lua_typed = { git = "https://git.huizinga.dev/Dreaded_X/lua_typed" }
 mlua = { version = "0.11.3", features = [
  "lua54",
  "vendored",
@@ -54,13 +55,12 @@ rumqttc = "0.24.0"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.143"
 serde_repr = "0.1.20"
-syn = { version = "2.0.106", features = ["extra-traits", "full"] }
+syn = { version = "2.0.106" }
 thiserror = "2.0.16"
 tokio = { version = "1", features = ["rt-multi-thread"] }
-tokio-cron-scheduler = "0.14.0"
+tokio-cron-scheduler = "0.15.0"
 tracing = "0.1.41"
 tracing-subscriber = "0.3.20"
-uuid = "1.18.1"
 wakey = "0.3.0"

 [dependencies]
@@ -68,14 +68,16 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 automation_devices = { workspace = true }
 automation_lib = { workspace = true }
+automation_macro = { path = "./automation_macro" }
 axum = { workspace = true }
 config = { version = "0.15.15", default-features = false, features = [
  "async",
  "toml",
 ] }
-dotenvy = { workspace = true }
+git-version = "0.3.9"
 google_home = { workspace = true }
-hostname = { workspace = true }
+lua_typed = { workspace = true }
+inventory = { workspace = true }
 mlua = { workspace = true }
 reqwest = { workspace = true }
 rumqttc = { workspace = true }
@@ -83,6 +85,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
+tokio-cron-scheduler = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }

--- a/3
+++ b/3
@@ -21,6 +21,5 @@ RUN cargo auditable build --release

 FROM gcr.io/distroless/cc-debian12:nonroot AS runtime
 COPY --from=builder /app/target/release/automation /app/automation
-ENV AUTOMATION__ENTRYPOINT=/app/config.lua
-COPY ./config.lua /app/config.lua
+COPY ./config /app/config
 CMD [ "/app/automation" ]
--- a/automation_devices/Cargo.toml
+++ b/automation_devices/Cargo.toml
@@ -13,6 +13,8 @@ bytes = { workspace = true }
 dyn-clone = { workspace = true }
 eui48 = { workspace = true }
 google_home = { workspace = true }
+inventory = { workspace = true }
+lua_typed = { workspace = true }
 mlua = { workspace = true }
 reqwest = { workspace = true }
 rumqttc = { workspace = true }
--- a/automation_devices/src/air_filter.rs
+++ b/automation_devices/src/air_filter.rs
@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use automation_lib::config::InfoConfig;
 use automation_lib::device::{Device, LuaDeviceCreate};
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
 use google_home::device::Name;
 use google_home::errors::ErrorCode;
 use google_home::traits::{
@@ -9,21 +9,26 @@ use google_home::traits::{
    TemperatureUnit,
 };
 use google_home::types::Type;
+use lua_typed::Typed;
 use thiserror::Error;
 use tracing::{debug, trace};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "AirFilterConfig")]
 pub struct Config {
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub info: InfoConfig,
    pub url: String,
 }
+crate::register_type!(Config);

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(OnOff)]
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff))]
 pub struct AirFilter {
    config: Config,
 }
+crate::register_device!(AirFilter);

 #[derive(Debug, Error)]
 pub enum Error {
--- a/automation_devices/src/contact_sensor.rs
+++ b/automation_devices/src/contact_sensor.rs
@@ -8,52 +8,63 @@ use automation_lib::error::DeviceConfigError;
 use automation_lib::event::OnMqtt;
 use automation_lib::messages::ContactMessage;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
 use google_home::device;
 use google_home::errors::{DeviceError, ErrorCode};
 use google_home::traits::OpenClose;
 use google_home::types::Type;
+use lua_typed::Typed;
 use serde::Deserialize;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, error, trace};

-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Copy)]
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Copy, Typed)]
 pub enum SensorType {
    Door,
    Drawer,
    Window,
 }
+crate::register_type!(SensorType);

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "ContactSensorConfig")]
 pub struct Config {
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub info: InfoConfig,
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,

    #[device_config(default(SensorType::Window))]
+    #[typed(default)]
    pub sensor_type: SensorType,

    #[device_config(from_lua, default)]
-    pub callback: ActionCallback<ContactSensor, bool>,
+    #[typed(default)]
+    pub callback: ActionCallback<(ContactSensor, bool)>,
    #[device_config(from_lua, default)]
-    pub battery_callback: ActionCallback<ContactSensor, f32>,
+    #[typed(default)]
+    pub battery_callback: ActionCallback<(ContactSensor, f32)>,

    #[device_config(from_lua)]
+    #[typed(default)]
    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);

 #[derive(Debug)]
 struct State {
    is_closed: bool,
 }

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(OpenClose)]
+#[derive(Debug, Clone, Device)]
+#[device(traits(OpenClose))]
 pub struct ContactSensor {
    config: Config,
    state: Arc<RwLock<State>>,
 }
+crate::register_device!(ContactSensor);

 impl ContactSensor {
    async fn state(&self) -> RwLockReadGuard<'_, State> {
@@ -165,14 +176,17 @@ impl OnMqtt for ContactSensor {
                return;
            }

-            self.config.callback.call(self, &!is_closed).await;
+            self.config.callback.call((self.clone(), !is_closed)).await;

            debug!(id = self.get_id(), "Updating state to {is_closed}");
            self.state_mut().await.is_closed = is_closed;
        }

        if let Some(battery) = message.battery {
-            self.config.battery_callback.call(self, &battery).await;
+            self.config
+                .battery_callback
+                .call((self.clone(), battery))
+                .await;
        }
    }
 }
--- a/automation_devices/src/hue_bridge.rs
+++ b/automation_devices/src/hue_bridge.rs
@@ -3,39 +3,71 @@ use std::net::SocketAddr;

 use async_trait::async_trait;
 use automation_lib::device::{Device, LuaDeviceCreate};
-use automation_lib::lua::traits::AddAdditionalMethods;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_lib::lua::traits::PartialUserData;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use mlua::LuaSerdeExt;
 use serde::{Deserialize, Serialize};
 use tracing::{error, trace, warn};

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Typed)]
 #[serde(rename_all = "snake_case")]
+#[typed(rename_all = "snake_case")]
 pub enum Flag {
    Presence,
    Darkness,
 }
+crate::register_type!(Flag);

-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Typed)]
 pub struct FlagIDs {
    presence: isize,
    darkness: isize,
 }
+crate::register_type!(FlagIDs);

-#[derive(Debug, LuaDeviceConfig, Clone)]
+#[derive(Debug, LuaDeviceConfig, Clone, Typed)]
+#[typed(as = "HueBridgeConfig")]
 pub struct Config {
    pub identifier: String,
    #[device_config(rename("ip"), with(|ip| SocketAddr::new(ip, 80)))]
+    #[typed(as = "ip")]
    pub addr: SocketAddr,
    pub login: String,
    pub flags: FlagIDs,
 }
+crate::register_type!(Config);

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(AddAdditionalMethods)]
+#[derive(Debug, Clone, Device)]
+#[device(extra_user_data = SetFlag)]
 pub struct HueBridge {
    config: Config,
 }
+crate::register_device!(HueBridge);
+
+struct SetFlag;
+impl PartialUserData<HueBridge> for SetFlag {
+    fn add_methods<M: mlua::UserDataMethods<HueBridge>>(methods: &mut M) {
+        methods.add_async_method(
+            "set_flag",
+            async |lua, this, (flag, value): (mlua::Value, bool)| {
+                let flag: Flag = lua.from_value(flag)?;
+
+                this.set_flag(flag, value).await;
+
+                Ok(())
+            },
+        );
+    }
+
+    fn definitions() -> Option<String> {
+        Some(format!(
+            "---@async\n---@param flag {}\n---@param value boolean\nfunction {}:set_flag(flag, value) end\n",
+            <Flag as Typed>::type_name(),
+            <HueBridge as Typed>::type_name(),
+        ))
+    }
+}

 #[derive(Debug, Serialize)]
 struct FlagMessage {
@@ -91,21 +123,3 @@ impl Device for HueBridge {
        self.config.identifier.clone()
    }
 }
-
-impl AddAdditionalMethods for HueBridge {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + 'static,
-    {
-        methods.add_async_method(
-            "set_flag",
-            async |lua, this, (flag, value): (mlua::Value, bool)| {
-                let flag: Flag = lua.from_value(flag)?;
-
-                this.set_flag(flag, value).await;
-
-                Ok(())
-            },
-        );
-    }
-}
--- a/automation_devices/src/hue_group.rs
+++ b/automation_devices/src/hue_group.rs
@@ -2,28 +2,33 @@ use std::net::SocketAddr;

 use anyhow::Result;
 use async_trait::async_trait;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
 use google_home::errors::ErrorCode;
 use google_home::traits::OnOff;
+use lua_typed::Typed;
 use tracing::{error, trace, warn};

 use super::{Device, LuaDeviceCreate};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "HueGroupConfig")]
 pub struct Config {
    pub identifier: String,
    #[device_config(rename("ip"), with(|ip| SocketAddr::new(ip, 80)))]
+    #[typed(as = "ip")]
    pub addr: SocketAddr,
    pub login: String,
    pub group_id: isize,
    pub scene_id: String,
 }
+crate::register_type!(Config);

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(OnOff)]
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff))]
 pub struct HueGroup {
    config: Config,
 }
+crate::register_device!(HueGroup);

 // Couple of helper function to get the correct urls
 #[async_trait]
--- a/automation_devices/src/hue_switch.rs
+++ b/automation_devices/src/hue_switch.rs
@@ -4,37 +4,47 @@ use automation_lib::config::{InfoConfig, MqttDeviceConfig};
 use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::{Publish, matches};
 use serde::Deserialize;
 use tracing::{debug, trace, warn};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "HueSwitchConfig")]
 pub struct Config {
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub info: InfoConfig,

    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,

    #[device_config(from_lua)]
    pub client: WrappedAsyncClient,

    #[device_config(from_lua, default)]
-    pub left_callback: ActionCallback<HueSwitch, ()>,
+    #[typed(default)]
+    pub left_callback: ActionCallback<HueSwitch>,

    #[device_config(from_lua, default)]
-    pub right_callback: ActionCallback<HueSwitch, ()>,
+    #[typed(default)]
+    pub right_callback: ActionCallback<HueSwitch>,

    #[device_config(from_lua, default)]
-    pub left_hold_callback: ActionCallback<HueSwitch, ()>,
+    #[typed(default)]
+    pub left_hold_callback: ActionCallback<HueSwitch>,

    #[device_config(from_lua, default)]
-    pub right_hold_callback: ActionCallback<HueSwitch, ()>,
+    #[typed(default)]
+    pub right_hold_callback: ActionCallback<HueSwitch>,

    #[device_config(from_lua, default)]
-    pub battery_callback: ActionCallback<HueSwitch, f32>,
+    #[typed(default)]
+    pub battery_callback: ActionCallback<(HueSwitch, f32)>,
 }
+crate::register_type!(Config);

 #[derive(Debug, Copy, Clone, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -55,10 +65,11 @@ struct State {
    battery: Option<f32>,
 }

-#[derive(Debug, Clone, LuaDevice)]
+#[derive(Debug, Clone, Device)]
 pub struct HueSwitch {
    config: Config,
 }
+crate::register_device!(HueSwitch);

 impl Device for HueSwitch {
    fn get_id(&self) -> String {
@@ -104,19 +115,21 @@ impl OnMqtt for HueSwitch {
                );

                match action {
-                    Action::LeftPressRelease => self.config.left_callback.call(self, &()).await,
-                    Action::RightPressRelease => self.config.right_callback.call(self, &()).await,
-                    Action::LeftHold => self.config.left_hold_callback.call(self, &()).await,
-                    Action::RightHold => self.config.right_hold_callback.call(self, &()).await,
+                    Action::LeftPressRelease => self.config.left_callback.call(self.clone()).await,
+                    Action::RightPressRelease => {
+                        self.config.right_callback.call(self.clone()).await
+                    }
+                    Action::LeftHold => self.config.left_hold_callback.call(self.clone()).await,
+                    Action::RightHold => self.config.right_hold_callback.call(self.clone()).await,
                    // If there is no hold action, the switch will act like a normal release
                    Action::RightHoldRelease => {
-                        if !self.config.right_hold_callback.is_set() {
-                            self.config.right_callback.call(self, &()).await
+                        if self.config.right_hold_callback.is_empty() {
+                            self.config.right_callback.call(self.clone()).await
                        }
                    }
                    Action::LeftHoldRelease => {
-                        if !self.config.left_hold_callback.is_set() {
-                            self.config.left_callback.call(self, &()).await
+                        if self.config.left_hold_callback.is_empty() {
+                            self.config.left_callback.call(self.clone()).await
                        }
                    }
                    _ => {}
@@ -124,7 +137,10 @@ impl OnMqtt for HueSwitch {
            }

            if let Some(battery) = message.battery {
-                self.config.battery_callback.call(self, &battery).await;
+                self.config
+                    .battery_callback
+                    .call((self.clone(), battery))
+                    .await;
            }
        }
    }
--- a/automation_devices/src/ikea_remote.rs
+++ b/automation_devices/src/ikea_remote.rs
@@ -5,34 +5,43 @@ use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
 use automation_lib::messages::{RemoteAction, RemoteMessage};
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::{Publish, matches};
 use tracing::{debug, error, trace};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "IkeaRemoteConfig")]
 pub struct Config {
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub info: InfoConfig,

    #[device_config(default)]
+    #[typed(default)]
    pub single_button: bool,

    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,

    #[device_config(from_lua)]
    pub client: WrappedAsyncClient,

-    #[device_config(from_lua)]
-    pub callback: ActionCallback<IkeaRemote, bool>,
    #[device_config(from_lua, default)]
-    pub battery_callback: ActionCallback<IkeaRemote, f32>,
+    #[typed(default)]
+    pub callback: ActionCallback<(IkeaRemote, bool)>,
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub battery_callback: ActionCallback<(IkeaRemote, f32)>,
 }
+crate::register_type!(Config);

-#[derive(Debug, Clone, LuaDevice)]
+#[derive(Debug, Clone, Device)]
 pub struct IkeaRemote {
    config: Config,
 }
+crate::register_device!(IkeaRemote);

 impl Device for IkeaRemote {
    fn get_id(&self) -> String {
@@ -88,12 +97,15 @@ impl OnMqtt for IkeaRemote {
                };

                if let Some(on) = on {
-                    self.config.callback.call(self, &on).await;
+                    self.config.callback.call((self.clone(), on)).await;
                }
            }

            if let Some(battery) = message.battery {
-                self.config.battery_callback.call(self, &battery).await;
+                self.config
+                    .battery_callback
+                    .call((self.clone(), battery))
+                    .await;
            }
        }
    }
--- a/automation_devices/src/kasa_outlet.rs
+++ b/automation_devices/src/kasa_outlet.rs
@@ -4,28 +4,33 @@ use std::str::Utf8Error;

 use async_trait::async_trait;
 use automation_lib::device::{Device, LuaDeviceCreate};
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
 use bytes::{Buf, BufMut};
 use google_home::errors::{self, DeviceError};
 use google_home::traits::OnOff;
+use lua_typed::Typed;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tracing::trace;

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "KasaOutletConfig")]
 pub struct Config {
    pub identifier: String,
    #[device_config(rename("ip"), with(|ip| SocketAddr::new(ip, 9999)))]
+    #[typed(as = "ip")]
    pub addr: SocketAddr,
 }
+crate::register_type!(Config);

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(OnOff)]
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff))]
 pub struct KasaOutlet {
    config: Config,
 }
+crate::register_device!(KasaOutlet);

 #[async_trait]
 impl LuaDeviceCreate for KasaOutlet {
--- a/automation_devices/src/lib.rs
+++ b/automation_devices/src/lib.rs
@@ -1,3 +1,4 @@
+#![feature(iter_intersperse)]
 mod air_filter;
 mod contact_sensor;
 mod hue_bridge;
@@ -12,48 +13,118 @@ mod wake_on_lan;
 mod washer;
 mod zigbee;

+use automation_lib::Module;
 use automation_lib::device::{Device, LuaDeviceCreate};
-use zigbee::light::{LightBrightness, LightColorTemperature, LightOnOff};
-use zigbee::outlet::{OutletOnOff, OutletPower};
+use tracing::{debug, warn};

-pub use self::air_filter::AirFilter;
-pub use self::contact_sensor::ContactSensor;
-pub use self::hue_bridge::HueBridge;
-pub use self::hue_group::HueGroup;
-pub use self::hue_switch::HueSwitch;
-pub use self::ikea_remote::IkeaRemote;
-pub use self::kasa_outlet::KasaOutlet;
-pub use self::light_sensor::LightSensor;
-pub use self::ntfy::*;
-pub use self::presence::Presence;
-pub use self::wake_on_lan::WakeOnLAN;
-pub use self::washer::Washer;
+type DeviceNameFn = fn() -> String;
+type RegisterDeviceFn = fn(lua: &mlua::Lua) -> mlua::Result<mlua::AnyUserData>;
+
+pub struct RegisteredDevice {
+    name_fn: DeviceNameFn,
+    register_fn: RegisterDeviceFn,
+}
+
+impl RegisteredDevice {
+    pub const fn new(name_fn: DeviceNameFn, register_fn: RegisterDeviceFn) -> Self {
+        Self {
+            name_fn,
+            register_fn,
+        }
+    }
+
+    pub fn get_name(&self) -> String {
+        (self.name_fn)()
+    }
+
+    pub fn register(&self, lua: &mlua::Lua) -> mlua::Result<mlua::AnyUserData> {
+        (self.register_fn)(lua)
+    }
+}

 macro_rules! register_device {
-    ($lua:expr, $device:ty) => {
-        $lua.globals()
-            .set(stringify!($device), $lua.create_proxy::<$device>()?)?;
+    ($device:ty) => {
+        ::inventory::submit!(crate::RegisteredDevice::new(
+            <$device as ::lua_typed::Typed>::type_name,
+            ::mlua::Lua::create_proxy::<$device>
+        ));
+
+        crate::register_type!($device);
    };
 }
+pub(crate) use register_device;

-pub fn register_with_lua(lua: &mlua::Lua) -> mlua::Result<()> {
-    register_device!(lua, AirFilter);
-    register_device!(lua, ContactSensor);
-    register_device!(lua, HueBridge);
-    register_device!(lua, HueGroup);
-    register_device!(lua, HueSwitch);
-    register_device!(lua, IkeaRemote);
-    register_device!(lua, KasaOutlet);
-    register_device!(lua, LightBrightness);
-    register_device!(lua, LightColorTemperature);
-    register_device!(lua, LightOnOff);
-    register_device!(lua, LightSensor);
-    register_device!(lua, Ntfy);
-    register_device!(lua, OutletOnOff);
-    register_device!(lua, OutletPower);
-    register_device!(lua, Presence);
-    register_device!(lua, WakeOnLAN);
-    register_device!(lua, Washer);
+inventory::collect!(RegisteredDevice);

-    Ok(())
+pub fn create_module(lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
+    let devices = lua.create_table()?;
+
+    debug!("Loading devices...");
+    for device in inventory::iter::<RegisteredDevice> {
+        let name = device.get_name();
+        debug!(name, "Registering device");
+        let proxy = device.register(lua)?;
+        devices.set(name, proxy)?;
+    }
+
+    Ok(devices)
 }
+
+type TypeNameFn = fn() -> String;
+type TypeDefinitionFn = fn() -> Option<String>;
+
+pub struct RegisteredType {
+    name_fn: TypeNameFn,
+    definition_fn: TypeDefinitionFn,
+}
+
+impl RegisteredType {
+    pub const fn new(name_fn: TypeNameFn, definition_fn: TypeDefinitionFn) -> Self {
+        Self {
+            name_fn,
+            definition_fn,
+        }
+    }
+
+    pub fn get_name(&self) -> String {
+        (self.name_fn)()
+    }
+
+    pub fn register(&self) -> Option<String> {
+        (self.definition_fn)()
+    }
+}
+
+macro_rules! register_type {
+    ($ty:ty) => {
+        ::inventory::submit!(crate::RegisteredType::new(
+            <$ty as ::lua_typed::Typed>::type_name,
+            <$ty as ::lua_typed::Typed>::generate_full
+        ));
+    };
+}
+pub(crate) use register_type;
+
+inventory::collect!(RegisteredType);
+
+fn generate_definitions() -> String {
+    let mut output = String::new();
+
+    let mut types: Vec<_> = inventory::iter::<RegisteredType>.into_iter().collect();
+    types.sort_by_key(|ty| ty.get_name());
+
+    output += "---@meta\n\nlocal devices\n\n";
+    for ty in types {
+        if let Some(def) = (ty.definition_fn)() {
+            output += &(def + "\n");
+        } else {
+            // NOTE: Due to how this works the typed is erased, so we don't know the cause
+            warn!("Registered type is missing generate_full function");
+        }
+    }
+    output += "return devices";
+
+    output
+}
+
+inventory::submit! {Module::new("automation:devices", create_module, Some(generate_definitions))}
--- a/automation_devices/src/light_sensor.rs
+++ b/automation_devices/src/light_sensor.rs
@@ -7,25 +7,30 @@ use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
 use automation_lib::messages::BrightnessMessage;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, trace, warn};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "LightSensorConfig")]
 pub struct Config {
    pub identifier: String,
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,
    pub min: isize,
    pub max: isize,

    #[device_config(from_lua, default)]
-    pub callback: ActionCallback<LightSensor, bool>,
+    #[typed(default)]
+    pub callback: ActionCallback<(LightSensor, bool)>,

    #[device_config(from_lua)]
    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);

 const DEFAULT: bool = false;

@@ -34,11 +39,12 @@ pub struct State {
    is_dark: bool,
 }

-#[derive(Debug, Clone, LuaDevice)]
+#[derive(Debug, Clone, Device)]
 pub struct LightSensor {
    config: Config,
    state: Arc<RwLock<State>>,
 }
+crate::register_device!(LightSensor);

 impl LightSensor {
    async fn state(&self) -> RwLockReadGuard<'_, State> {
@@ -114,7 +120,7 @@ impl OnMqtt for LightSensor {

            self.config
                .callback
-                .call(self, &!self.state().await.is_dark)
+                .call((self.clone(), !self.state().await.is_dark))
                .await;
        }
    }
--- a/automation_devices/src/ntfy.rs
+++ b/automation_devices/src/ntfy.rs
@@ -3,16 +3,18 @@ use std::convert::Infallible;

 use async_trait::async_trait;
 use automation_lib::device::{Device, LuaDeviceCreate};
-use automation_lib::lua::traits::AddAdditionalMethods;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_lib::lua::traits::PartialUserData;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use mlua::LuaSerdeExt;
 use serde::{Deserialize, Serialize};
 use serde_repr::*;
 use tracing::{error, trace, warn};

-#[derive(Debug, Serialize_repr, Deserialize, Clone, Copy)]
+#[derive(Debug, Serialize_repr, Deserialize, Clone, Copy, Typed)]
 #[repr(u8)]
 #[serde(rename_all = "snake_case")]
+#[typed(rename_all = "snake_case")]
 pub enum Priority {
    Min = 1,
    Low,
@@ -20,83 +22,56 @@ pub enum Priority {
    High,
    Max,
 }
+crate::register_type!(Priority);

-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Typed)]
 #[serde(rename_all = "snake_case", tag = "action")]
+#[typed(rename_all = "snake_case", tag = "action")]
 pub enum ActionType {
    Broadcast {
        #[serde(skip_serializing_if = "HashMap::is_empty")]
+        #[serde(default)]
+        #[typed(default)]
        extras: HashMap<String, String>,
    },
    // View,
    // Http
 }

-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Typed)]
 pub struct Action {
    #[serde(flatten)]
+    #[typed(flatten)]
    pub action: ActionType,
    pub label: String,
    pub clear: Option<bool>,
 }
+crate::register_type!(Action);

-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Typed)]
 struct NotificationFinal {
    topic: String,
    #[serde(flatten)]
+    #[typed(flatten)]
    inner: Notification,
 }

-#[derive(Debug, Serialize, Clone, Deserialize)]
+#[derive(Debug, Serialize, Clone, Deserialize, Typed)]
 pub struct Notification {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    title: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    title: String,
    message: Option<String>,
    #[serde(skip_serializing_if = "Vec::is_empty", default = "Default::default")]
+    #[typed(default)]
    tags: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    priority: Option<Priority>,
    #[serde(skip_serializing_if = "Vec::is_empty", default = "Default::default")]
+    #[typed(default)]
    actions: Vec<Action>,
 }
+crate::register_type!(Notification);

 impl Notification {
-    pub fn new() -> Self {
-        Self {
-            title: None,
-            message: None,
-            tags: Vec::new(),
-            priority: None,
-            actions: Vec::new(),
-        }
-    }
-
-    pub fn set_title(mut self, title: &str) -> Self {
-        self.title = Some(title.into());
-        self
-    }
-
-    pub fn set_message(mut self, message: &str) -> Self {
-        self.message = Some(message.into());
-        self
-    }
-
-    pub fn add_tag(mut self, tag: &str) -> Self {
-        self.tags.push(tag.into());
-        self
-    }
-
-    pub fn set_priority(mut self, priority: Priority) -> Self {
-        self.priority = Some(priority);
-        self
-    }
-
-    pub fn add_action(mut self, action: Action) -> Self {
-        self.actions.push(action);
-        self
-    }
-
    fn finalize(self, topic: &str) -> NotificationFinal {
        NotificationFinal {
            topic: topic.into(),
@@ -105,24 +80,46 @@ impl Notification {
    }
 }

-impl Default for Notification {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "NtfyConfig")]
 pub struct Config {
    #[device_config(default("https://ntfy.sh".into()))]
+    #[typed(default)]
    pub url: String,
    pub topic: String,
 }
+crate::register_type!(Config);

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(AddAdditionalMethods)]
+#[derive(Debug, Clone, Device)]
+#[device(extra_user_data = SendNotification)]
 pub struct Ntfy {
    config: Config,
 }
+crate::register_device!(Ntfy);
+
+struct SendNotification;
+impl PartialUserData<Ntfy> for SendNotification {
+    fn add_methods<M: mlua::UserDataMethods<Ntfy>>(methods: &mut M) {
+        methods.add_async_method(
+            "send_notification",
+            async |lua, this, notification: mlua::Value| {
+                let notification: Notification = lua.from_value(notification)?;
+
+                this.send(notification).await;
+
+                Ok(())
+            },
+        );
+    }
+
+    fn definitions() -> Option<String> {
+        Some(format!(
+            "---@async\n---@param notification {}\nfunction {}:send_notification(notification) end\n",
+            <Notification as Typed>::type_name(),
+            <Ntfy as Typed>::type_name(),
+        ))
+    }
+}

 #[async_trait]
 impl LuaDeviceCreate for Ntfy {
@@ -162,21 +159,3 @@ impl Ntfy {
        }
    }
 }
-
-impl AddAdditionalMethods for Ntfy {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + 'static,
-    {
-        methods.add_async_method(
-            "send_notification",
-            async |lua, this, notification: mlua::Value| {
-                let notification: Notification = lua.from_value(notification)?;
-
-                this.send(notification).await;
-
-                Ok(())
-            },
-        );
-    }
-}
--- a/automation_devices/src/presence.rs
+++ b/automation_devices/src/presence.rs
@@ -6,25 +6,30 @@ use automation_lib::action_callback::ActionCallback;
 use automation_lib::config::MqttDeviceConfig;
 use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
-use automation_lib::lua::traits::AddAdditionalMethods;
+use automation_lib::lua::traits::PartialUserData;
 use automation_lib::messages::PresenceMessage;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, trace, warn};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "PresenceConfig")]
 pub struct Config {
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,

    #[device_config(from_lua, default)]
-    pub callback: ActionCallback<Presence, bool>,
+    #[typed(default)]
+    pub callback: ActionCallback<(Presence, bool)>,

    #[device_config(from_lua)]
    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);

 pub const DEFAULT_PRESENCE: bool = false;

@@ -34,12 +39,29 @@ pub struct State {
    current_overall_presence: bool,
 }

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(AddAdditionalMethods)]
+#[derive(Debug, Clone, Device)]
+#[device(extra_user_data = OverallPresence)]
 pub struct Presence {
    config: Config,
    state: Arc<RwLock<State>>,
 }
+crate::register_device!(Presence);
+
+struct OverallPresence;
+impl PartialUserData<Presence> for OverallPresence {
+    fn add_methods<M: mlua::UserDataMethods<Presence>>(methods: &mut M) {
+        methods.add_async_method("overall_presence", async |_lua, this, ()| {
+            Ok(this.state().await.current_overall_presence)
+        });
+    }
+
+    fn definitions() -> Option<String> {
+        Some(format!(
+            "---@async\n---@return boolean\nfunction {}:overall_presence() end\n",
+            <Presence as Typed>::type_name(),
+        ))
+    }
+}

 impl Presence {
    async fn state(&self) -> RwLockReadGuard<'_, State> {
@@ -118,18 +140,10 @@ impl OnMqtt for Presence {
            debug!("Overall presence updated: {overall_presence}");
            self.state_mut().await.current_overall_presence = overall_presence;

-            self.config.callback.call(self, &overall_presence).await;
+            self.config
+                .callback
+                .call((self.clone(), overall_presence))
+                .await;
        }
    }
 }
-
-impl AddAdditionalMethods for Presence {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + 'static,
-    {
-        methods.add_async_method("overall_presence", async |_lua, this, ()| {
-            Ok(this.state().await.current_overall_presence)
-        });
-    }
-}
--- a/automation_devices/src/wake_on_lan.rs
+++ b/automation_devices/src/wake_on_lan.rs
@@ -6,32 +6,39 @@ use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
 use automation_lib::messages::ActivateMessage;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
 use eui48::MacAddress;
 use google_home::device;
 use google_home::errors::ErrorCode;
 use google_home::traits::{self, Scene};
 use google_home::types::Type;
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tracing::{debug, error, trace};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "WolConfig")]
 pub struct Config {
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub info: InfoConfig,
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,
    pub mac_address: MacAddress,
    #[device_config(default(Ipv4Addr::new(255, 255, 255, 255)))]
+    #[typed(default)]
    pub broadcast_ip: Ipv4Addr,
    #[device_config(from_lua)]
    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);

-#[derive(Debug, Clone, LuaDevice)]
+#[derive(Debug, Clone, Device)]
 pub struct WakeOnLAN {
    config: Config,
 }
+crate::register_device!(WakeOnLAN);

 #[async_trait]
 impl LuaDeviceCreate for WakeOnLAN {
--- a/automation_devices/src/washer.rs
+++ b/automation_devices/src/washer.rs
@@ -7,25 +7,30 @@ use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
 use automation_lib::messages::PowerMessage;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, error, trace};

-#[derive(Debug, Clone, LuaDeviceConfig)]
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "WasherConfig")]
 pub struct Config {
    pub identifier: String,
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,
    // Power in Watt
    pub threshold: f32,

    #[device_config(from_lua, default)]
-    pub done_callback: ActionCallback<Washer, ()>,
+    #[typed(default)]
+    pub done_callback: ActionCallback<Washer>,

    #[device_config(from_lua)]
    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);

 #[derive(Debug)]
 pub struct State {
@@ -33,11 +38,12 @@ pub struct State {
 }

 // TODO: Add google home integration
-#[derive(Debug, Clone, LuaDevice)]
+#[derive(Debug, Clone, Device)]
 pub struct Washer {
    config: Config,
    state: Arc<RwLock<State>>,
 }
+crate::register_device!(Washer);

 impl Washer {
    async fn state(&self) -> RwLockReadGuard<'_, State> {
@@ -109,7 +115,7 @@ impl OnMqtt for Washer {

            self.state_mut().await.running = 0;

-            self.config.done_callback.call(self, &()).await;
+            self.config.done_callback.call(self.clone()).await;
        } else if power < self.config.threshold {
            // Prevent false positives
            self.state_mut().await.running = 0;
--- a/automation_devices/src/zigbee/light.rs
+++ b/automation_devices/src/zigbee/light.rs
@@ -10,11 +10,12 @@ use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
 use automation_lib::helpers::serialization::state_deserializer;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig, LuaSerialize};
 use google_home::device;
 use google_home::errors::ErrorCode;
 use google_home::traits::{Brightness, Color, ColorSetting, ColorTemperatureRange, OnOff};
 use google_home::types::Type;
+use lua_typed::Typed;
 use rumqttc::{Publish, matches};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -22,33 +23,47 @@ use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, trace, warn};

 pub trait LightState:
-    Debug + Clone + Default + Sync + Send + Serialize + Into<StateOnOff> + 'static
+    Debug + Clone + Default + Sync + Send + Serialize + Into<StateOnOff> + Typed + 'static
 {
 }

-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct Config<T: LightState> {
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "ConfigLight")]
+pub struct Config<T: LightState>
+where
+    Light<T>: Typed,
+{
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub info: InfoConfig,
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,

    #[device_config(from_lua, default)]
-    pub callback: ActionCallback<Light<T>, T>,
+    #[typed(default)]
+    pub callback: ActionCallback<(Light<T>, T)>,

    #[device_config(from_lua)]
+    #[typed(default)]
    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config<StateOnOff>);
+crate::register_type!(Config<StateBrightness>);
+crate::register_type!(Config<StateColorTemperature>);

-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "LightStateOnOff")]
 pub struct StateOnOff {
    #[serde(deserialize_with = "state_deserializer")]
    state: bool,
 }

 impl LightState for StateOnOff {}
+crate::register_type!(StateOnOff);

-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "LightStateBrightness")]
 pub struct StateBrightness {
    #[serde(deserialize_with = "state_deserializer")]
    state: bool,
@@ -56,6 +71,7 @@ pub struct StateBrightness {
 }

 impl LightState for StateBrightness {}
+crate::register_type!(StateBrightness);

 impl From<StateBrightness> for StateOnOff {
    fn from(state: StateBrightness) -> Self {
@@ -63,13 +79,15 @@ impl From<StateBrightness> for StateOnOff {
    }
 }

-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "LightStateColorTemperature")]
 pub struct StateColorTemperature {
    #[serde(deserialize_with = "state_deserializer")]
    state: bool,
    brightness: f32,
    color_temp: u32,
 }
+crate::register_type!(StateColorTemperature);

 impl LightState for StateColorTemperature {}

@@ -88,21 +106,32 @@ impl From<StateColorTemperature> for StateBrightness {
    }
 }

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(<StateOnOff>: OnOff)]
-#[traits(<StateBrightness>: OnOff, Brightness)]
-#[traits(<StateColorTemperature>: OnOff, Brightness, ColorSetting)]
-pub struct Light<T: LightState> {
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff for LightOnOff, LightBrightness, LightColorTemperature))]
+#[device(traits(Brightness for LightBrightness, LightColorTemperature))]
+#[device(traits(ColorSetting for LightColorTemperature))]
+pub struct Light<T: LightState>
+where
+    Light<T>: Typed,
+{
    config: Config<T>,

    state: Arc<RwLock<T>>,
 }

 pub type LightOnOff = Light<StateOnOff>;
-pub type LightBrightness = Light<StateBrightness>;
-pub type LightColorTemperature = Light<StateColorTemperature>;
+crate::register_device!(LightOnOff);

-impl<T: LightState> Light<T> {
+pub type LightBrightness = Light<StateBrightness>;
+crate::register_device!(LightBrightness);
+
+pub type LightColorTemperature = Light<StateColorTemperature>;
+crate::register_device!(LightColorTemperature);
+
+impl<T: LightState> Light<T>
+where
+    Light<T>: Typed,
+{
    async fn state(&self) -> RwLockReadGuard<'_, T> {
        self.state.read().await
    }
@@ -113,7 +142,10 @@ impl<T: LightState> Light<T> {
 }

 #[async_trait]
-impl<T: LightState> LuaDeviceCreate for Light<T> {
+impl<T: LightState> LuaDeviceCreate for Light<T>
+where
+    Light<T>: Typed,
+{
    type Config = Config<T>;
    type Error = rumqttc::ClientError;

@@ -132,14 +164,17 @@ impl<T: LightState> LuaDeviceCreate for Light<T> {
    }
 }

-impl<T: LightState> Device for Light<T> {
+impl<T: LightState> Device for Light<T>
+where
+    Light<T>: Typed,
+{
    fn get_id(&self) -> String {
        self.config.info.identifier()
    }
 }

 #[async_trait]
-impl OnMqtt for Light<StateOnOff> {
+impl OnMqtt for LightOnOff {
    async fn on_mqtt(&self, message: Publish) {
        // Check if the message is from the device itself or from a remote
        if matches(&message.topic, &self.config.mqtt.topic) {
@@ -165,14 +200,14 @@ impl OnMqtt for Light<StateOnOff> {

            self.config
                .callback
-                .call(self, self.state().await.deref())
+                .call((self.clone(), self.state().await.clone()))
                .await;
        }
    }
 }

 #[async_trait]
-impl OnMqtt for Light<StateBrightness> {
+impl OnMqtt for LightBrightness {
    async fn on_mqtt(&self, message: Publish) {
        // Check if the message is from the deviec itself or from a remote
        if matches(&message.topic, &self.config.mqtt.topic) {
@@ -204,14 +239,14 @@ impl OnMqtt for Light<StateBrightness> {

            self.config
                .callback
-                .call(self, self.state().await.deref())
+                .call((self.clone(), self.state().await.clone()))
                .await;
        }
    }
 }

 #[async_trait]
-impl OnMqtt for Light<StateColorTemperature> {
+impl OnMqtt for LightColorTemperature {
    async fn on_mqtt(&self, message: Publish) {
        // Check if the message is from the deviec itself or from a remote
        if matches(&message.topic, &self.config.mqtt.topic) {
@@ -245,14 +280,17 @@ impl OnMqtt for Light<StateColorTemperature> {

            self.config
                .callback
-                .call(self, self.state().await.deref())
+                .call((self.clone(), self.state().await.clone()))
                .await;
        }
    }
 }

 #[async_trait]
-impl<T: LightState> google_home::Device for Light<T> {
+impl<T: LightState> google_home::Device for Light<T>
+where
+    Light<T>: Typed,
+{
    fn get_device_type(&self) -> Type {
        Type::Light
    }
@@ -283,6 +321,7 @@ impl<T: LightState> google_home::Device for Light<T> {
 impl<T> OnOff for Light<T>
 where
    T: LightState,
+    Light<T>: Typed,
 {
    async fn on(&self) -> Result<bool, ErrorCode> {
        let state = self.state().await;
@@ -322,6 +361,7 @@ impl<T> Brightness for Light<T>
 where
    T: LightState,
    T: Into<StateBrightness>,
+    Light<T>: Typed,
 {
    async fn brightness(&self) -> Result<u8, ErrorCode> {
        let state = self.state().await;
@@ -363,6 +403,7 @@ impl<T> ColorSetting for Light<T>
 where
    T: LightState,
    T: Into<StateColorTemperature>,
+    Light<T>: Typed,
 {
    fn color_temperature_range(&self) -> ColorTemperatureRange {
        ColorTemperatureRange {
--- a/automation_devices/src/zigbee/outlet.rs
+++ b/automation_devices/src/zigbee/outlet.rs
@@ -10,11 +10,12 @@ use automation_lib::device::{Device, LuaDeviceCreate};
 use automation_lib::event::OnMqtt;
 use automation_lib::helpers::serialization::state_deserializer;
 use automation_lib::mqtt::WrappedAsyncClient;
-use automation_macro::{LuaDevice, LuaDeviceConfig};
+use automation_macro::{Device, LuaDeviceConfig, LuaSerialize};
 use google_home::device;
 use google_home::errors::ErrorCode;
 use google_home::traits::OnOff;
 use google_home::types::Type;
+use lua_typed::Typed;
 use rumqttc::{Publish, matches};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -22,15 +23,16 @@ use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, trace, warn};

 pub trait OutletState:
-    Debug + Clone + Default + Sync + Send + Serialize + Into<StateOnOff> + 'static
+    Debug + Clone + Default + Sync + Send + Serialize + Into<StateOnOff> + Typed + 'static
 {
 }

-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Copy)]
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Copy, Typed)]
 pub enum OutletType {
    Outlet,
    Kettle,
 }
+crate::register_type!(OutletType);

 impl From<OutletType> for Type {
    fn from(outlet: OutletType) -> Self {
@@ -41,36 +43,50 @@ impl From<OutletType> for Type {
    }
 }

-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct Config<T: OutletState> {
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "ConfigOutlet")]
+pub struct Config<T: OutletState>
+where
+    Outlet<T>: Typed,
+{
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub info: InfoConfig,
    #[device_config(flatten)]
+    #[typed(flatten)]
    pub mqtt: MqttDeviceConfig,
    #[device_config(default(OutletType::Outlet))]
+    #[typed(default)]
    pub outlet_type: OutletType,

    #[device_config(from_lua, default)]
-    pub callback: ActionCallback<Outlet<T>, T>,
+    #[typed(default)]
+    pub callback: ActionCallback<(Outlet<T>, T)>,

    #[device_config(from_lua)]
    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config<StateOnOff>);
+crate::register_type!(Config<StatePower>);

-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "OutletStateOnOff")]
 pub struct StateOnOff {
    #[serde(deserialize_with = "state_deserializer")]
    state: bool,
 }
+crate::register_type!(StateOnOff);

 impl OutletState for StateOnOff {}

-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "OutletStatePower")]
 pub struct StatePower {
    #[serde(deserialize_with = "state_deserializer")]
    state: bool,
    power: f64,
 }
+crate::register_type!(StatePower);

 impl OutletState for StatePower {}

@@ -80,19 +96,27 @@ impl From<StatePower> for StateOnOff {
    }
 }

-#[derive(Debug, Clone, LuaDevice)]
-#[traits(<StateOnOff>: OnOff)]
-#[traits(<StatePower>: OnOff)]
-pub struct Outlet<T: OutletState> {
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff for OutletOnOff, OutletPower))]
+pub struct Outlet<T: OutletState>
+where
+    Outlet<T>: Typed,
+{
    config: Config<T>,

    state: Arc<RwLock<T>>,
 }

 pub type OutletOnOff = Outlet<StateOnOff>;
-pub type OutletPower = Outlet<StatePower>;
+crate::register_device!(OutletOnOff);

-impl<T: OutletState> Outlet<T> {
+pub type OutletPower = Outlet<StatePower>;
+crate::register_device!(OutletPower);
+
+impl<T: OutletState> Outlet<T>
+where
+    Outlet<T>: Typed,
+{
    async fn state(&self) -> RwLockReadGuard<'_, T> {
        self.state.read().await
    }
@@ -103,7 +127,10 @@ impl<T: OutletState> Outlet<T> {
 }

 #[async_trait]
-impl<T: OutletState> LuaDeviceCreate for Outlet<T> {
+impl<T: OutletState> LuaDeviceCreate for Outlet<T>
+where
+    Outlet<T>: Typed,
+{
    type Config = Config<T>;
    type Error = rumqttc::ClientError;

@@ -122,14 +149,17 @@ impl<T: OutletState> LuaDeviceCreate for Outlet<T> {
    }
 }

-impl<T: OutletState> Device for Outlet<T> {
+impl<T: OutletState> Device for Outlet<T>
+where
+    Outlet<T>: Typed,
+{
    fn get_id(&self) -> String {
        self.config.info.identifier()
    }
 }

 #[async_trait]
-impl OnMqtt for Outlet<StateOnOff> {
+impl OnMqtt for OutletOnOff {
    async fn on_mqtt(&self, message: Publish) {
        // Check if the message is from the device itself or from a remote
        if matches(&message.topic, &self.config.mqtt.topic) {
@@ -155,14 +185,14 @@ impl OnMqtt for Outlet<StateOnOff> {

            self.config
                .callback
-                .call(self, self.state().await.deref())
+                .call((self.clone(), self.state().await.clone()))
                .await;
        }
    }
 }

 #[async_trait]
-impl OnMqtt for Outlet<StatePower> {
+impl OnMqtt for OutletPower {
    async fn on_mqtt(&self, message: Publish) {
        // Check if the message is from the deviec itself or from a remote
        if matches(&message.topic, &self.config.mqtt.topic) {
@@ -192,14 +222,17 @@ impl OnMqtt for Outlet<StatePower> {

            self.config
                .callback
-                .call(self, self.state().await.deref())
+                .call((self.clone(), self.state().await.clone()))
                .await;
        }
    }
 }

 #[async_trait]
-impl<T: OutletState> google_home::Device for Outlet<T> {
+impl<T: OutletState> google_home::Device for Outlet<T>
+where
+    Outlet<T>: Typed,
+{
    fn get_device_type(&self) -> Type {
        self.config.outlet_type.into()
    }
@@ -230,6 +263,7 @@ impl<T: OutletState> google_home::Device for Outlet<T> {
 impl<T> OnOff for Outlet<T>
 where
    T: OutletState,
+    Outlet<T>: Typed,
 {
    async fn on(&self) -> Result<bool, ErrorCode> {
        let state = self.state().await;
--- a/automation_lib/Cargo.toml
+++ b/automation_lib/Cargo.toml
@@ -4,19 +4,20 @@ version = "0.1.0"
 edition = "2024"

 [dependencies]
+automation_macro = { workspace = true }
 async-trait = { workspace = true }
 automation_cast = { workspace = true }
 bytes = { workspace = true }
 dyn-clone = { workspace = true }
 futures = { workspace = true }
 google_home = { workspace = true }
-indexmap = { workspace = true }
+hostname = { workspace = true }
+inventory = { workspace = true }
+lua_typed = { workspace = true }
 mlua = { workspace = true }
 rumqttc = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
-tokio-cron-scheduler = { workspace = true }
 tracing = { workspace = true }
-uuid = { workspace = true }
--- a/automation_lib/src/action_callback.rs
+++ b/automation_lib/src/action_callback.rs
@@ -1,71 +1,94 @@
 use std::marker::PhantomData;

-use mlua::{FromLua, IntoLua, LuaSerdeExt};
-use serde::Serialize;
+use futures::future::try_join_all;
+use lua_typed::Typed;
+use mlua::{FromLua, IntoLuaMulti};

 #[derive(Debug, Clone)]
-struct Internal {
-    uuid: uuid::Uuid,
-    lua: mlua::Lua,
+pub struct ActionCallback<P> {
+    callbacks: Vec<mlua::Function>,
+    _parameters: PhantomData<P>,
 }

-#[derive(Debug, Clone)]
-pub struct ActionCallback<T, S> {
-    internal: Option<Internal>,
-    _this: PhantomData<T>,
-    _state: PhantomData<S>,
+impl Typed for ActionCallback<()> {
+    fn type_name() -> String {
+        "fun() | fun()[]".into()
+    }
 }

-impl<T, S> Default for ActionCallback<T, S> {
+impl<A: Typed> Typed for ActionCallback<A> {
+    fn type_name() -> String {
+        let type_name = A::type_name();
+        format!("fun(_: {type_name}) | fun(_: {type_name})[]")
+    }
+}
+
+impl<A: Typed, B: Typed> Typed for ActionCallback<(A, B)> {
+    fn type_name() -> String {
+        let type_name_a = A::type_name();
+        let type_name_b = B::type_name();
+        format!(
+            "fun(_: {type_name_a}, _: {type_name_b}) | fun(_: {type_name_a}, _: {type_name_b})[]"
+        )
+    }
+}
+
+// NOTE: For some reason the derive macro combined with PhantomData leads to issues where it
+// requires all types part of P to implement default, even if they never actually get constructed.
+// By manually implemented Default it works fine.
+impl<P> Default for ActionCallback<P> {
    fn default() -> Self {
        Self {
-            internal: None,
-            _this: PhantomData::<T>,
-            _state: PhantomData::<S>,
+            callbacks: Default::default(),
+            _parameters: Default::default(),
        }
    }
 }

-impl<T, S> FromLua for ActionCallback<T, S> {
-    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
-        let uuid = uuid::Uuid::new_v4();
-        lua.set_named_registry_value(&uuid.to_string(), value)?;
+impl<P> FromLua for ActionCallback<P> {
+    fn from_lua(value: mlua::Value, _lua: &mlua::Lua) -> mlua::Result<Self> {
+        let callbacks = match value {
+            mlua::Value::Function(f) => vec![f],
+            mlua::Value::Table(table) => table
+                .pairs::<mlua::Value, mlua::Function>()
+                .map(|pair| {
+                    let (_, f) = pair?;
+
+                    Ok::<_, mlua::Error>(f)
+                })
+                .try_collect()?,
+            _ => {
+                return Err(mlua::Error::FromLuaConversionError {
+                    from: value.type_name(),
+                    to: "ActionCallback".into(),
+                    message: Some("expected function or table of functions".into()),
+                });
+            }
+        };

        Ok(ActionCallback {
-            internal: Some(Internal {
-                uuid,
-                lua: lua.clone(),
-            }),
-            _this: PhantomData::<T>,
-            _state: PhantomData::<S>,
+            callbacks,
+            _parameters: PhantomData::<P>,
        })
    }
 }

 // TODO: Return proper error here
-impl<T, S> ActionCallback<T, S>
+impl<P> ActionCallback<P>
 where
-    T: IntoLua + Sync + Send + Clone + 'static,
-    S: Serialize,
+    P: IntoLuaMulti + Sync + Clone,
 {
-    pub async fn call(&self, this: &T, state: &S) {
-        let Some(internal) = self.internal.as_ref() else {
-            return;
-        };
-
-        let state = internal.lua.to_value(state).unwrap();
-
-        let callback: mlua::Value = internal
-            .lua
-            .named_registry_value(&internal.uuid.to_string())
-            .unwrap();
-        match callback {
-            mlua::Value::Function(f) => f.call_async::<()>((this.clone(), state)).await.unwrap(),
-            _ => todo!("Only functions are currently supported"),
-        }
+    pub async fn call(&self, parameters: P) {
+        try_join_all(
+            self.callbacks
+                .iter()
+                .map(async |f| f.call_async::<()>(parameters.clone()).await),
+        )
+        .await
+        .unwrap();
    }

-    pub fn is_set(&self) -> bool {
-        self.internal.is_some()
+    pub fn is_empty(&self) -> bool {
+        self.callbacks.is_empty()
    }
 }
--- a/automation_lib/src/config.rs
+++ b/automation_lib/src/config.rs
@@ -1,58 +1,7 @@
-use std::net::{Ipv4Addr, SocketAddr};
-use std::time::Duration;
-
-use rumqttc::{MqttOptions, Transport};
+use lua_typed::Typed;
 use serde::Deserialize;

-#[derive(Debug, Clone, Deserialize)]
-pub struct MqttConfig {
-    pub host: String,
-    pub port: u16,
-    pub client_name: String,
-    pub username: String,
-    pub password: String,
-    #[serde(default)]
-    pub tls: bool,
-}
-
-impl From<MqttConfig> for MqttOptions {
-    fn from(value: MqttConfig) -> Self {
-        let mut mqtt_options = MqttOptions::new(value.client_name, value.host, value.port);
-        mqtt_options.set_credentials(value.username, value.password);
-        mqtt_options.set_keep_alive(Duration::from_secs(5));
-
-        if value.tls {
-            mqtt_options.set_transport(Transport::tls_with_default_config());
-        }
-
-        mqtt_options
-    }
-}
-
-#[derive(Debug, Deserialize)]
-pub struct FulfillmentConfig {
-    pub openid_url: String,
-    #[serde(default = "default_fulfillment_ip")]
-    pub ip: Ipv4Addr,
-    #[serde(default = "default_fulfillment_port")]
-    pub port: u16,
-}
-
-impl From<FulfillmentConfig> for SocketAddr {
-    fn from(fulfillment: FulfillmentConfig) -> Self {
-        (fulfillment.ip, fulfillment.port).into()
-    }
-}
-
-fn default_fulfillment_ip() -> Ipv4Addr {
-    [0, 0, 0, 0].into()
-}
-
-fn default_fulfillment_port() -> u16 {
-    7878
-}
-
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Typed)]
 pub struct InfoConfig {
    pub name: String,
    pub room: Option<String>,
@@ -68,7 +17,7 @@ impl InfoConfig {
    }
 }

-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Typed)]
 pub struct MqttDeviceConfig {
    pub topic: String,
 }
--- a/automation_lib/src/device.rs
+++ b/automation_lib/src/device.rs
@@ -2,6 +2,7 @@ use std::fmt::Debug;

 use automation_cast::Cast;
 use dyn_clone::DynClone;
+use lua_typed::Typed;
 use mlua::ObjectLike;

 use crate::event::OnMqtt;
@@ -26,7 +27,7 @@ impl mlua::FromLua for Box<dyn Device> {
    fn from_lua(value: mlua::Value, _lua: &mlua::Lua) -> mlua::Result<Self> {
        match value {
            mlua::Value::UserData(ud) => {
-                let ud = if ud.is::<Box<dyn Device>>() {
+                let ud = if ud.is::<Self>() {
                    ud
                } else {
                    ud.call_method::<_>("__box", ())?
@@ -35,10 +36,19 @@ impl mlua::FromLua for Box<dyn Device> {
                let b = ud.borrow::<Self>()?.clone();
                Ok(b)
            }
-            _ => Err(mlua::Error::RuntimeError("Expected user data".into())),
+            _ => Err(mlua::Error::runtime(format!(
+                "Expected user data, instead found: {}",
+                value.type_name()
+            ))),
        }
    }
 }
 impl mlua::UserData for Box<dyn Device> {}

+impl Typed for Box<dyn Device> {
+    fn type_name() -> String {
+        "DeviceInterface".into()
+    }
+}
+
 dyn_clone::clone_trait_object!(Device);
--- a/automation_lib/src/device_manager.rs
+++ b/automation_lib/src/device_manager.rs
@@ -1,11 +1,8 @@
 use std::collections::HashMap;
-use std::pin::Pin;
 use std::sync::Arc;

-use futures::Future;
 use futures::future::join_all;
 use tokio::sync::{RwLock, RwLockReadGuard};
-use tokio_cron_scheduler::{Job, JobScheduler};
 use tracing::{debug, instrument, trace};

 use crate::device::Device;
@@ -17,7 +14,6 @@ pub type DeviceMap = HashMap<String, Box<dyn Device>>;
 pub struct DeviceManager {
    devices: Arc<RwLock<DeviceMap>>,
    event_channel: EventChannel,
-    scheduler: JobScheduler,
 }

 impl DeviceManager {
@@ -27,7 +23,6 @@ impl DeviceManager {
        let device_manager = Self {
            devices: Arc::new(RwLock::new(HashMap::new())),
            event_channel,
-            scheduler: JobScheduler::new().await.unwrap(),
        };

        tokio::spawn({
@@ -43,8 +38,6 @@ impl DeviceManager {
            }
        });

-        device_manager.scheduler.start().await.unwrap();
-
        device_manager
    }

@@ -94,51 +87,3 @@ impl DeviceManager {
        }
    }
 }
-
-impl mlua::UserData for DeviceManager {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
-        methods.add_async_method("add", async |_lua, this, device: Box<dyn Device>| {
-            this.add(device).await;
-
-            Ok(())
-        });
-
-        methods.add_async_method(
-            "schedule",
-            async |lua, this, (schedule, f): (String, mlua::Function)| {
-                debug!("schedule = {schedule}");
-                // This creates a function, that returns the actual job we want to run
-                let create_job = {
-                    let lua = lua.clone();
-
-                    move |uuid: uuid::Uuid,
-                          _: tokio_cron_scheduler::JobScheduler|
-                          -> Pin<Box<dyn Future<Output = ()> + Send>> {
-                        let lua = lua.clone();
-
-                        // Create the actual function we want to run on a schedule
-                        let future = async move {
-                            let f: mlua::Function =
-                                lua.named_registry_value(uuid.to_string().as_str()).unwrap();
-                            f.call_async::<()>(()).await.unwrap();
-                        };
-
-                        Box::pin(future)
-                    }
-                };
-
-                let job = Job::new_async(schedule.as_str(), create_job).unwrap();
-
-                let uuid = this.scheduler.add(job).await.unwrap();
-
-                // Store the function in the registry
-                lua.set_named_registry_value(uuid.to_string().as_str(), f)
-                    .unwrap();
-
-                Ok(())
-            },
-        );
-
-        methods.add_method("event_channel", |_lua, this, ()| Ok(this.event_channel()))
-    }
-}
--- a/automation_lib/src/helpers/mod.rs
+++ b/automation_lib/src/helpers/mod.rs
@@ -1,11 +1 @@
 pub mod serialization;
-mod timeout;
-
-pub use timeout::Timeout;
-
-pub fn register_with_lua(lua: &mlua::Lua) -> mlua::Result<()> {
-    lua.globals()
-        .set("Timeout", lua.create_proxy::<Timeout>()?)?;
-
-    Ok(())
-}
--- a/automation_lib/src/lib.rs
+++ b/automation_lib/src/lib.rs
@@ -1,4 +1,7 @@
-#![allow(incomplete_features)]
+#![feature(iterator_try_collect)]
+#![feature(with_negative_coherence)]
+
+use tracing::debug;

 pub mod action_callback;
 pub mod config;
@@ -10,4 +13,50 @@ pub mod helpers;
 pub mod lua;
 pub mod messages;
 pub mod mqtt;
-pub mod schedule;
+
+type RegisterFn = fn(lua: &mlua::Lua) -> mlua::Result<mlua::Table>;
+type DefinitionsFn = fn() -> String;
+
+pub struct Module {
+    name: &'static str,
+    register_fn: RegisterFn,
+    definitions_fn: Option<DefinitionsFn>,
+}
+
+impl Module {
+    pub const fn new(
+        name: &'static str,
+        register_fn: RegisterFn,
+        definitions_fn: Option<DefinitionsFn>,
+    ) -> Self {
+        Self {
+            name,
+            register_fn,
+            definitions_fn,
+        }
+    }
+
+    pub const fn get_name(&self) -> &'static str {
+        self.name
+    }
+
+    pub fn register(&self, lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
+        (self.register_fn)(lua)
+    }
+
+    pub fn definitions(&self) -> Option<String> {
+        self.definitions_fn.map(|f| f())
+    }
+}
+
+pub fn load_modules(lua: &mlua::Lua) -> mlua::Result<()> {
+    for module in inventory::iter::<Module> {
+        debug!(name = module.get_name(), "Loading module");
+        let table = module.register(lua)?;
+        lua.register_module(module.get_name(), table)?;
+    }
+
+    Ok(())
+}
+
+inventory::collect!(Module);
--- a/automation_lib/src/lua/mod.rs
+++ b/automation_lib/src/lua/mod.rs
@@ -1 +1,3 @@
 pub mod traits;
+
+mod utils;
--- a/automation_lib/src/lua/traits.rs
+++ b/automation_lib/src/lua/traits.rs
@@ -2,11 +2,40 @@ use std::ops::Deref;

 // TODO: Enable and disable functions based on query_only and command_only

-pub trait OnOff {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + google_home::traits::OnOff + 'static,
-    {
+pub trait PartialUserData<T> {
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M);
+
+    fn interface_name() -> Option<&'static str> {
+        None
+    }
+
+    fn definitions() -> Option<String> {
+        None
+    }
+}
+
+pub struct Device;
+
+impl<T> PartialUserData<T> for Device
+where
+    T: crate::device::Device + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
+        methods.add_async_method("get_id", async |_lua, this, _: ()| Ok(this.get_id()));
+    }
+
+    fn interface_name() -> Option<&'static str> {
+        Some("DeviceInterface")
+    }
+}
+
+pub struct OnOff;
+
+impl<T> PartialUserData<T> for OnOff
+where
+    T: google_home::traits::OnOff + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
        methods.add_async_method("set_on", async |_lua, this, on: bool| {
            this.deref().set_on(on).await.unwrap();

@@ -17,14 +46,19 @@ pub trait OnOff {
            Ok(this.deref().on().await.unwrap())
        });
    }
-}
-impl<T> OnOff for T where T: google_home::traits::OnOff {}

-pub trait Brightness {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + google_home::traits::Brightness + 'static,
-    {
+    fn interface_name() -> Option<&'static str> {
+        Some("OnOffInterface")
+    }
+}
+
+pub struct Brightness;
+
+impl<T> PartialUserData<T> for Brightness
+where
+    T: google_home::traits::Brightness + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
        methods.add_async_method("set_brightness", async |_lua, this, brightness: u8| {
            this.set_brightness(brightness).await.unwrap();

@@ -35,14 +69,19 @@ pub trait Brightness {
            Ok(this.brightness().await.unwrap())
        });
    }
-}
-impl<T> Brightness for T where T: google_home::traits::Brightness {}

-pub trait ColorSetting {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + google_home::traits::ColorSetting + 'static,
-    {
+    fn interface_name() -> Option<&'static str> {
+        Some("BrightnessInterface")
+    }
+}
+
+pub struct ColorSetting;
+
+impl<T> PartialUserData<T> for ColorSetting
+where
+    T: google_home::traits::ColorSetting + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
        methods.add_async_method(
            "set_color_temperature",
            async |_lua, this, temperature: u32| {
@@ -58,14 +97,19 @@ pub trait ColorSetting {
            Ok(this.color().await.temperature)
        });
    }
-}
-impl<T> ColorSetting for T where T: google_home::traits::ColorSetting {}

-pub trait OpenClose {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + google_home::traits::OpenClose + 'static,
-    {
+    fn interface_name() -> Option<&'static str> {
+        Some("ColorSettingInterface")
+    }
+}
+
+pub struct OpenClose;
+
+impl<T> PartialUserData<T> for OpenClose
+where
+    T: google_home::traits::OpenClose + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
        methods.add_async_method("set_open_percent", async |_lua, this, open_percent: u8| {
            this.set_open_percent(open_percent).await.unwrap();

@@ -76,11 +120,8 @@ pub trait OpenClose {
            Ok(this.open_percent().await.unwrap())
        });
    }
-}
-impl<T> OpenClose for T where T: google_home::traits::OpenClose {}

-pub trait AddAdditionalMethods {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M)
-    where
-        Self: Sized + 'static;
+    fn interface_name() -> Option<&'static str> {
+        Some("OpenCloseInterface")
+    }
 }
--- a/automation_lib/src/lua/utils/mod.rs
+++ b/automation_lib/src/lua/utils/mod.rs
@@ -0,0 +1,48 @@
+mod timeout;
+
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use lua_typed::Typed;
+pub use timeout::Timeout;
+
+use crate::Module;
+
+fn create_module(lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
+    let utils = lua.create_table()?;
+
+    utils.set(Timeout::type_name(), lua.create_proxy::<Timeout>()?)?;
+
+    let get_hostname = lua.create_function(|_lua, ()| {
+        hostname::get()
+            .map(|name| name.to_str().unwrap_or("unknown").to_owned())
+            .map_err(mlua::ExternalError::into_lua_err)
+    })?;
+    utils.set("get_hostname", get_hostname)?;
+    let get_epoch = lua.create_function(|_lua, ()| {
+        Ok(SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("Time is after UNIX EPOCH")
+            .as_millis())
+    })?;
+    utils.set("get_epoch", get_epoch)?;
+
+    Ok(utils)
+}
+
+fn generate_definitions() -> String {
+    let mut output = String::new();
+
+    output += "---@meta\n\nlocal utils\n\n";
+
+    output += &Timeout::generate_full().expect("Timeout should have generate_full");
+    output += "\n";
+
+    output += "---@return string\nfunction utils.get_hostname() end\n\n";
+    output += "---@return integer\nfunction utils.get_epoch() end\n\n";
+
+    output += "return utils";
+
+    output
+}
+
+inventory::submit! {Module::new("automation:utils", create_module, Some(generate_definitions))}
--- a/automation_lib/src/lua/utils/timeout.rs
+++ b/automation_lib/src/lua/utils/timeout.rs
@@ -1,6 +1,7 @@
 use std::sync::Arc;
 use std::time::Duration;

+use lua_typed::Typed;
 use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
 use tracing::debug;
@@ -29,7 +30,7 @@ impl mlua::UserData for Timeout {

        methods.add_async_method(
            "start",
-            async |_lua, this, (timeout, callback): (f32, ActionCallback<mlua::Value, bool>)| {
+            async |_lua, this, (timeout, callback): (f32, ActionCallback<()>)| {
                if let Some(handle) = this.state.write().await.handle.take() {
                    handle.abort();
                }
@@ -42,7 +43,7 @@ impl mlua::UserData for Timeout {
                    async move {
                        tokio::time::sleep(timeout).await;

-                        callback.call(&mlua::Nil, &false).await;
+                        callback.call(()).await;
                    }
                }));

@@ -74,3 +75,44 @@ impl mlua::UserData for Timeout {
        });
    }
 }
+
+impl Typed for Timeout {
+    fn type_name() -> String {
+        "Timeout".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        let type_name = Self::type_name();
+        Some(format!("---@class {type_name}\nlocal {type_name}\n"))
+    }
+
+    fn generate_members() -> Option<String> {
+        let mut output = String::new();
+
+        let type_name = Self::type_name();
+
+        output += &format!(
+            "---@async\n---@param timeout number\n---@param callback {}\nfunction {type_name}:start(timeout, callback) end\n",
+            ActionCallback::<()>::type_name()
+        );
+
+        output += &format!("---@async\nfunction {type_name}:cancel() end\n",);
+
+        output +=
+            &format!("---@async\n---@return boolean\nfunction {type_name}:is_waiting() end\n",);
+
+        Some(output)
+    }
+
+    fn generate_footer() -> Option<String> {
+        let mut output = String::new();
+
+        let type_name = Self::type_name();
+
+        output += &format!("utils.{type_name} = {{}}\n");
+        output += &format!("---@return {type_name}\n");
+        output += &format!("function utils.{type_name}.new() end\n");
+
+        Some(output)
+    }
+}
--- a/automation_lib/src/mqtt.rs
+++ b/automation_lib/src/mqtt.rs
@@ -1,14 +1,67 @@
 use std::ops::{Deref, DerefMut};
+use std::time::Duration;

+use automation_macro::LuaDeviceConfig;
+use lua_typed::Typed;
 use mlua::FromLua;
-use rumqttc::{AsyncClient, Event, EventLoop, Incoming};
+use rumqttc::{AsyncClient, Event, Incoming, MqttOptions, Transport};
+use serde::Deserialize;
 use tracing::{debug, warn};

 use crate::event::{self, EventChannel};

+#[derive(Debug, Clone, LuaDeviceConfig, Deserialize, Typed)]
+pub struct MqttConfig {
+    pub host: String,
+    pub port: u16,
+    pub client_name: String,
+    pub username: String,
+    pub password: String,
+    #[serde(default)]
+    #[typed(default)]
+    pub tls: bool,
+}
+
+impl From<MqttConfig> for MqttOptions {
+    fn from(value: MqttConfig) -> Self {
+        let mut mqtt_options = MqttOptions::new(value.client_name, value.host, value.port);
+        mqtt_options.set_credentials(value.username, value.password);
+        mqtt_options.set_keep_alive(Duration::from_secs(5));
+
+        if value.tls {
+            mqtt_options.set_transport(Transport::tls_with_default_config());
+        }
+
+        mqtt_options
+    }
+}
+
 #[derive(Debug, Clone, FromLua)]
 pub struct WrappedAsyncClient(pub AsyncClient);

+impl Typed for WrappedAsyncClient {
+    fn type_name() -> String {
+        "AsyncClient".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        let type_name = Self::type_name();
+        Some(format!("---@class {type_name}\nlocal {type_name}\n"))
+    }
+
+    fn generate_members() -> Option<String> {
+        let mut output = String::new();
+
+        let type_name = Self::type_name();
+
+        output += &format!(
+            "---@async\n---@param topic string\n---@param message table?\nfunction {type_name}:send_message(topic, message) end\n"
+        );
+
+        Some(output)
+    }
+}
+
 impl Deref for WrappedAsyncClient {
    type Target = AsyncClient;

@@ -28,7 +81,13 @@ impl mlua::UserData for WrappedAsyncClient {
        methods.add_async_method(
            "send_message",
            async |_lua, this, (topic, message): (String, mlua::Value)| {
-                let message = serde_json::to_string(&message).unwrap();
+                // serde_json converts nil => "null", but we actually want nil to send an empty
+                // message
+                let message = if message.is_nil() {
+                    "".into()
+                } else {
+                    serde_json::to_string(&message).unwrap()
+                };

                debug!("message = {message}");

@@ -43,8 +102,9 @@ impl mlua::UserData for WrappedAsyncClient {
    }
 }

-pub fn start(mut eventloop: EventLoop, event_channel: &EventChannel) {
+pub fn start(config: MqttConfig, event_channel: &EventChannel) -> WrappedAsyncClient {
    let tx = event_channel.get_tx();
+    let (client, mut eventloop) = AsyncClient::new(config.into(), 100);

    tokio::spawn(async move {
        debug!("Listening for MQTT events");
@@ -63,4 +123,6 @@ pub fn start(mut eventloop: EventLoop, event_channel: &EventChannel) {
            }
        }
    });
+
+    WrappedAsyncClient(client)
 }
--- a/automation_lib/src/schedule.rs
+++ b/automation_lib/src/schedule.rs
@@ -1,17 +0,0 @@
-use indexmap::IndexMap;
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize, Hash, PartialEq, Eq, Clone, Copy)]
-#[serde(rename_all = "snake_case")]
-pub enum Action {
-    On,
-    Off,
-}
-
-pub type Schedule = IndexMap<String, IndexMap<Action, Vec<String>>>;
-
-// #[derive(Debug, Deserialize)]
-// pub struct Schedule {
-//     pub when: String,
-//     pub actions: IndexMap<Action, Vec<String>>,
-// }
--- a/automation_macro/Cargo.toml
+++ b/automation_macro/Cargo.toml
@@ -11,3 +11,6 @@ itertools = { workspace = true }
 proc-macro2 = { workspace = true }
 quote = { workspace = true }
 syn = { workspace = true }
+
+[dev-dependencies]
+mlua = { workspace = true }
--- a/automation_macro/src/device.rs
+++ b/automation_macro/src/device.rs
@@ -0,0 +1,265 @@
+use std::collections::HashMap;
+
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::parse::{Parse, ParseStream};
+use syn::punctuated::Punctuated;
+use syn::spanned::Spanned;
+use syn::{Attribute, DeriveInput, Token, parenthesized};
+
+enum Attr {
+    Trait(TraitAttr),
+    ExtraUserData(ExtraUserDataAttr),
+}
+
+impl Attr {
+    fn parse(attr: &Attribute) -> syn::Result<Self> {
+        let mut parsed = None;
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("traits") {
+                let input;
+                _ = parenthesized!(input in meta.input);
+                parsed = Some(Attr::Trait(input.parse()?));
+            } else if meta.path.is_ident("extra_user_data") {
+                let value = meta.value()?;
+                parsed = Some(Attr::ExtraUserData(value.parse()?));
+            } else {
+                return Err(syn::Error::new(meta.path.span(), "Unknown attribute"));
+            }
+
+            Ok(())
+        })?;
+
+        Ok(parsed.expect("Parsed should be set"))
+    }
+}
+
+struct TraitAttr {
+    traits: Traits,
+    aliases: Aliases,
+}
+
+impl Parse for TraitAttr {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            traits: input.parse()?,
+            aliases: input.parse()?,
+        })
+    }
+}
+
+#[derive(Default)]
+struct Traits(Vec<syn::Ident>);
+
+impl Traits {
+    fn extend(&mut self, other: &Traits) {
+        self.0.extend_from_slice(&other.0);
+    }
+}
+
+impl Parse for Traits {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        input
+            .call(Punctuated::<_, Token![,]>::parse_separated_nonempty)
+            .map(|traits| traits.into_iter().collect())
+            .map(Self)
+    }
+}
+
+#[derive(Default)]
+struct Aliases(Vec<syn::Ident>);
+
+impl Aliases {
+    fn has_aliases(&self) -> bool {
+        !self.0.is_empty()
+    }
+}
+
+impl Parse for Aliases {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if !input.peek(Token![for]) {
+            if input.is_empty() {
+                return Ok(Default::default());
+            } else {
+                return Err(input.error("Expected ')' or 'for'"));
+            }
+        }
+
+        _ = input.parse::<syn::Token![for]>()?;
+
+        input
+            .call(Punctuated::<_, Token![,]>::parse_separated_nonempty)
+            .map(|aliases| aliases.into_iter().collect())
+            .map(Self)
+    }
+}
+
+#[derive(Clone)]
+struct ExtraUserDataAttr(syn::Ident);
+
+impl Parse for ExtraUserDataAttr {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self(input.parse()?))
+    }
+}
+
+struct Implementation {
+    name: syn::Ident,
+    traits: Traits,
+    extra_user_data: Vec<ExtraUserDataAttr>,
+}
+
+impl quote::ToTokens for Implementation {
+    fn to_tokens(&self, tokens: &mut TokenStream2) {
+        let Self {
+            name,
+            traits,
+            extra_user_data,
+        } = &self;
+        let Traits(traits) = traits;
+        let extra_user_data: Vec<_> = extra_user_data.iter().map(|tr| tr.0.clone()).collect();
+
+        tokens.extend(quote! {
+            impl mlua::UserData for #name {
+                fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
+                    methods.add_async_function("new", async |_lua, config| {
+                        let device: Self = LuaDeviceCreate::create(config)
+                            .await
+                            .map_err(mlua::ExternalError::into_lua_err)?;
+
+                        Ok(device)
+                    });
+
+                    methods.add_method("__box", |_lua, this, _: ()| {
+                        let b: Box<dyn Device> = Box::new(this.clone());
+                        Ok(b)
+                    });
+
+                    <::automation_lib::lua::traits::Device as ::automation_lib::lua::traits::PartialUserData<#name>>::add_methods(methods);
+
+                    #(
+                        <::automation_lib::lua::traits::#traits as ::automation_lib::lua::traits::PartialUserData<#name>>::add_methods(methods);
+                    )*
+
+                    #(
+                        <#extra_user_data as ::automation_lib::lua::traits::PartialUserData<#name>>::add_methods(methods);
+                    )*
+                }
+            }
+
+            impl ::lua_typed::Typed for #name {
+                fn type_name() -> String {
+                    stringify!(#name).into()
+                }
+
+                fn generate_header() -> std::option::Option<::std::string::String> {
+                    let type_name = <Self as ::lua_typed::Typed>::type_name();
+                    let mut output = String::new();
+
+                    let interfaces: String = [
+                        <::automation_lib::lua::traits::Device as ::automation_lib::lua::traits::PartialUserData<#name>>::interface_name(),
+                        #(
+                            <::automation_lib::lua::traits::#traits as ::automation_lib::lua::traits::PartialUserData<#name>>::interface_name(),
+                        )*
+                    ].into_iter().flatten().intersperse(", ").collect();
+
+                    let interfaces = if interfaces.is_empty() {
+                        "".into()
+                    } else {
+                        format!(": {interfaces}")
+                    };
+
+                    Some(format!("---@class {type_name}{interfaces}\nlocal {type_name}\n"))
+                }
+
+                fn generate_members() -> Option<String> {
+                    let mut output = String::new();
+
+                    let type_name = <Self as ::lua_typed::Typed>::type_name();
+                    output += &format!("devices.{type_name} = {{}}\n");
+                    let config_name = <<Self as ::automation_lib::device::LuaDeviceCreate>::Config as ::lua_typed::Typed>::type_name();
+                    output += &format!("---@param config {config_name}\n");
+                    output += &format!("---@return {type_name}\n");
+                    output += &format!("function devices.{type_name}.new(config) end\n");
+
+                    output += &<::automation_lib::lua::traits::Device as ::automation_lib::lua::traits::PartialUserData<#name>>::definitions().unwrap_or("".into());
+
+                    #(
+                        output += &<::automation_lib::lua::traits::#traits as ::automation_lib::lua::traits::PartialUserData<#name>>::definitions().unwrap_or("".into());
+                    )*
+                    #(
+                        output += &<#extra_user_data as ::automation_lib::lua::traits::PartialUserData<#name>>::definitions().unwrap_or("".into());
+                    )*
+
+
+                    Some(output)
+                }
+            }
+        });
+    }
+}
+
+struct Implementations(Vec<Implementation>);
+
+impl Implementations {
+    fn from_attr(attributes: Vec<Attr>, name: syn::Ident) -> Self {
+        let mut add_methods = Vec::new();
+        let mut all = Traits::default();
+        let mut implementations: HashMap<_, Traits> = HashMap::new();
+        for attribute in attributes {
+            match attribute {
+                Attr::Trait(attribute) => {
+                    if attribute.aliases.has_aliases() {
+                        for alias in &attribute.aliases.0 {
+                            implementations
+                                .entry(Some(alias.clone()))
+                                .or_default()
+                                .extend(&attribute.traits);
+                        }
+                    } else {
+                        all.extend(&attribute.traits);
+                    }
+                }
+                Attr::ExtraUserData(attribute) => add_methods.push(attribute),
+            }
+        }
+
+        if implementations.is_empty() {
+            implementations.entry(None).or_default().extend(&all);
+        } else {
+            for traits in implementations.values_mut() {
+                traits.extend(&all);
+            }
+        }
+
+        Self(
+            implementations
+                .into_iter()
+                .map(|(alias, traits)| Implementation {
+                    name: alias.unwrap_or(name.clone()),
+                    traits,
+                    extra_user_data: add_methods.clone(),
+                })
+                .collect(),
+        )
+    }
+}
+
+pub fn device(input: DeriveInput) -> TokenStream2 {
+    let Implementations(imp) = match input
+        .attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("device"))
+        .map(Attr::parse)
+        .try_collect::<Vec<_>>()
+    {
+        Ok(attr) => Implementations::from_attr(attr, input.ident),
+        Err(err) => return err.into_compile_error(),
+    };
+
+    quote! {
+        #(
+            #imp
+        )*
+    }
+}
--- a/automation_macro/src/impl_device.rs
+++ b/automation_macro/src/impl_device.rs
@@ -1,88 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::{ToTokens, quote};
-use syn::parse::Parse;
-use syn::punctuated::Punctuated;
-use syn::{AngleBracketedGenericArguments, Attribute, DeriveInput, Ident, Path, Token};
-
-#[derive(Debug, Default)]
-struct Impl {
-    generics: Option<AngleBracketedGenericArguments>,
-    traits: Vec<Path>,
-}
-
-impl Parse for Impl {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let generics = if input.peek(Token![<]) {
-            let generics = input.parse()?;
-            input.parse::<Token![:]>()?;
-
-            Some(generics)
-        } else {
-            None
-        };
-
-        let traits: Punctuated<_, _> = input.parse_terminated(Path::parse, Token![,])?;
-        let traits = traits.into_iter().collect();
-
-        Ok(Impl { generics, traits })
-    }
-}
-
-impl Impl {
-    fn generate(&self, name: &Ident) -> TokenStream {
-        let generics = &self.generics;
-
-        // If an identifier is specified, assume it is placed in ::automation_lib::lua::traits,
-        // otherwise use the provided path
-        let traits = self.traits.iter().map(|t| {
-            if let Some(ident) = t.get_ident() {
-                quote! {::automation_lib::lua::traits::#ident }
-            } else {
-                t.to_token_stream()
-            }
-        });
-
-        quote! {
-            impl mlua::UserData for #name #generics {
-                fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
-                    methods.add_async_function("new", async |_lua, config| {
-                        let device: Self = LuaDeviceCreate::create(config)
-                            .await
-                            .map_err(mlua::ExternalError::into_lua_err)?;
-
-                        Ok(device)
-                    });
-
-                    methods.add_method("__box", |_lua, this, _: ()| {
-                        let b: Box<dyn Device> = Box::new(this.clone());
-                        Ok(b)
-                    });
-
-                    methods.add_async_method("get_id", async |_lua, this, _: ()| { Ok(this.get_id()) });
-
-                    #(
-                        #traits::add_methods(methods);
-                    )*
-                }
-            }
-        }
-    }
-}
-
-pub fn impl_device_macro(ast: &DeriveInput) -> TokenStream {
-    let name = &ast.ident;
-
-    let impls: TokenStream = ast
-        .attrs
-        .iter()
-        .filter(|attr| attr.path().is_ident("traits"))
-        .flat_map(Attribute::parse_args::<Impl>)
-        .map(|im| im.generate(name))
-        .collect();
-
-    if impls.is_empty() {
-        Impl::default().generate(name)
-    } else {
-        impls
-    }
-}
--- a/automation_macro/src/lib.rs
+++ b/automation_macro/src/lib.rs
@@ -1,12 +1,12 @@
 #![feature(iter_intersperse)]
-mod impl_device;
+#![feature(iterator_try_collect)]
+mod device;
 mod lua_device_config;

 use lua_device_config::impl_lua_device_config_macro;
+use quote::quote;
 use syn::{DeriveInput, parse_macro_input};

-use crate::impl_device::impl_device_macro;
-
 #[proc_macro_derive(LuaDeviceConfig, attributes(device_config))]
 pub fn lua_device_config_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
@@ -14,9 +14,60 @@ pub fn lua_device_config_derive(input: proc_macro::TokenStream) -> proc_macro::T
    impl_lua_device_config_macro(&ast).into()
 }

-#[proc_macro_derive(LuaDevice, attributes(traits))]
-pub fn impl_device(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+#[proc_macro_derive(LuaSerialize, attributes(traits))]
+pub fn lua_serialize(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);

-    impl_device_macro(&ast).into()
+    let name = &ast.ident;
+
+    quote! {
+        impl ::mlua::IntoLua for #name {
+            fn into_lua(self, lua: &::mlua::Lua) -> ::mlua::Result<::mlua::Value> {
+                ::mlua::LuaSerdeExt::to_value(lua, &self)
+            }
+        }
+    }
+    .into()
+}
+
+/// Derive macro generating an impl for the trait `::mlua::UserData`
+///
+/// # Device traits
+/// The `device(traits)` attribute can be used to tell the macro what traits are implemented so that
+/// the appropriate methods can automatically be registered.
+/// If the struct does not have any type parameters the syntax is very simple:
+/// ```rust
+/// #[device(traits(TraitA, TraitB))]
+/// ```
+///
+/// If the type does have type parameters you will have to manually specify all variations that
+/// have the trait available:
+/// ```rust
+/// #[device(traits(TraitA, TraitB for <StateA>, <StateB>))]
+/// ```
+/// If multiple of these attributes are specified they will all combined appropriately.
+///
+///
+/// ## NOTE
+/// If your type _has_ type parameters any instance of the traits attribute that does not specify
+/// any type parameters will have the traits applied to _all_ other type parameter variations
+/// listed in the other trait attributes. This behavior only applies if there is at least one
+/// instance with type parameters specified.
+///
+/// # Additional methods
+/// Additional methods can be added by using the `device(add_methods)` attribute. This attribute
+/// takes the path to a function with the following signature that can register the additional methods:
+///
+/// ```rust
+/// # struct D;
+/// fn top_secret<M: mlua::UserDataMethods<D>>(methods: &mut M) {}
+/// ```
+/// It can then be registered with:
+/// ```rust
+/// #[device(add_methods = top_secret)]
+/// ```
+#[proc_macro_derive(Device, attributes(device))]
+pub fn device(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    device::device(ast).into()
 }
--- a/config.lua
+++ b/config.lua
@@ -1,681 +0,0 @@
-local device_manager = require("device_manager")
-local utils = require("utils")
-local secrets = require("secrets")
-local debug = require("variables").debug or false
-
-print(_VERSION)
-
-local host = utils.get_hostname()
-print("Running @" .. host)
-
-local function mqtt_z2m(topic)
-	return "zigbee2mqtt/" .. topic
-end
-
-local function mqtt_automation(topic)
-	return "automation/" .. topic
-end
-
-local fulfillment = {
-	openid_url = "https://login.huizinga.dev/api/oidc",
-}
-
-local mqtt_client = require("mqtt").new({
-	host = ((host == "zeus" or host == "hephaestus") and "olympus.lan.huizinga.dev") or "mosquitto",
-	port = 8883,
-	client_name = "automation-" .. host,
-	username = "mqtt",
-	password = secrets.mqtt_password,
-	tls = host == "zeus" or host == "hephaestus",
-})
-
-local ntfy = Ntfy.new({
-	topic = secrets.ntfy_topic,
-})
-device_manager:add(ntfy)
-
-local low_battery = {}
-local function check_battery(device, battery)
-	local id = device:get_id()
-	if battery < 15 then
-		print("Device '" .. id .. "' has low battery: " .. tostring(battery))
-		low_battery[id] = battery
-	else
-		low_battery[id] = nil
-	end
-end
-device_manager:schedule("0 0 21 */1 * *", function()
-	-- Don't send notifications if there are now devices with low battery
-	if next(low_battery) == nil then
-		print("No devices with low battery")
-		return
-	end
-
-	local lines = {}
-	for name, battery in pairs(low_battery) do
-		table.insert(lines, name .. ": " .. tostring(battery) .. "%")
-	end
-	local message = table.concat(lines, "\n")
-
-	ntfy:send_notification({
-		title = "Low battery",
-		message = message,
-		tags = { "battery" },
-		priority = "default",
-	})
-end)
-
-local on_presence = {
-	add = function(self, f)
-		self[#self + 1] = f
-	end,
-}
-
-local presence_system = Presence.new({
-	topic = mqtt_automation("presence/+/#"),
-	client = mqtt_client,
-	callback = function(_, presence)
-		for _, f in ipairs(on_presence) do
-			if type(f) == "function" then
-				f(presence)
-			end
-		end
-	end,
-})
-device_manager:add(presence_system)
-on_presence:add(function(presence)
-	ntfy:send_notification({
-		title = "Presence",
-		message = presence and "Home" or "Away",
-		tags = { "house" },
-		priority = "low",
-		actions = {
-			{
-				action = "broadcast",
-				extras = {
-					cmd = "presence",
-					state = presence and "0" or "1",
-				},
-				label = presence and "Set away" or "Set home",
-				clear = true,
-			},
-		},
-	})
-end)
-on_presence:add(function(presence)
-	mqtt_client:send_message(mqtt_automation("debug") .. "/presence", {
-		state = presence,
-		updated = utils.get_epoch(),
-	})
-end)
-
-local function turn_off_when_away(device)
-	on_presence:add(function(presence)
-		if not presence then
-			device:set_on(false)
-		end
-	end)
-end
-
-local on_light = {
-	add = function(self, f)
-		self[#self + 1] = f
-	end,
-}
-device_manager:add(LightSensor.new({
-	identifier = "living_light_sensor",
-	topic = mqtt_z2m("living/light"),
-	client = mqtt_client,
-	min = 22000,
-	max = 23500,
-	callback = function(_, light)
-		for _, f in ipairs(on_light) do
-			if type(f) == "function" then
-				f(light)
-			end
-		end
-	end,
-}))
-on_light:add(function(light)
-	mqtt_client:send_message(mqtt_automation("debug") .. "/darkness", {
-		state = not light,
-		updated = utils.get_epoch(),
-	})
-end)
-
-local hue_ip = "10.0.0.102"
-local hue_token = secrets.hue_token
-
-local hue_bridge = HueBridge.new({
-	identifier = "hue_bridge",
-	ip = hue_ip,
-	login = hue_token,
-	flags = {
-		presence = 41,
-		darkness = 43,
-	},
-})
-device_manager:add(hue_bridge)
-on_light:add(function(light)
-	hue_bridge:set_flag("darkness", not light)
-end)
-on_presence:add(function(presence)
-	hue_bridge:set_flag("presence", presence)
-end)
-
-local kitchen_lights = HueGroup.new({
-	identifier = "kitchen_lights",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 7,
-	scene_id = "7MJLG27RzeRAEVJ",
-})
-device_manager:add(kitchen_lights)
-local living_lights = HueGroup.new({
-	identifier = "living_lights",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 1,
-	scene_id = "SNZw7jUhQ3cXSjkj",
-})
-device_manager:add(living_lights)
-local living_lights_relax = HueGroup.new({
-	identifier = "living_lights",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 1,
-	scene_id = "eRJ3fvGHCcb6yNw",
-})
-device_manager:add(living_lights_relax)
-
-device_manager:add(HueSwitch.new({
-	name = "Switch",
-	room = "Living",
-	client = mqtt_client,
-	topic = mqtt_z2m("living/switch"),
-	left_callback = function()
-		kitchen_lights:set_on(not kitchen_lights:on())
-	end,
-	right_callback = function()
-		living_lights:set_on(not living_lights:on())
-	end,
-	right_hold_callback = function()
-		living_lights_relax:set_on(true)
-	end,
-	battery_callback = check_battery,
-}))
-
-device_manager:add(WakeOnLAN.new({
-	name = "Zeus",
-	room = "Living Room",
-	topic = mqtt_automation("appliance/living_room/zeus"),
-	client = mqtt_client,
-	mac_address = "30:9c:23:60:9c:13",
-	broadcast_ip = "10.0.3.255",
-}))
-
-local living_mixer = OutletOnOff.new({
-	name = "Mixer",
-	room = "Living Room",
-	topic = mqtt_z2m("living/mixer"),
-	client = mqtt_client,
-})
-turn_off_when_away(living_mixer)
-device_manager:add(living_mixer)
-local living_speakers = OutletOnOff.new({
-	name = "Speakers",
-	room = "Living Room",
-	topic = mqtt_z2m("living/speakers"),
-	client = mqtt_client,
-})
-turn_off_when_away(living_speakers)
-device_manager:add(living_speakers)
-
-device_manager:add(IkeaRemote.new({
-	name = "Remote",
-	room = "Living Room",
-	client = mqtt_client,
-	topic = mqtt_z2m("living/remote"),
-	single_button = true,
-	callback = function(_, on)
-		if on then
-			if living_mixer:on() then
-				living_mixer:set_on(false)
-				living_speakers:set_on(false)
-			else
-				living_mixer:set_on(true)
-				living_speakers:set_on(true)
-			end
-		else
-			if not living_mixer:on() then
-				living_mixer:set_on(true)
-			else
-				living_speakers:set_on(not living_speakers:on())
-			end
-		end
-	end,
-	battery_callback = check_battery,
-}))
-
-local function kettle_timeout()
-	local timeout = Timeout.new()
-
-	return function(self, state)
-		if state.state and state.power < 100 then
-			timeout:start(3, function()
-				self:set_on(false)
-			end)
-		else
-			timeout:cancel()
-		end
-	end
-end
-
-local kettle = OutletPower.new({
-	outlet_type = "Kettle",
-	name = "Kettle",
-	room = "Kitchen",
-	topic = mqtt_z2m("kitchen/kettle"),
-	client = mqtt_client,
-	callback = kettle_timeout(),
-})
-turn_off_when_away(kettle)
-device_manager:add(kettle)
-
-local function set_kettle(_, on)
-	kettle:set_on(on)
-end
-
-device_manager:add(IkeaRemote.new({
-	name = "Remote",
-	room = "Bedroom",
-	client = mqtt_client,
-	topic = mqtt_z2m("bedroom/remote"),
-	single_button = true,
-	callback = set_kettle,
-	battery_callback = check_battery,
-}))
-
-device_manager:add(IkeaRemote.new({
-	name = "Remote",
-	room = "Kitchen",
-	client = mqtt_client,
-	topic = mqtt_z2m("kitchen/remote"),
-	single_button = true,
-	callback = set_kettle,
-	battery_callback = check_battery,
-}))
-
-local function off_timeout(duration)
-	local timeout = Timeout.new()
-
-	return function(self, state)
-		if state.state then
-			timeout:start(duration, function()
-				self:set_on(false)
-			end)
-		else
-			timeout:cancel()
-		end
-	end
-end
-
-local bathroom_light = LightOnOff.new({
-	name = "Light",
-	room = "Bathroom",
-	topic = mqtt_z2m("bathroom/light"),
-	client = mqtt_client,
-	callback = off_timeout(debug and 60 or 45 * 60),
-})
-device_manager:add(bathroom_light)
-
-device_manager:add(Washer.new({
-	identifier = "bathroom_washer",
-	topic = mqtt_z2m("bathroom/washer"),
-	client = mqtt_client,
-	threshold = 1,
-	done_callback = function()
-		ntfy:send_notification({
-			title = "Laundy is done",
-			message = "Don't forget to hang it!",
-			tags = { "womans_clothes" },
-			priority = "high",
-		})
-	end,
-}))
-
-device_manager:add(OutletOnOff.new({
-	name = "Charger",
-	room = "Workbench",
-	topic = mqtt_z2m("workbench/charger"),
-	client = mqtt_client,
-	callback = off_timeout(debug and 5 or 20 * 3600),
-}))
-
-local workbench_outlet = OutletOnOff.new({
-	name = "Outlet",
-	room = "Workbench",
-	topic = mqtt_z2m("workbench/outlet"),
-	client = mqtt_client,
-})
-turn_off_when_away(workbench_outlet)
-device_manager:add(workbench_outlet)
-
-local workbench_light = LightColorTemperature.new({
-	name = "Light",
-	room = "Workbench",
-	topic = mqtt_z2m("workbench/light"),
-	client = mqtt_client,
-})
-turn_off_when_away(workbench_light)
-device_manager:add(workbench_light)
-
-local delay_color_temp = Timeout.new()
-device_manager:add(IkeaRemote.new({
-	name = "Remote",
-	room = "Workbench",
-	client = mqtt_client,
-	topic = mqtt_z2m("workbench/remote"),
-	callback = function(_, on)
-		delay_color_temp:cancel()
-		if on then
-			workbench_light:set_brightness(82)
-			-- NOTE: This light does NOT support changing both the brightness and color
-			-- temperature at the same time, so we first change the brightness and once
-			-- that is complete we change the color temperature, as that is less likely
-			-- to have to actually change.
-			delay_color_temp:start(0.5, function()
-				workbench_light:set_color_temperature(3333)
-			end)
-		else
-			workbench_light:set_on(false)
-		end
-	end,
-	battery_callback = check_battery,
-}))
-
-local hallway_top_light = HueGroup.new({
-	identifier = "hallway_top_light",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 83,
-	scene_id = "QeufkFDICEHWeKJ7",
-})
-device_manager:add(HueSwitch.new({
-	name = "SwitchBottom",
-	room = "Hallway",
-	client = mqtt_client,
-	topic = mqtt_z2m("hallway/switchbottom"),
-	left_callback = function()
-		hallway_top_light:set_on(not hallway_top_light:on())
-	end,
-	battery_callback = check_battery,
-}))
-device_manager:add(HueSwitch.new({
-	name = "SwitchTop",
-	room = "Hallway",
-	client = mqtt_client,
-	topic = mqtt_z2m("hallway/switchtop"),
-	left_callback = function()
-		hallway_top_light:set_on(not hallway_top_light:on())
-	end,
-	battery_callback = check_battery,
-}))
-
-local hallway_light_automation = {
-	timeout = Timeout.new(),
-	forced = false,
-	switch_callback = function(self, on)
-		self.timeout:cancel()
-		self.group.set_on(on)
-		self.forced = on
-	end,
-	door_callback = function(self, open)
-		if open then
-			self.timeout:cancel()
-
-			self.group.set_on(true)
-		elseif not self.forced then
-			self.timeout:start(debug and 10 or 2 * 60, function()
-				if self.trash == nil or self.trash:open_percent() == 0 then
-					self.group.set_on(false)
-				end
-			end)
-		end
-	end,
-	trash_callback = function(self, open)
-		if open then
-			self.group.set_on(true)
-		else
-			if
-				not self.timeout:is_waiting()
-				and (self.door == nil or self.door:open_percent() == 0)
-				and not self.forced
-			then
-				self.group.set_on(false)
-			end
-		end
-	end,
-	light_callback = function(self, on)
-		if
-			on
-			and (self.trash == nil or self.trash:open_percent()) == 0
-			and (self.door == nil or self.door:open_percent() == 0)
-		then
-			-- If the door and trash are not open, that means the light got turned on manually
-			self.timeout:cancel()
-			self.forced = true
-		elseif not on then
-			-- The light is never forced when it is off
-			self.forced = false
-		end
-	end,
-}
-
-local hallway_storage = LightBrightness.new({
-	name = "Storage",
-	room = "Hallway",
-	topic = mqtt_z2m("hallway/storage"),
-	client = mqtt_client,
-	callback = function(_, state)
-		hallway_light_automation:light_callback(state.state)
-	end,
-})
-turn_off_when_away(hallway_storage)
-device_manager:add(hallway_storage)
-
-local hallway_bottom_lights = HueGroup.new({
-	identifier = "hallway_bottom_lights",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 81,
-	scene_id = "3qWKxGVadXFFG4o",
-})
-device_manager:add(hallway_bottom_lights)
-
-hallway_light_automation.group = {
-	set_on = function(on)
-		if on then
-			hallway_storage:set_brightness(80)
-		else
-			hallway_storage:set_on(false)
-		end
-		hallway_bottom_lights:set_on(on)
-	end,
-}
-
-local frontdoor_presence = {
-	timeout = Timeout.new(),
-}
-setmetatable(frontdoor_presence, {
-	__call = function(self, open)
-		if open then
-			self.timeout:cancel()
-
-			if not presence_system:overall_presence() then
-				mqtt_client:send_message(mqtt_automation("presence/contact/frontdoor"), {
-					state = true,
-					updated = utils.get_epoch(),
-				})
-			end
-		else
-			self.timeout:start(debug and 10 or 15 * 60, function()
-				mqtt_client:send_message(mqtt_automation("presence/contact/frontdoor"), {})
-			end)
-		end
-	end,
-})
-
-device_manager:add(IkeaRemote.new({
-	name = "Remote",
-	room = "Hallway",
-	client = mqtt_client,
-	topic = mqtt_z2m("hallway/remote"),
-	callback = function(_, on)
-		hallway_light_automation:switch_callback(on)
-	end,
-	battery_callback = check_battery,
-}))
-local hallway_frontdoor = ContactSensor.new({
-	name = "Frontdoor",
-	room = "Hallway",
-	sensor_type = "Door",
-	topic = mqtt_z2m("hallway/frontdoor"),
-	client = mqtt_client,
-	presence = {
-		topic = mqtt_automation("presence/contact/frontdoor"),
-		timeout = debug and 10 or 15 * 60,
-	},
-	callback = function(_, open)
-		hallway_light_automation:door_callback(open)
-		frontdoor_presence(open)
-	end,
-	battery_callback = check_battery,
-})
-device_manager:add(hallway_frontdoor)
-hallway_light_automation.door = hallway_frontdoor
-
-local hallway_trash = ContactSensor.new({
-	name = "Trash",
-	room = "Hallway",
-	sensor_type = "Drawer",
-	topic = mqtt_z2m("hallway/trash"),
-	client = mqtt_client,
-	callback = function(_, open)
-		hallway_light_automation:trash_callback(open)
-	end,
-	battery_callback = check_battery,
-})
-device_manager:add(hallway_trash)
-hallway_light_automation.trash = hallway_trash
-
-local guest_light = LightOnOff.new({
-	name = "Light",
-	room = "Guest Room",
-	topic = mqtt_z2m("guest/light"),
-	client = mqtt_client,
-})
-turn_off_when_away(guest_light)
-device_manager:add(guest_light)
-
-local bedroom_air_filter = AirFilter.new({
-	name = "Air Filter",
-	room = "Bedroom",
-	url = "http://10.0.0.103",
-})
-device_manager:add(bedroom_air_filter)
-
-local bedroom_lights = HueGroup.new({
-	identifier = "bedroom_lights",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 3,
-	scene_id = "PvRs-lGD4VRytL9",
-})
-device_manager:add(bedroom_lights)
-local bedroom_lights_relax = HueGroup.new({
-	identifier = "bedroom_lights",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 3,
-	scene_id = "60tfTyR168v2csz",
-})
-device_manager:add(bedroom_lights_relax)
-
-device_manager:add(HueSwitch.new({
-	name = "Switch",
-	room = "Bedroom",
-	client = mqtt_client,
-	topic = mqtt_z2m("bedroom/switch"),
-	left_callback = function()
-		bedroom_lights:set_on(not bedroom_lights:on())
-	end,
-	left_hold_callback = function()
-		bedroom_lights_relax:set_on(true)
-	end,
-	battery_callback = check_battery,
-}))
-
-device_manager:add(ContactSensor.new({
-	name = "Balcony",
-	room = "Living Room",
-	sensor_type = "Door",
-	topic = mqtt_z2m("living/balcony"),
-	client = mqtt_client,
-	battery_callback = check_battery,
-}))
-device_manager:add(ContactSensor.new({
-	name = "Window",
-	room = "Living Room",
-	topic = mqtt_z2m("living/window"),
-	client = mqtt_client,
-	battery_callback = check_battery,
-}))
-device_manager:add(ContactSensor.new({
-	name = "Window",
-	room = "Bedroom",
-	topic = mqtt_z2m("bedroom/window"),
-	client = mqtt_client,
-	battery_callback = check_battery,
-}))
-device_manager:add(ContactSensor.new({
-	name = "Window",
-	room = "Guest Room",
-	topic = mqtt_z2m("guest/window"),
-	client = mqtt_client,
-	battery_callback = check_battery,
-}))
-
-local storage_light = LightBrightness.new({
-	name = "Light",
-	room = "Storage",
-	topic = mqtt_z2m("storage/light"),
-	client = mqtt_client,
-})
-turn_off_when_away(storage_light)
-device_manager:add(storage_light)
-
-device_manager:add(ContactSensor.new({
-	name = "Door",
-	room = "Storage",
-	sensor_type = "Door",
-	topic = mqtt_z2m("storage/door"),
-	client = mqtt_client,
-	callback = function(_, open)
-		if open then
-			storage_light:set_brightness(100)
-		else
-			storage_light:set_on(false)
-		end
-	end,
-	battery_callback = check_battery,
-}))
-
-device_manager:schedule("0 0 19 * * *", function()
-	bedroom_air_filter:set_on(true)
-end)
-device_manager:schedule("0 0 20 * * *", function()
-	bedroom_air_filter:set_on(false)
-end)
-
-return fulfillment
--- a/config/battery.lua
+++ b/config/battery.lua
@@ -0,0 +1,47 @@
+local ntfy = require("config.ntfy")
+
+--- @class BatteryModule: Module
+local module = {}
+
+--- @type {[string]: number}
+local low_battery = {}
+
+--- @param device DeviceInterface
+--- @param battery number
+function module.callback(device, battery)
+	local id = device:get_id()
+	if battery < 15 then
+		print("Device '" .. id .. "' has low battery: " .. tostring(battery))
+		low_battery[id] = battery
+	else
+		low_battery[id] = nil
+	end
+end
+
+local function notify_low_battery()
+	-- Don't send notifications if there are now devices with low battery
+	if next(low_battery) == nil then
+		print("No devices with low battery")
+		return
+	end
+
+	local lines = {}
+	for name, battery in pairs(low_battery) do
+		table.insert(lines, name .. ": " .. tostring(battery) .. "%")
+	end
+	local message = table.concat(lines, "\n")
+
+	ntfy.send_notification({
+		title = "Low battery",
+		message = message,
+		tags = { "battery" },
+		priority = "default",
+	})
+end
+
+--- @type Schedule
+module.schedule = {
+	["0 0 21 */1 * *"] = notify_low_battery,
+}
+
+return module
--- a/config/config.lua
+++ b/config/config.lua
@@ -0,0 +1,32 @@
+local utils = require("automation:utils")
+local secrets = require("automation:secrets")
+
+local host = utils.get_hostname()
+print("Lua " .. _VERSION .. " running on " .. utils.get_hostname())
+
+---@type Config
+return {
+	fulfillment = {
+		openid_url = "https://login.huizinga.dev/api/oidc",
+	},
+	mqtt = {
+		host = ((host == "zeus" or host == "hephaestus") and "olympus.lan.huizinga.dev") or "mosquitto",
+		port = 8883,
+		client_name = "automation-" .. host,
+		username = "mqtt",
+		password = secrets.mqtt_password,
+		tls = host == "zeus" or host == "hephaestus",
+	},
+	modules = {
+		require("config.battery"),
+		require("config.debug"),
+		require("config.hallway_automation"),
+		require("config.helper"),
+		require("config.hue_bridge"),
+		require("config.light"),
+		require("config.ntfy"),
+		require("config.presence"),
+		require("config.rooms"),
+		require("config.windows"),
+	},
+}
--- a/config/debug.lua
+++ b/config/debug.lua
@@ -0,0 +1,35 @@
+local helper = require("config.helper")
+local light = require("config.light")
+local presence = require("config.presence")
+local utils = require("automation:utils")
+local variables = require("automation:variables")
+
+--- @class DebugModule: Module
+local module = {}
+
+if variables.debug == "true" then
+	module.debug_mode = true
+elseif not variables.debug or variables.debug == "false" then
+	module.debug_mode = false
+else
+	error("Variable debug has invalid value '" .. variables.debug .. "', expected 'true' or 'false'")
+end
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	presence.add_callback(function(p)
+		mqtt_client:send_message(helper.mqtt_automation("debug") .. "/presence", {
+			state = p,
+			updated = utils.get_epoch(),
+		})
+	end)
+
+	light.add_callback(function(l)
+		mqtt_client:send_message(helper.mqtt_automation("debug") .. "/darkness", {
+			state = not l,
+			updated = utils.get_epoch(),
+		})
+	end)
+end
+
+return module
--- a/config/hallway_automation.lua
+++ b/config/hallway_automation.lua
@@ -0,0 +1,85 @@
+local debug = require("config.debug")
+local utils = require("automation:utils")
+
+--- @class HallwayAutomationModule: Module
+local module = {}
+
+local timeout = utils.Timeout.new()
+local forced = false
+--- @type OpenCloseInterface?
+local trash = nil
+--- @type OpenCloseInterface?
+local door = nil
+
+--- @type fun(on: boolean)[]
+local callbacks = {}
+
+--- @param on boolean
+local function callback(on)
+	for _, f in ipairs(callbacks) do
+		f(on)
+	end
+end
+
+---@type fun(device: DeviceInterface, on: boolean)
+function module.switch_callback(_, on)
+	timeout:cancel()
+	callback(on)
+	forced = on
+end
+
+---@type fun(device: DeviceInterface, open: boolean)
+function module.door_callback(_, open)
+	if open then
+		timeout:cancel()
+
+		callback(true)
+	elseif not forced then
+		timeout:start(debug.debug_mode and 10 or 2 * 60, function()
+			if trash == nil or trash:open_percent() == 0 then
+				callback(false)
+			end
+		end)
+	end
+end
+
+---@type fun(device: DeviceInterface, open: boolean)
+function module.trash_callback(_, open)
+	if open then
+		callback(true)
+	else
+		if not forced and not timeout:is_waiting() and (door == nil or door:open_percent() == 0) then
+			callback(false)
+		end
+	end
+end
+
+---@type fun(device: DeviceInterface, state: { state: boolean })
+function module.light_callback(_, state)
+	print("LIGHT = " .. tostring(state.state))
+	if state.state and (trash == nil or trash:open_percent()) == 0 and (door == nil or door:open_percent() == 0) then
+		-- If the door and trash are not open, that means the light got turned on manually
+		timeout:cancel()
+		forced = true
+	elseif not state.state then
+		-- The light is never forced when it is off
+		forced = false
+	end
+end
+
+--- @param t OpenCloseInterface
+function module.set_trash(t)
+	trash = t
+end
+
+--- @param d OpenCloseInterface
+function module.set_door(d)
+	door = d
+end
+
+--- @param c fun(on: boolean)
+function module.add_callback(c)
+	table.insert(callbacks, c)
+end
+
+return module
--- a/config/helper.lua
+++ b/config/helper.lua
@@ -0,0 +1,49 @@
+local utils = require("automation:utils")
+
+--- @class HelperModule: Module
+local module = {}
+
+--- @param topic string
+--- @return string
+function module.mqtt_z2m(topic)
+	return "zigbee2mqtt/" .. topic
+end
+
+--- @param topic string
+--- @return string
+function module.mqtt_automation(topic)
+	return "automation/" .. topic
+end
+
+--- @return fun(self: OnOffInterface, state: {state: boolean, power: number})
+function module.auto_off()
+	local timeout = utils.Timeout.new()
+
+	return function(self, state)
+		if state.state and state.power < 100 then
+			timeout:start(3, function()
+				self:set_on(false)
+			end)
+		else
+			timeout:cancel()
+		end
+	end
+end
+
+--- @param duration number
+--- @return fun(self: OnOffInterface, state: {state: boolean})
+function module.off_timeout(duration)
+	local timeout = utils.Timeout.new()
+
+	return function(self, state)
+		if state.state then
+			timeout:start(duration, function()
+				self:set_on(false)
+			end)
+		else
+			timeout:cancel()
+		end
+	end
+end
+
+return module
--- a/config/hue_bridge.lua
+++ b/config/hue_bridge.lua
@@ -0,0 +1,41 @@
+local devices = require("automation:devices")
+local light = require("config.light")
+local presence = require("config.presence")
+local secrets = require("automation:secrets")
+
+--- @class HueBridgeModule: Module
+local module = {}
+
+module.ip = "10.0.0.102"
+module.token = secrets.hue_token
+
+if module.token == nil then
+	error("Hue token is not specified")
+end
+
+--- @type SetupFunction
+function module.setup()
+	local bridge = devices.HueBridge.new({
+		identifier = "hue_bridge",
+		ip = module.ip,
+		login = module.token,
+		flags = {
+			presence = 41,
+			darkness = 43,
+		},
+	})
+
+	light.add_callback(function(l)
+		bridge:set_flag("darkness", not l)
+	end)
+
+	presence.add_callback(function(p)
+		bridge:set_flag("presence", p)
+	end)
+
+	return {
+		bridge,
+	}
+end
+
+return module
--- a/config/light.lua
+++ b/config/light.lua
@@ -0,0 +1,44 @@
+local devices = require("automation:devices")
+local helper = require("config.helper")
+
+--- @class LightModule: Module
+local module = {}
+
+--- @class OnPresence
+--- @field [integer] fun(light: boolean)
+local callbacks = {}
+
+--- @param callback fun(light: boolean)
+function module.add_callback(callback)
+	table.insert(callbacks, callback)
+end
+
+--- @param _ DeviceInterface
+--- @param light boolean
+local function callback(_, light)
+	for _, f in ipairs(callbacks) do
+		f(light)
+	end
+end
+
+--- @type LightSensor?
+module.device = nil
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	module.device = devices.LightSensor.new({
+		identifier = "living_light_sensor",
+		topic = helper.mqtt_z2m("living/light"),
+		client = mqtt_client,
+		min = 22000,
+		max = 23500,
+		callback = callback,
+	})
+
+	--- @type Module
+	return {
+		module.device,
+	}
+end
+
+return module
--- a/config/ntfy.lua
+++ b/config/ntfy.lua
@@ -0,0 +1,34 @@
+local devices = require("automation:devices")
+local secrets = require("automation:secrets")
+
+--- @class NtfyModule: Module
+local module = {}
+
+local ntfy_topic = secrets.ntfy_topic
+if ntfy_topic == nil then
+	error("Ntfy topic is not specified")
+end
+
+--- @type Ntfy?
+local ntfy = nil
+
+--- @param notification Notification
+function module.send_notification(notification)
+	if ntfy then
+		ntfy:send_notification(notification)
+	end
+end
+
+--- @type SetupFunction
+function module.setup()
+	ntfy = devices.Ntfy.new({
+		topic = ntfy_topic,
+	})
+
+	--- @type Module
+	return {
+		ntfy,
+	}
+end
+
+return module
--- a/config/presence.lua
+++ b/config/presence.lua
@@ -0,0 +1,80 @@
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local ntfy = require("config.ntfy")
+
+--- @class PresenceModule: Module
+local module = {}
+
+--- @class OnPresence
+--- @field [integer] fun(presence: boolean)
+local callbacks = {}
+
+--- @param callback fun(presence: boolean)
+function module.add_callback(callback)
+	table.insert(callbacks, callback)
+end
+
+--- @param device OnOffInterface
+function module.turn_off_when_away(device)
+	module.add_callback(function(presence)
+		if not presence then
+			device:set_on(false)
+		end
+	end)
+end
+
+--- @param _ DeviceInterface
+--- @param presence boolean
+local function callback(_, presence)
+	for _, f in ipairs(callbacks) do
+		f(presence)
+	end
+end
+
+--- @type Presence?
+local presence = nil
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	presence = devices.Presence.new({
+		topic = helper.mqtt_automation("presence/+/#"),
+		client = mqtt_client,
+		callback = callback,
+	})
+
+	module.add_callback(function(p)
+		ntfy.send_notification({
+			title = "Presence",
+			message = p and "Home" or "Away",
+			tags = { "house" },
+			priority = "low",
+			actions = {
+				{
+					action = "broadcast",
+					extras = {
+						cmd = "presence",
+						state = p and "0" or "1",
+					},
+					label = p and "Set away" or "Set home",
+					clear = true,
+				},
+			},
+		})
+	end)
+
+	--- @type Module
+	return {
+		presence,
+	}
+end
+
+function module.overall_presence()
+	-- Default to no presence when the device has not been created yet
+	if not presence then
+		return false
+	end
+
+	return presence:overall_presence()
+end
+
+return module
--- a/config/rooms.lua
+++ b/config/rooms.lua
@@ -0,0 +1,12 @@
+--- @type Module
+return {
+	require("config.rooms.bathroom"),
+	require("config.rooms.bedroom"),
+	require("config.rooms.guest_bedroom"),
+	require("config.rooms.hallway_bottom"),
+	require("config.rooms.hallway_top"),
+	require("config.rooms.kitchen"),
+	require("config.rooms.living_room"),
+	require("config.rooms.storage"),
+	require("config.rooms.workbench"),
+}
--- a/config/rooms/bathroom.lua
+++ b/config/rooms/bathroom.lua
@@ -0,0 +1,40 @@
+local debug = require("config.debug")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local ntfy = require("config.ntfy")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.LightOnOff.new({
+		name = "Light",
+		room = "Bathroom",
+		topic = helper.mqtt_z2m("bathroom/light"),
+		client = mqtt_client,
+		callback = helper.off_timeout(debug.debug_mode and 60 or 45 * 60),
+	})
+
+	local washer = devices.Washer.new({
+		identifier = "bathroom_washer",
+		topic = helper.mqtt_z2m("bathroom/washer"),
+		client = mqtt_client,
+		threshold = 1,
+		done_callback = function()
+			ntfy.send_notification({
+				title = "Laundy is done",
+				message = "Don't forget to hang it!",
+				tags = { "womans_clothes" },
+				priority = "high",
+			})
+		end,
+	})
+
+	--- @type Module
+	return {
+		light,
+		washer,
+	}
+end
+
+return module
--- a/config/rooms/bedroom.lua
+++ b/config/rooms/bedroom.lua
@@ -0,0 +1,78 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+--- @type AirFilter?
+local air_filter = nil
+
+function module.setup(mqtt_client)
+	local lights = devices.HueGroup.new({
+		identifier = "bedroom_lights",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 3,
+		scene_id = "PvRs-lGD4VRytL9",
+	})
+	local lights_relax = devices.HueGroup.new({
+		identifier = "bedroom_lights_relax",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 3,
+		scene_id = "60tfTyR168v2csz",
+	})
+
+	air_filter = devices.AirFilter.new({
+		name = "Air Filter",
+		room = "Bedroom",
+		url = "http://10.0.0.103",
+	})
+
+	local switch = devices.HueSwitch.new({
+		name = "Switch",
+		room = "Bedroom",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("bedroom/switch"),
+		left_callback = function()
+			lights:set_on(not lights:on())
+		end,
+		left_hold_callback = function()
+			lights_relax:set_on(true)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local window = devices.ContactSensor.new({
+		name = "Window",
+		room = "Bedroom",
+		topic = helper.mqtt_z2m("bedroom/window"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(window)
+
+	--- @type Module
+	return {
+		devices = {
+			lights,
+			lights_relax,
+			air_filter,
+			switch,
+			window,
+		},
+		schedule = {
+			["0 0 19 * * *"] = function()
+				air_filter:set_on(true)
+			end,
+			["0 0 20 * * *"] = function()
+				air_filter:set_on(false)
+			end,
+		},
+	}
+end
+
+return module
--- a/config/rooms/guest_bedroom.lua
+++ b/config/rooms/guest_bedroom.lua
@@ -0,0 +1,35 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local presence = require("config.presence")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.LightOnOff.new({
+		name = "Light",
+		room = "Guest Room",
+		topic = helper.mqtt_z2m("guest/light"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(light)
+
+	local window = devices.ContactSensor.new({
+		name = "Window",
+		room = "Guest Room",
+		topic = helper.mqtt_z2m("guest/window"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(window)
+
+	--- @type Module
+	return {
+		light,
+		window,
+	}
+end
+
+return module
--- a/config/rooms/hallway_bottom.lua
+++ b/config/rooms/hallway_bottom.lua
@@ -0,0 +1,110 @@
+local battery = require("config.battery")
+local debug = require("config.debug")
+local devices = require("automation:devices")
+local hallway_automation = require("config.hallway_automation")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local presence = require("config.presence")
+local utils = require("automation:utils")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local main_light = devices.HueGroup.new({
+		identifier = "hallway_main_light",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 81,
+		scene_id = "3qWKxGVadXFFG4o",
+	})
+	hallway_automation.add_callback(function(on)
+		main_light:set_on(on)
+	end)
+
+	local storage_light = devices.LightBrightness.new({
+		name = "Storage",
+		room = "Hallway",
+		topic = helper.mqtt_z2m("hallway/storage"),
+		client = mqtt_client,
+		callback = hallway_automation.light_callback,
+	})
+	presence.turn_off_when_away(storage_light)
+	hallway_automation.add_callback(function(on)
+		if on then
+			storage_light:set_brightness(80)
+		else
+			storage_light:set_on(false)
+		end
+	end)
+
+	local remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Hallway",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("hallway/remote"),
+		callback = hallway_automation.switch_callback,
+		battery_callback = battery.callback,
+	})
+
+	local trash = devices.ContactSensor.new({
+		name = "Trash",
+		room = "Hallway",
+		sensor_type = "Drawer",
+		topic = helper.mqtt_z2m("hallway/trash"),
+		client = mqtt_client,
+		callback = hallway_automation.trash_callback,
+		battery_callback = battery.callback,
+	})
+	hallway_automation.set_trash(trash)
+
+	---@param duration number
+	---@return fun(_, open: boolean)
+	local function frontdoor_presence(duration)
+		local timeout = utils.Timeout.new()
+
+		return function(_, open)
+			if open then
+				timeout:cancel()
+
+				if presence.overall_presence() then
+					mqtt_client:send_message(helper.mqtt_automation("presence/contact/frontdoor"), {
+						state = true,
+						updated = utils.get_epoch(),
+					})
+				end
+			else
+				timeout:start(duration, function()
+					mqtt_client:send_message(helper.mqtt_automation("presence/contact/frontdoor"), nil)
+				end)
+			end
+		end
+	end
+
+	local frontdoor = devices.ContactSensor.new({
+		name = "Frontdoor",
+		room = "Hallway",
+		sensor_type = "Door",
+		topic = helper.mqtt_z2m("hallway/frontdoor"),
+		client = mqtt_client,
+		callback = {
+			frontdoor_presence(debug.debug_mode and 10 or 15 * 60),
+			hallway_automation.door_callback,
+		},
+		battery_callback = battery.callback,
+	})
+	windows.add(frontdoor)
+	hallway_automation.set_door(frontdoor)
+
+	--- @type Module
+	return {
+		main_light,
+		storage_light,
+		remote,
+		trash,
+		frontdoor,
+	}
+end
+
+return module
--- a/config/rooms/hallway_top.lua
+++ b/config/rooms/hallway_top.lua
@@ -0,0 +1,48 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.HueGroup.new({
+		identifier = "hallway_top_light",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 83,
+		scene_id = "QeufkFDICEHWeKJ7",
+	})
+
+	local top_switch = devices.HueSwitch.new({
+		name = "SwitchTop",
+		room = "Hallway",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("hallway/switchtop"),
+		left_callback = function()
+			light:set_on(not light:on())
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local bottom_switch = devices.HueSwitch.new({
+		name = "SwitchBottom",
+		room = "Hallway",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("hallway/switchbottom"),
+		left_callback = function()
+			light:set_on(not light:on())
+		end,
+		battery_callback = battery.callback,
+	})
+
+	--- @type Module
+	return {
+		light,
+		top_switch,
+		bottom_switch,
+	}
+end
+
+return module
--- a/config/rooms/kitchen.lua
+++ b/config/rooms/kitchen.lua
@@ -0,0 +1,71 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local presence = require("config.presence")
+
+--- @class KitchenModule: Module
+local module = {}
+
+--- @type HueGroup?
+local lights = nil
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	lights = devices.HueGroup.new({
+		identifier = "kitchen_lights",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 7,
+		scene_id = "7MJLG27RzeRAEVJ",
+	})
+
+	local kettle = devices.OutletPower.new({
+		outlet_type = "Kettle",
+		name = "Kettle",
+		room = "Kitchen",
+		topic = helper.mqtt_z2m("kitchen/kettle"),
+		client = mqtt_client,
+		callback = helper.auto_off(),
+	})
+	presence.turn_off_when_away(kettle)
+
+	local kettle_remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Kitchen",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("kitchen/remote"),
+		single_button = true,
+		callback = function(_, on)
+			kettle:set_on(on)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local kettle_remote_bedroom = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Bedroom",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("bedroom/remote"),
+		single_button = true,
+		callback = function(_, on)
+			kettle:set_on(on)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	return {
+		lights,
+		kettle,
+		kettle_remote,
+		kettle_remote_bedroom,
+	}
+end
+
+function module.toggle_lights()
+	if lights then
+		lights:set_on(not lights:on())
+	end
+end
+
+return module
--- a/config/rooms/living_room.lua
+++ b/config/rooms/living_room.lua
@@ -0,0 +1,126 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local presence = require("config.presence")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local lights = devices.HueGroup.new({
+		identifier = "living_lights",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 1,
+		scene_id = "SNZw7jUhQ3cXSjkj",
+	})
+
+	local lights_relax = devices.HueGroup.new({
+		identifier = "living_lights_relax",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 1,
+		scene_id = "eRJ3fvGHCcb6yNw",
+	})
+
+	local switch = devices.HueSwitch.new({
+		name = "Switch",
+		room = "Living",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("living/switch"),
+		left_callback = require("config.rooms.kitchen").toggle_lights,
+		right_callback = function()
+			lights:set_on(not lights:on())
+		end,
+		right_hold_callback = function()
+			lights_relax:set_on(true)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local pc = devices.WakeOnLAN.new({
+		name = "Zeus",
+		room = "Living Room",
+		topic = helper.mqtt_automation("appliance/living_room/zeus"),
+		client = mqtt_client,
+		mac_address = "30:9c:23:60:9c:13",
+		broadcast_ip = "10.0.3.255",
+	})
+
+	local mixer = devices.OutletOnOff.new({
+		name = "Mixer",
+		room = "Living Room",
+		topic = helper.mqtt_z2m("living/mixer"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(mixer)
+
+	local speakers = devices.OutletOnOff.new({
+		name = "Speakers",
+		room = "Living Room",
+		topic = helper.mqtt_z2m("living/speakers"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(speakers)
+
+	local audio_remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Living Room",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("living/remote"),
+		single_button = true,
+		callback = function(_, on)
+			if on then
+				if mixer:on() then
+					mixer:set_on(false)
+					speakers:set_on(false)
+				else
+					mixer:set_on(true)
+					speakers:set_on(true)
+				end
+			else
+				if not mixer:on() then
+					mixer:set_on(true)
+				else
+					speakers:set_on(not speakers:on())
+				end
+			end
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local balcony = devices.ContactSensor.new({
+		name = "Balcony",
+		room = "Living Room",
+		sensor_type = "Door",
+		topic = helper.mqtt_z2m("living/balcony"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(balcony)
+	local window = devices.ContactSensor.new({
+		name = "Window",
+		room = "Living Room",
+		topic = helper.mqtt_z2m("living/window"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(window)
+
+	--- @type Module
+	return {
+		lights,
+		lights_relax,
+		switch,
+		pc,
+		mixer,
+		speakers,
+		audio_remote,
+		balcony,
+		window,
+	}
+end
+
+return module
--- a/config/rooms/storage.lua
+++ b/config/rooms/storage.lua
@@ -0,0 +1,41 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local presence = require("config.presence")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.LightBrightness.new({
+		name = "Light",
+		room = "Storage",
+		topic = helper.mqtt_z2m("storage/light"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(light)
+
+	local door = devices.ContactSensor.new({
+		name = "Door",
+		room = "Storage",
+		sensor_type = "Door",
+		topic = helper.mqtt_z2m("storage/door"),
+		client = mqtt_client,
+		callback = function(_, open)
+			if open then
+				light:set_brightness(100)
+			else
+				light:set_on(false)
+			end
+		end,
+		battery_callback = battery.callback,
+	})
+
+	--- @type Module
+	return {
+		light,
+		door,
+	}
+end
+
+return module
--- a/config/rooms/workbench.lua
+++ b/config/rooms/workbench.lua
@@ -0,0 +1,69 @@
+local battery = require("config.battery")
+local debug = require("config.debug")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local presence = require("config.presence")
+local utils = require("automation:utils")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local charger = devices.OutletOnOff.new({
+		name = "Charger",
+		room = "Workbench",
+		topic = helper.mqtt_z2m("workbench/charger"),
+		client = mqtt_client,
+		callback = helper.off_timeout(debug.debug_mode and 5 or 20 * 3600),
+	})
+
+	local outlets = devices.OutletOnOff.new({
+		name = "Outlets",
+		room = "Workbench",
+		topic = helper.mqtt_z2m("workbench/outlet"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(outlets)
+
+	local light = devices.LightColorTemperature.new({
+		name = "Light",
+		room = "Workbench",
+		topic = helper.mqtt_z2m("workbench/light"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(light)
+
+	local delay_color_temp = utils.Timeout.new()
+	local remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Workbench",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("workbench/remote"),
+		callback = function(_, on)
+			delay_color_temp:cancel()
+			if on then
+				light:set_brightness(82)
+				-- NOTE: This light does NOT support changing both the brightness and color
+				-- temperature at the same time, so we first change the brightness and once
+				-- that is complete we change the color temperature, as that is less likely
+				-- to have to actually change.
+				delay_color_temp:start(0.5, function()
+					light:set_color_temperature(3333)
+				end)
+			else
+				light:set_on(false)
+			end
+		end,
+		battery_callback = battery.callback,
+	})
+
+	--- @type Module
+	return {
+		charger,
+		outlets,
+		light,
+		remote,
+	}
+end
+
+return module
--- a/config/windows.lua
+++ b/config/windows.lua
@@ -0,0 +1,43 @@
+local ntfy = require("config.ntfy")
+local presence = require("config.presence")
+
+--- @class WindowsModule: Module
+local module = {}
+
+--- @class OnPresence
+--- @field [integer] OpenCloseInterface
+local sensors = {}
+
+--- @param sensor OpenCloseInterface
+function module.add(sensor)
+	table.insert(sensors, sensor)
+end
+
+--- @type SetupFunction
+function module.setup()
+	presence.add_callback(function(p)
+		if not p then
+			local open = {}
+			for _, sensor in ipairs(sensors) do
+				if sensor:open_percent() > 0 then
+					local id = sensor:get_id()
+					print("Open window detected: " .. id)
+					table.insert(open, id)
+				end
+			end
+
+			if #open > 0 then
+				local message = table.concat(open, "\n")
+
+				ntfy.send_notification({
+					title = "Windows are open",
+					message = message,
+					tags = { "window" },
+					priority = "high",
+				})
+			end
+		end
+	end)
+end
+
+return module
--- a/definitions/automation:devices.lua
+++ b/definitions/automation:devices.lua
@@ -0,0 +1,337 @@
+-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED
+---@meta
+
+local devices
+
+---@class Action
+---@field action
+---| "broadcast"
+---@field extras (table<string, string>)?
+---@field label string
+---@field clear (boolean)?
+local Action
+
+---@class AirFilter: DeviceInterface, OnOffInterface
+local AirFilter
+devices.AirFilter = {}
+---@param config AirFilterConfig
+---@return AirFilter
+function devices.AirFilter.new(config) end
+
+---@class AirFilterConfig
+---@field name string
+---@field room (string)?
+---@field url string
+local AirFilterConfig
+
+---@class ConfigLightLightStateBrightness
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field callback (fun(_: LightBrightness, _: LightStateBrightness) | fun(_: LightBrightness, _: LightStateBrightness)[])?
+---@field client (AsyncClient)?
+local ConfigLightLightStateBrightness
+
+---@class ConfigLightLightStateColorTemperature
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field callback (fun(_: LightColorTemperature, _: LightStateColorTemperature) | fun(_: LightColorTemperature, _: LightStateColorTemperature)[])?
+---@field client (AsyncClient)?
+local ConfigLightLightStateColorTemperature
+
+---@class ConfigLightLightStateOnOff
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field callback (fun(_: LightOnOff, _: LightStateOnOff) | fun(_: LightOnOff, _: LightStateOnOff)[])?
+---@field client (AsyncClient)?
+local ConfigLightLightStateOnOff
+
+---@class ConfigOutletOutletStateOnOff
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field outlet_type (OutletType)?
+---@field callback (fun(_: OutletOnOff, _: OutletStateOnOff) | fun(_: OutletOnOff, _: OutletStateOnOff)[])?
+---@field client AsyncClient
+local ConfigOutletOutletStateOnOff
+
+---@class ConfigOutletOutletStatePower
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field outlet_type (OutletType)?
+---@field callback (fun(_: OutletPower, _: OutletStatePower) | fun(_: OutletPower, _: OutletStatePower)[])?
+---@field client AsyncClient
+local ConfigOutletOutletStatePower
+
+---@class ContactSensor: DeviceInterface, OpenCloseInterface
+local ContactSensor
+devices.ContactSensor = {}
+---@param config ContactSensorConfig
+---@return ContactSensor
+function devices.ContactSensor.new(config) end
+
+---@class ContactSensorConfig
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field sensor_type (SensorType)?
+---@field callback (fun(_: ContactSensor, _: boolean) | fun(_: ContactSensor, _: boolean)[])?
+---@field battery_callback (fun(_: ContactSensor, _: number) | fun(_: ContactSensor, _: number)[])?
+---@field client (AsyncClient)?
+local ContactSensorConfig
+
+---@alias Flag
+---| "presence"
+---| "darkness"
+
+---@class FlagIDs
+---@field presence integer
+---@field darkness integer
+local FlagIDs
+
+---@class HueBridge: DeviceInterface
+local HueBridge
+devices.HueBridge = {}
+---@param config HueBridgeConfig
+---@return HueBridge
+function devices.HueBridge.new(config) end
+---@async
+---@param flag Flag
+---@param value boolean
+function HueBridge:set_flag(flag, value) end
+
+---@class HueBridgeConfig
+---@field identifier string
+---@field ip string
+---@field login string
+---@field flags FlagIDs
+local HueBridgeConfig
+
+---@class HueGroup: DeviceInterface, OnOffInterface
+local HueGroup
+devices.HueGroup = {}
+---@param config HueGroupConfig
+---@return HueGroup
+function devices.HueGroup.new(config) end
+
+---@class HueGroupConfig
+---@field identifier string
+---@field ip string
+---@field login string
+---@field group_id integer
+---@field scene_id string
+local HueGroupConfig
+
+---@class HueSwitch: DeviceInterface
+local HueSwitch
+devices.HueSwitch = {}
+---@param config HueSwitchConfig
+---@return HueSwitch
+function devices.HueSwitch.new(config) end
+
+---@class HueSwitchConfig
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field client AsyncClient
+---@field left_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field right_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field left_hold_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field right_hold_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field battery_callback (fun(_: HueSwitch, _: number) | fun(_: HueSwitch, _: number)[])?
+local HueSwitchConfig
+
+---@class IkeaRemote: DeviceInterface
+local IkeaRemote
+devices.IkeaRemote = {}
+---@param config IkeaRemoteConfig
+---@return IkeaRemote
+function devices.IkeaRemote.new(config) end
+
+---@class IkeaRemoteConfig
+---@field name string
+---@field room (string)?
+---@field single_button (boolean)?
+---@field topic string
+---@field client AsyncClient
+---@field callback (fun(_: IkeaRemote, _: boolean) | fun(_: IkeaRemote, _: boolean)[])?
+---@field battery_callback (fun(_: IkeaRemote, _: number) | fun(_: IkeaRemote, _: number)[])?
+local IkeaRemoteConfig
+
+---@class KasaOutlet: DeviceInterface, OnOffInterface
+local KasaOutlet
+devices.KasaOutlet = {}
+---@param config KasaOutletConfig
+---@return KasaOutlet
+function devices.KasaOutlet.new(config) end
+
+---@class KasaOutletConfig
+---@field identifier string
+---@field ip string
+local KasaOutletConfig
+
+---@class LightBrightness: DeviceInterface, OnOffInterface, BrightnessInterface
+local LightBrightness
+devices.LightBrightness = {}
+---@param config ConfigLightLightStateBrightness
+---@return LightBrightness
+function devices.LightBrightness.new(config) end
+
+---@class LightColorTemperature: DeviceInterface, OnOffInterface, BrightnessInterface, ColorSettingInterface
+local LightColorTemperature
+devices.LightColorTemperature = {}
+---@param config ConfigLightLightStateColorTemperature
+---@return LightColorTemperature
+function devices.LightColorTemperature.new(config) end
+
+---@class LightOnOff: DeviceInterface, OnOffInterface
+local LightOnOff
+devices.LightOnOff = {}
+---@param config ConfigLightLightStateOnOff
+---@return LightOnOff
+function devices.LightOnOff.new(config) end
+
+---@class LightSensor: DeviceInterface
+local LightSensor
+devices.LightSensor = {}
+---@param config LightSensorConfig
+---@return LightSensor
+function devices.LightSensor.new(config) end
+
+---@class LightSensorConfig
+---@field identifier string
+---@field topic string
+---@field min integer
+---@field max integer
+---@field callback (fun(_: LightSensor, _: boolean) | fun(_: LightSensor, _: boolean)[])?
+---@field client AsyncClient
+local LightSensorConfig
+
+---@class LightStateBrightness
+---@field state boolean
+---@field brightness number
+local LightStateBrightness
+
+---@class LightStateColorTemperature
+---@field state boolean
+---@field brightness number
+---@field color_temp integer
+local LightStateColorTemperature
+
+---@class LightStateOnOff
+---@field state boolean
+local LightStateOnOff
+
+---@class Notification
+---@field title string
+---@field message (string)?
+---@field tags ((string)[])?
+---@field priority (Priority)?
+---@field actions ((Action)[])?
+local Notification
+
+---@class Ntfy: DeviceInterface
+local Ntfy
+devices.Ntfy = {}
+---@param config NtfyConfig
+---@return Ntfy
+function devices.Ntfy.new(config) end
+---@async
+---@param notification Notification
+function Ntfy:send_notification(notification) end
+
+---@class NtfyConfig
+---@field url (string)?
+---@field topic string
+local NtfyConfig
+
+---@class OutletOnOff: DeviceInterface, OnOffInterface
+local OutletOnOff
+devices.OutletOnOff = {}
+---@param config ConfigOutletOutletStateOnOff
+---@return OutletOnOff
+function devices.OutletOnOff.new(config) end
+
+---@class OutletPower: DeviceInterface, OnOffInterface
+local OutletPower
+devices.OutletPower = {}
+---@param config ConfigOutletOutletStatePower
+---@return OutletPower
+function devices.OutletPower.new(config) end
+
+---@class OutletStateOnOff
+---@field state boolean
+local OutletStateOnOff
+
+---@class OutletStatePower
+---@field state boolean
+---@field power number
+local OutletStatePower
+
+---@alias OutletType
+---| "Outlet"
+---| "Kettle"
+
+---@class Presence: DeviceInterface
+local Presence
+devices.Presence = {}
+---@param config PresenceConfig
+---@return Presence
+function devices.Presence.new(config) end
+---@async
+---@return boolean
+function Presence:overall_presence() end
+
+---@class PresenceConfig
+---@field topic string
+---@field callback (fun(_: Presence, _: boolean) | fun(_: Presence, _: boolean)[])?
+---@field client AsyncClient
+local PresenceConfig
+
+---@alias Priority
+---| "min"
+---| "low"
+---| "default"
+---| "high"
+---| "max"
+
+---@alias SensorType
+---| "Door"
+---| "Drawer"
+---| "Window"
+
+---@class WakeOnLAN: DeviceInterface
+local WakeOnLAN
+devices.WakeOnLAN = {}
+---@param config WolConfig
+---@return WakeOnLAN
+function devices.WakeOnLAN.new(config) end
+
+---@class Washer: DeviceInterface
+local Washer
+devices.Washer = {}
+---@param config WasherConfig
+---@return Washer
+function devices.Washer.new(config) end
+
+---@class WasherConfig
+---@field identifier string
+---@field topic string
+---@field threshold number
+---@field done_callback (fun(_: Washer) | fun(_: Washer)[])?
+---@field client AsyncClient
+local WasherConfig
+
+---@class WolConfig
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field mac_address string
+---@field broadcast_ip (string)?
+---@field client AsyncClient
+local WolConfig
+
+return devices
--- a/definitions/automation:secrets.lua
+++ b/definitions/automation:secrets.lua
@@ -0,0 +1,6 @@
+---@meta
+
+---@type table<string, string?>
+local secrets
+
+return secrets
--- a/definitions/automation:utils.lua
+++ b/definitions/automation:utils.lua
@@ -0,0 +1,27 @@
+-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED
+---@meta
+
+local utils
+
+---@class Timeout
+local Timeout
+---@async
+---@param timeout number
+---@param callback fun() | fun()[]
+function Timeout:start(timeout, callback) end
+---@async
+function Timeout:cancel() end
+---@async
+---@return boolean
+function Timeout:is_waiting() end
+utils.Timeout = {}
+---@return Timeout
+function utils.Timeout.new() end
+
+---@return string
+function utils.get_hostname() end
+
+---@return integer
+function utils.get_epoch() end
+
+return utils
--- a/definitions/automation:variables.lua
+++ b/definitions/automation:variables.lua
@@ -0,0 +1,6 @@
+---@meta
+
+---@type table<string, string?>
+local variables
+
+return variables
--- a/definitions/config.lua
+++ b/definitions/config.lua
@@ -0,0 +1,41 @@
+-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED
+---@meta
+
+---@class FulfillmentConfig
+---@field openid_url string
+---@field ip (string)?
+---@field port (integer)?
+local FulfillmentConfig
+
+---@class Config
+---@field fulfillment FulfillmentConfig
+---@field modules (Module)[]
+---@field mqtt MqttConfig
+local Config
+
+---@alias SetupFunction fun(mqtt_client: AsyncClient): Module | DeviceInterface[] | nil
+
+---@alias Schedule table<string, fun() | fun()[]>
+
+---@class Module
+---@field setup (SetupFunction)?
+---@field devices (DeviceInterface)[]?
+---@field schedule Schedule?
+---@field [number] (Module)[]?
+local Module
+
+---@class MqttConfig
+---@field host string
+---@field port integer
+---@field client_name string
+---@field username string
+---@field password string
+---@field tls (boolean)?
+local MqttConfig
+
+---@class AsyncClient
+local AsyncClient
+---@async
+---@param topic string
+---@param message table?
+function AsyncClient:send_message(topic, message) end
--- a/definitions/interfaces.lua
+++ b/definitions/interfaces.lua
@@ -0,0 +1,42 @@
+--- @meta
+
+---@class DeviceInterface
+local DeviceInterface
+---@return string
+function DeviceInterface:get_id() end
+
+---@class OnOffInterface: DeviceInterface
+local OnOffInterface
+---@async
+---@param on boolean
+function OnOffInterface:set_on(on) end
+---@async
+---@return boolean
+function OnOffInterface:on() end
+
+---@class BrightnessInterface: DeviceInterface
+local BrightnessInterface
+---@async
+---@param brightness integer
+function BrightnessInterface:set_brightness(brightness) end
+---@async
+---@return integer
+function BrightnessInterface:brightness() end
+
+---@class ColorSettingInterface: DeviceInterface
+local ColorSettingInterface
+---@async
+---@param temperature integer
+function ColorSettingInterface:set_color_temperature(temperature) end
+---@async
+---@return integer
+function ColorSettingInterface:color_temperature() end
+
+---@class OpenCloseInterface: DeviceInterface
+local OpenCloseInterface
+---@async
+---@param open_percent integer
+function OpenCloseInterface:set_open_percent(open_percent) end
+---@async
+---@return integer
+function OpenCloseInterface:open_percent() end
--- a/src/bin/automation.rs
+++ b/src/bin/automation.rs
@@ -1,32 +1,27 @@
 #![feature(iter_intersperse)]
-mod config;
-mod secret;
-mod web;

 use std::net::SocketAddr;
 use std::path::Path;
 use std::process;
-use std::time::{SystemTime, UNIX_EPOCH};

 use ::config::{Environment, File};
-use automation_lib::config::{FulfillmentConfig, MqttConfig};
+use automation::config::{Config, Setup};
+use automation::secret::EnvironmentSecretFile;
+use automation::version::VERSION;
+use automation::web::{ApiError, User};
 use automation_lib::device_manager::DeviceManager;
-use automation_lib::helpers;
-use automation_lib::mqtt::{self, WrappedAsyncClient};
+use automation_lib::mqtt;
 use axum::extract::{FromRef, State};
 use axum::http::StatusCode;
 use axum::routing::post;
 use axum::{Json, Router};
-use config::Config;
-use dotenvy::dotenv;
 use google_home::{GoogleHome, Request, Response};
 use mlua::LuaSerdeExt;
-use rumqttc::AsyncClient;
 use tokio::net::TcpListener;
 use tracing::{debug, error, info, warn};
-use web::{ApiError, User};

-use crate::secret::EnvironmentSecretFile;
+// Force automation_devices to link so that it gets registered as a module
+extern crate automation_devices;

 #[derive(Clone)]
 struct AppState {
@@ -72,11 +67,11 @@ async fn fulfillment(
 }

 async fn app() -> anyhow::Result<()> {
-    dotenv().ok();
-
    tracing_subscriber::fmt::init();

-    let config: Config = ::config::Config::builder()
+    info!(version = VERSION, "automation_rs");
+
+    let setup: Setup = ::config::Config::builder()
        .add_source(
            File::with_name(&format!("{}.toml", std::env!("CARGO_PKG_NAME"))).required(false),
        )
@@ -91,8 +86,6 @@ async fn app() -> anyhow::Result<()> {
        .try_deserialize()
        .unwrap();

-    info!("Starting automation_rs...");
-
    // Setup the device handler
    let device_manager = DeviceManager::new().await;

@@ -136,48 +129,22 @@ async fn app() -> anyhow::Result<()> {
    })?;
    lua.globals().set("print", print)?;

-    let mqtt = lua.create_table()?;
-    let event_channel = device_manager.event_channel();
-    let mqtt_new = lua.create_function(move |lua, config: mlua::Value| {
-        let config: MqttConfig = lua.from_value(config)?;
+    automation_lib::load_modules(&lua)?;

-        // Create a mqtt client
-        // TODO: When starting up, the devices are not yet created, this could lead to a device being out of sync
-        let (client, eventloop) = AsyncClient::new(config.into(), 100);
-        mqtt::start(eventloop, &event_channel);
+    lua.register_module("automation:variables", lua.to_value(&setup.variables)?)?;
+    lua.register_module("automation:secrets", lua.to_value(&setup.secrets)?)?;

-        Ok(WrappedAsyncClient(client))
-    })?;
-    mqtt.set("new", mqtt_new)?;
-    lua.register_module("mqtt", mqtt)?;
+    let entrypoint = Path::new(&setup.entrypoint);
+    let config: Config = lua.load(entrypoint).eval_async().await?;

-    lua.register_module("device_manager", device_manager.clone())?;
+    let mqtt_client = mqtt::start(config.mqtt, &device_manager.event_channel());

-    lua.register_module("variables", lua.to_value(&config.variables)?)?;
-    lua.register_module("secrets", lua.to_value(&config.secrets)?)?;
+    let resolved = config.modules.resolve(&lua, &mqtt_client).await?;
+    for device in resolved.devices {
+        device_manager.add(device).await;
+    }

-    let utils = lua.create_table()?;
-    let get_hostname = lua.create_function(|_lua, ()| {
-        hostname::get()
-            .map(|name| name.to_str().unwrap_or("unknown").to_owned())
-            .map_err(mlua::ExternalError::into_lua_err)
-    })?;
-    utils.set("get_hostname", get_hostname)?;
-    let get_epoch = lua.create_function(|_lua, ()| {
-        Ok(SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("Time is after UNIX EPOCH")
-            .as_millis())
-    })?;
-    utils.set("get_epoch", get_epoch)?;
-    lua.register_module("utils", utils)?;
-
-    automation_devices::register_with_lua(&lua)?;
-    helpers::register_with_lua(&lua)?;
-
-    let entrypoint = Path::new(&config.entrypoint);
-    let fulfillment_config: mlua::Value = lua.load(entrypoint).eval_async().await?;
-    let fulfillment_config: FulfillmentConfig = lua.from_value(fulfillment_config)?;
+    resolved.scheduler.start().await?;

    // Create google home fulfillment route
    let fulfillment = Router::new().route("/google_home", post(fulfillment));
@@ -186,12 +153,12 @@ async fn app() -> anyhow::Result<()> {
    let app = Router::new()
        .nest("/fulfillment", fulfillment)
        .with_state(AppState {
-            openid_url: fulfillment_config.openid_url.clone(),
+            openid_url: config.fulfillment.openid_url.clone(),
            device_manager,
        });

    // Start the web server
-    let addr: SocketAddr = fulfillment_config.into();
+    let addr: SocketAddr = config.fulfillment.into();
    info!("Server started on http://{addr}");
    let listener = TcpListener::bind(addr).await?;
    axum::serve(listener, app).await?;
--- a/src/bin/generate_definitions.rs
+++ b/src/bin/generate_definitions.rs
@@ -0,0 +1,45 @@
+use std::fs::{self, File};
+use std::io::Write;
+
+use automation::config::generate_definitions;
+use automation_lib::Module;
+use tracing::{info, warn};
+
+extern crate automation_devices;
+
+fn write_definitions(filename: &str, definitions: &str) -> std::io::Result<()> {
+    let definitions_directory =
+        std::path::Path::new(std::env!("CARGO_MANIFEST_DIR")).join("definitions");
+    fs::create_dir_all(&definitions_directory)?;
+
+    let mut file = File::create(definitions_directory.join(filename))?;
+
+    file.write_all(b"-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED\n")?;
+    file.write_all(definitions.as_bytes())?;
+
+    // Make sure we have a trailing new line
+    if !definitions.ends_with("\n") {
+        file.write_all(b"\n")?;
+    }
+
+    Ok(())
+}
+
+fn main() -> std::io::Result<()> {
+    tracing_subscriber::fmt::init();
+
+    for module in inventory::iter::<Module> {
+        if let Some(definitions) = module.definitions() {
+            info!(name = module.get_name(), "Generating definitions");
+
+            let filename = format!("{}.lua", module.get_name());
+            write_definitions(&filename, &definitions)?;
+        } else {
+            warn!(name = module.get_name(), "No definitions");
+        }
+    }
+
+    write_definitions("config.lua", &generate_definitions())?;
+
+    Ok(())
+}
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,9 +1,19 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
+use std::net::{Ipv4Addr, SocketAddr};
+use std::ops::Deref;

+use automation_lib::action_callback::ActionCallback;
+use automation_lib::device::Device;
+use automation_lib::mqtt::{MqttConfig, WrappedAsyncClient};
+use automation_macro::LuaDeviceConfig;
+use lua_typed::Typed;
+use mlua::FromLua;
 use serde::Deserialize;

+use crate::schedule::Scheduler;
+
 #[derive(Debug, Deserialize)]
-pub struct Config {
+pub struct Setup {
    #[serde(default = "default_entrypoint")]
    pub entrypoint: String,
    #[serde(default)]
@@ -13,5 +23,266 @@ pub struct Config {
 }

 fn default_entrypoint() -> String {
-    "./config.lua".into()
+    "./config/config.lua".into()
+}
+
+#[derive(Debug, Deserialize, Typed)]
+pub struct FulfillmentConfig {
+    pub openid_url: String,
+    #[serde(default = "default_fulfillment_ip")]
+    #[typed(default)]
+    pub ip: Ipv4Addr,
+    #[serde(default = "default_fulfillment_port")]
+    #[typed(default)]
+    pub port: u16,
+}
+
+#[derive(Debug)]
+struct SetupFunction(mlua::Function);
+
+impl Typed for SetupFunction {
+    fn type_name() -> String {
+        "SetupFunction".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        Some(format!(
+            "---@alias {} fun(mqtt_client: {}): {} | DeviceInterface[] | nil\n",
+            Self::type_name(),
+            WrappedAsyncClient::type_name(),
+            Module::type_name()
+        ))
+    }
+}
+
+impl FromLua for SetupFunction {
+    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
+        Ok(Self(FromLua::from_lua(value, lua)?))
+    }
+}
+
+impl Deref for SetupFunction {
+    type Target = mlua::Function;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Debug, Default)]
+struct Schedule(HashMap<String, ActionCallback<()>>);
+
+impl Typed for Schedule {
+    fn type_name() -> String {
+        "Schedule".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        Some(format!(
+            "---@alias {} {}\n",
+            Self::type_name(),
+            HashMap::<String, ActionCallback<()>>::type_name(),
+        ))
+    }
+}
+
+impl FromLua for Schedule {
+    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
+        Ok(Self(FromLua::from_lua(value, lua)?))
+    }
+}
+
+impl IntoIterator for Schedule {
+    type Item = <HashMap<String, ActionCallback<()>> as IntoIterator>::Item;
+
+    type IntoIter = <HashMap<String, ActionCallback<()>> as IntoIterator>::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[derive(Debug, Default)]
+struct Module {
+    setup: Option<SetupFunction>,
+    devices: Vec<Box<dyn Device>>,
+    schedule: Schedule,
+    modules: Vec<Module>,
+}
+
+// TODO: Add option to typed to rename field
+impl Typed for Module {
+    fn type_name() -> String {
+        "Module".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        Some(format!("---@class {}\n", Self::type_name()))
+    }
+
+    fn generate_members() -> Option<String> {
+        Some(format!(
+            r#"---@field setup {}
+---@field devices {}?
+---@field schedule {}?
+---@field [number] {}?
+"#,
+            Option::<SetupFunction>::type_name(),
+            Vec::<Box<dyn Device>>::type_name(),
+            Schedule::type_name(),
+            Vec::<Module>::type_name(),
+        ))
+    }
+
+    fn generate_footer() -> Option<String> {
+        let type_name = <Self as Typed>::type_name();
+        Some(format!("local {type_name}\n"))
+    }
+}
+
+impl FromLua for Module {
+    fn from_lua(value: mlua::Value, _lua: &mlua::Lua) -> mlua::Result<Self> {
+        // When calling require it might return a result from the searcher indicating how the
+        // module was found, we want to ignore these entries.
+        // TODO: Find a better solution for this
+        if value.is_string() {
+            return Ok(Default::default());
+        }
+
+        let mlua::Value::Table(table) = value else {
+            return Err(mlua::Error::runtime(format!(
+                "Expected module table, instead found: {}",
+                value.type_name()
+            )));
+        };
+
+        let setup = table.get("setup")?;
+        let devices = table.get("devices").unwrap_or_default();
+        let schedule = table.get("schedule").unwrap_or_default();
+
+        let mut modules = Vec::new();
+
+        for module in table.sequence_values::<Module>() {
+            modules.push(module?);
+        }
+
+        Ok(Module {
+            setup,
+            devices,
+            schedule,
+            modules,
+        })
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Modules(Vec<Module>);
+
+impl Typed for Modules {
+    fn type_name() -> String {
+        Vec::<Module>::type_name()
+    }
+}
+
+impl FromLua for Modules {
+    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
+        Ok(Self(FromLua::from_lua(value, lua)?))
+    }
+}
+
+impl Modules {
+    pub async fn resolve(
+        self,
+        lua: &mlua::Lua,
+        client: &WrappedAsyncClient,
+    ) -> mlua::Result<Resolved> {
+        let mut devices = Vec::new();
+        let mut scheduler = Scheduler::default();
+
+        let mut modules: VecDeque<_> = self.0.into();
+        loop {
+            let Some(module) = modules.pop_front() else {
+                break;
+            };
+
+            modules.extend(module.modules);
+
+            if let Some(setup) = module.setup {
+                let result: mlua::Value = setup.call_async(client.clone()).await?;
+
+                if result.is_nil() {
+                    // We ignore nil results
+                } else if let Ok(d) = <Vec<_> as FromLua>::from_lua(result.clone(), lua)
+                    && !d.is_empty()
+                {
+                    // This is a shortcut for the common pattern of setup functions that only
+                    // return devices
+                    devices.extend(d);
+                } else if let Ok(module) = FromLua::from_lua(result.clone(), lua) {
+                    modules.push_back(module);
+                } else {
+                    return Err(mlua::Error::runtime(
+                        "Setup function returned data in an unexpected format",
+                    ));
+                }
+            }
+
+            devices.extend(module.devices);
+            for (cron, f) in module.schedule {
+                scheduler.add_job(cron, f);
+            }
+        }
+
+        Ok(Resolved { devices, scheduler })
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Resolved {
+    pub devices: Vec<Box<dyn Device>>,
+    pub scheduler: Scheduler,
+}
+
+#[derive(Debug, LuaDeviceConfig, Typed)]
+pub struct Config {
+    pub fulfillment: FulfillmentConfig,
+    #[device_config(from_lua, default)]
+    pub modules: Modules,
+    #[device_config(from_lua)]
+    pub mqtt: MqttConfig,
+}
+
+impl From<FulfillmentConfig> for SocketAddr {
+    fn from(fulfillment: FulfillmentConfig) -> Self {
+        (fulfillment.ip, fulfillment.port).into()
+    }
+}
+fn default_fulfillment_ip() -> Ipv4Addr {
+    [0, 0, 0, 0].into()
+}
+
+fn default_fulfillment_port() -> u16 {
+    7878
+}
+
+pub fn generate_definitions() -> String {
+    let mut output = "---@meta\n\n".to_string();
+
+    output +=
+        &FulfillmentConfig::generate_full().expect("FulfillmentConfig should have a definition");
+    output += "\n";
+    output += &Config::generate_full().expect("Config should have a definition");
+    output += "\n";
+    output += &SetupFunction::generate_full().expect("SetupFunction should have a definition");
+    output += "\n";
+    output += &Schedule::generate_full().expect("Schedule should have a definition");
+    output += "\n";
+    output += &Module::generate_full().expect("Module should have a definition");
+    output += "\n";
+    output += &MqttConfig::generate_full().expect("MqttConfig should have a definition");
+    output += "\n";
+    output +=
+        &WrappedAsyncClient::generate_full().expect("WrappedAsyncClient should have a definition");
+
+    output
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -0,0 +1,7 @@
+#![feature(if_let_guard)]
+
+pub mod config;
+pub mod schedule;
+pub mod secret;
+pub mod version;
+pub mod web;
--- a/src/schedule.rs
+++ b/src/schedule.rs
@@ -0,0 +1,37 @@
+use std::pin::Pin;
+
+use automation_lib::action_callback::ActionCallback;
+use tokio_cron_scheduler::{Job, JobScheduler, JobSchedulerError};
+
+#[derive(Debug, Default)]
+pub struct Scheduler {
+    jobs: Vec<(String, ActionCallback<()>)>,
+}
+
+impl Scheduler {
+    pub fn add_job(&mut self, cron: String, f: ActionCallback<()>) {
+        self.jobs.push((cron, f));
+    }
+
+    pub async fn start(self) -> Result<(), JobSchedulerError> {
+        let scheduler = JobScheduler::new().await?;
+
+        for (s, f) in self.jobs {
+            let job = {
+                move |_uuid, _lock| -> Pin<Box<dyn Future<Output = ()> + Send>> {
+                    let f = f.clone();
+
+                    Box::pin(async move {
+                        f.call(()).await;
+                    })
+                }
+            };
+
+            let job = Job::new_async(s, job)?;
+
+            scheduler.add(job).await?;
+        }
+
+        scheduler.start().await
+    }
+}
--- a/src/version.rs
+++ b/src/version.rs
@@ -0,0 +1,11 @@
+pub const VERSION: &str = get_version();
+
+const fn get_version() -> &'static str {
+    if let Some(version) = std::option_env!("RELEASE_VERSION")
+        && !version.is_empty()
+    {
+        version
+    } else {
+        git_version::git_version!(fallback = "unknown")
+    }
+}
Author	SHA1	Message	Date
Dreaded_X	ad158f2c22	feat: Reduced visibility of config structs All checks were successful Build and deploy / build (push) Successful in 9m0s Details Build and deploy / Deploy container (push) Successful in 49s Details	2025-10-22 04:13:54 +02:00
Dreaded_X	f36adf2f19	feat: Implement useful traits to simplify code	2025-10-22 04:09:01 +02:00
Dreaded_X	5947098bfb	chore: Fix config type annotations All checks were successful Build and deploy / build (push) Successful in 12m30s Details Build and deploy / Deploy container (push) Has been skipped Details	2025-10-22 03:59:59 +02:00
Dreaded_X	8a3143a3ea	feat: Added type alias for setup and schedule types	2025-10-22 03:59:40 +02:00
Dreaded_X	9546585440	feat(config)!: Made schedule part of new modules All checks were successful Build and deploy / build (push) Successful in 11m57s Details Build and deploy / Deploy container (push) Has been skipped Details	2025-10-22 03:24:34 +02:00
Dreaded_X	a938f3d71b	feat(config)!: Improve config module resolution All checks were successful Build and deploy / build (push) Successful in 11m31s Details Build and deploy / Deploy container (push) Has been skipped Details The new system is slightly less flexible, but the code and lua definitions is now a lot simpler and easier to understand. In fact the old lua definition was not actually correct. It is likely that existing configs require not/minimal tweaks to work again.	2025-10-22 03:09:15 +02:00
Dreaded_X	a6c19eb9b4	fix: Fix issues with inner type definitions	2025-10-22 02:59:21 +02:00
Dreaded_X	7db628709a	refactor: Split config All checks were successful Build and deploy / build (push) Successful in 10m56s Details Build and deploy / Deploy container (push) Has been skipped Details	2025-10-20 05:02:19 +02:00
Dreaded_X	bc75f7005c	feat(config)!: Device creation function is now named entry It now has to be called 'setup', this makes it possible to just include the table as a whole in devices and it will automatically call the correct function.	2025-10-20 05:02:04 +02:00
Dreaded_X	2056c6c70d	feat(config)!: Changed default config location	2025-10-20 04:48:33 +02:00
Dreaded_X	2fe9fbadfb	feat(config)!: Remove device manager lua code With the recent changes the device manager no longer needs to be available in lua.	2025-10-20 04:48:33 +02:00
Dreaded_X	2db4af7427	feat(config)!: Config now returns the mqtt config instead of the client Instead the client is now created on the rust side based on the config. Devices that require the mqtt client will now instead need to be constructor using a function. This function receives the mqtt client.	2025-10-20 04:48:32 +02:00
Dreaded_X	7b7279017f	refactor: Restructured config to not rely on mqtt client being available In preparation of changes to the mqtt client the config is rewritten to use a device creation function for devices that need the mqtt client. This also fixes a but where hallway_top_light was not actually added to the device manager.	2025-10-20 04:48:29 +02:00
Dreaded_X	f05856cd0c	feat(config)!: In config devices can now also be a (table of) function(s) This function receives the mqtt client as an argument. In the future this will be the only way to create devices that require the mqtt client.	2025-10-20 04:48:28 +02:00
Dreaded_X	02b6cf12a1	feat: Improved device conversion error message	2025-10-20 04:48:28 +02:00
Dreaded_X	02b87126e1	feat: Use ActionCallback for schedule This has two advantages: - Each schedule entry can take either a single function or table of functions. - We get a better type definition.	2025-10-20 04:48:28 +02:00
Dreaded_X	1ffccd955c	refactor(config)!: Move scheduler out of device_manager Due to changes made in mlua the new scheduler is much simpler. It also had no real business being part of the device manager, so it has now been moved to be part of the returned config.	2025-10-20 04:48:28 +02:00
Dreaded_X	948380ea9b	feat: Receive devices through config return	2025-10-20 04:48:28 +02:00
Dreaded_X	0c80cef5a1	feat: Ensure consistent ordering device definitions	2025-10-20 04:48:28 +02:00
Dreaded_X	84e8942fc9	feat: Generate definitions for config	2025-10-20 04:48:27 +02:00
Dreaded_X	b557afe2fc	refactor: Move definition writing into separate function	2025-10-20 04:48:27 +02:00
Dreaded_X	5801421378	refactor: Move main.rs to bin/automation.rs	2025-10-20 04:48:22 +02:00
Dreaded_X	ba818c6b60	refactor(config)!: Setup for expanding lua config return Moves the application config out of automation_lib and sets up the config return type for further expansion.	2025-10-17 03:08:21 +02:00
Dreaded_X	a95574b731	feat: Added type annotations to config.lua All checks were successful Build and deploy / build (push) Successful in 9m16s Details Build and deploy / Deploy container (push) Successful in 3m12s Details In some instances this required some restructuring of the code to be able to properly add the annotations.	2025-10-15 04:24:08 +02:00
Dreaded_X	810fae8da5	chore: Reordered pre-commit hooks	2025-10-15 04:23:12 +02:00
Dreaded_X	6fc3783d7a	feat: Added lua definition files Also added a pre-commit hook to ensure that the definitions files are up-to-date.	2025-10-15 04:23:12 +02:00
Dreaded_X	df64804b00	feat: Add bin to automatically generate lua definitions	2025-10-15 04:01:15 +02:00
Dreaded_X	11b9787890	chore: Remove allow that is no longer required	2025-10-15 03:57:57 +02:00
Dreaded_X	8961101fdf	chore: Run main application by default	2025-10-15 03:57:02 +02:00
Dreaded_X	17a68e8991	feat: Added optional definition function to module	2025-10-15 03:53:55 +02:00
Dreaded_X	be1602d0e2	feat(config)!: Move mqtt module to actual separate module The automation:mqtt module now gets loaded in a similar way as the automation:devices and automation:utils modules. This leads to a breaking change where instantiating a new mqtt client the device manager needs to be explicitly passed in.	2025-10-15 03:53:55 +02:00
Dreaded_X	9bddeae54e	feat: Use Typed::type_name for Timeout proxy name	2025-10-15 03:53:06 +02:00
Dreaded_X	97b944874a	feat: Added/expanded Typed impls	2025-10-15 03:50:50 +02:00
Dreaded_X	54164c517b	feat: Remove automatic automation: module prefix Instead the prefix should be manually specified if it is desired.	2025-10-15 03:50:36 +02:00
Dreaded_X	518abd169d	chore: Removed dotenvy Since secrets can now be set from automation.toml the .env file was no longer used, so dotenvy can be removed.	2025-10-15 03:44:17 +02:00
Dreaded_X	30ea9b2737	feat: Use Typed type_name for registering proxy	2025-10-15 03:44:17 +02:00
Dreaded_X	cd470cadaf	feat!: Expanded add_methods to extra_user_data Instead of being a function it now expects a struct with the PartialUserData trait implemented. This in part ensures the correct function signature. It also adds another optional function to PartialUserData that returns definitions for the added methods.	2025-10-15 03:44:17 +02:00
Dreaded_X	4b76bde2a6	feat: Specify (optional) interface name in PartialUserData	2025-10-15 03:44:17 +02:00
Dreaded_X	006a561307	feat: Use PartialUserData on proxy type to add trait methods	2025-10-15 03:44:17 +02:00
Dreaded_X	745a1025bb	feat!: Improved attribute parsing in device macro	2025-10-15 03:44:13 +02:00
Dreaded_X	45485fca37	feat: Add proper type definition for devices Depending on the implemented traits the lua class will inherit from the associated interface class. It also specifies the constructor function for each of the devices.	2025-10-15 00:45:37 +02:00
Dreaded_X	1532958a86	feat: Added Typed impl for all automation devices To accomplish this a basic implementation was also provided for some types in automation_lib	2025-10-15 00:45:37 +02:00
Dreaded_X	76eb63cd97	feat: Use same add_methods mechanic for Device as for other traits All checks were successful Build and deploy / build (push) Successful in 9m57s Details Build and deploy / Deploy container (push) Has been skipped Details	2025-10-10 03:33:28 +02:00
Dreaded_X	b784cfed4a	feat: Notify when windows are left open when leaving All checks were successful Build and deploy / build (push) Successful in 15m2s Details Build and deploy / Deploy container (push) Successful in 2m8s Details	2025-10-10 01:12:58 +02:00
Dreaded_X	06b3154733	feat!: Use type alias instead of generic parameters in device macro All checks were successful Build and deploy / build (push) Successful in 10m11s Details Build and deploy / Deploy container (push) Successful in 2m8s Details This enforced the idea that all generics must be specified for the type when using the device macro. It will also come into play later when the Typed macro gets introduced, as the name will be used when generating definitions.	2025-09-17 00:35:30 +02:00
Dreaded_X	580a5187bd	feat!: Made ntfy notification title required All checks were successful Build and deploy / build (push) Successful in 12m26s Details Build and deploy / Deploy container (push) Successful in 43s Details	2025-09-13 04:04:51 +02:00
Dreaded_X	8982e9c165	feat(config)!: Put automation modules in namespace All checks were successful Build and deploy / build (push) Successful in 13m33s Details Build and deploy / Deploy container (push) Successful in 39s Details All lua modules that originate from automation_rs are now prefixed with `automation:`.	2025-09-11 04:12:15 +02:00
Dreaded_X	4e28ad0f85	feat!: Improve device type registration All checks were successful Build and deploy / build (push) Successful in 10m37s Details Build and deploy / Deploy container (push) Successful in 38s Details Instead of one function that contains all the device types available in `automation_devices` a global registry is used were each device can register itself.	2025-09-10 03:02:05 +02:00
Dreaded_X	f0e4c9dd21	chore!: Remove unused notification setters Since the creation of notifications has moved entirely to lua these setters were not being used anymore.	2025-09-10 02:56:56 +02:00
Dreaded_X	5271e5ad81	refactor(config)!: Moved Timeout into utils module and moved module All checks were successful Build and deploy / build (push) Successful in 10m43s Details Build and deploy / Deploy container (push) Successful in 39s Details The module is now setup in automation_lib::lua::utils.	2025-09-10 02:11:11 +02:00
Dreaded_X	1d28b43264	refactor: Move module load code into separate function	2025-09-10 02:11:11 +02:00
Dreaded_X	da04fad520	refactor(config)!: Move device proxies into module Instead of registering the device proxies in the global namespace they are now registered in a module called `devices`.	2025-09-10 02:11:09 +02:00
Dreaded_X	84e4b30b6a	feat!: Improve lua module registration Instead of having to call all the module registration functions in one place it is possible for each module to register itself in a global registry. During startup all the all the modules will be registered automatically. This does currently have one weakness, to need to ensure that the crate is linked.	2025-09-10 02:10:45 +02:00
Dreaded_X	95a8a377e8	feat!: Removed AddAdditionalMethods It has been replaced with the add_methods device attribute.	2025-09-10 01:58:48 +02:00
Dreaded_X	23355190ca	feat: Added attribute to easily register additional lua methods Previously this could only be done by implementing a trait, like `AddAdditionalMethods`, that that has an add_methods function where you can put your custom methods. With this new attribute you can pass in a register function directly!	2025-09-10 01:58:48 +02:00
Dreaded_X	2dbd491b81	refactor!: Rewrote device implementation macro once again This time with a bit more though put into the design of the code, as a result the macro should be a lot more robust. This did result in the macro getting renamed from LuaDevice to Device as this should be _the_ Device macro. The attribute also got renamed from traits() to device(traits()) and the syntax got overhauled to allow for a bit more expression.	2025-09-10 01:58:48 +02:00
Dreaded_X	aad089aa10	chore: Removed old leftover contact sensor presence config	2025-09-10 01:46:16 +02:00
Dreaded_X	18e40726fe	refactor: Remove unneeded wrapper functions when specifying callbacks These wrappers can be moved up to where the callback itself is defined instead of having to wrap the call manually. This also works a lot nicer now that it is possible to provide multiple callback functions.	2025-09-10 01:46:16 +02:00
Dreaded_X	1925bac73c	fix: Front door presence does not get cleared properly	2025-09-10 01:46:16 +02:00
Dreaded_X	5383e7265d	feat!: ActionCallback can now receive any amount of arguments ActionCallback now only has one generics argument that has to implement IntoLuaMulti, this makes ActionCallback much more flexible as it no longer always requires two arguments.	2025-09-10 01:46:12 +02:00
Dreaded_X	352654107a	feat: Added derive macro to implement IntoLua on structs that implement Serialize This can be very useful if you want to convert a data struct to a lua table without having to write the boilerplane (however small it may be). It also adds the macro on several state structs so they can be converted to lua in the upcoming ActionCallback refactor.	2025-09-08 04:06:00 +02:00
Dreaded_X	3a7f2f9bd7	fix: IkeaRemote callback is missing default specifier	2025-09-08 04:05:43 +02:00
Dreaded_X	3be11b0c6a	feat: Allow for multiple callbacks inside of an ActionCallback This also results in the conversion being performed when the ActionCallback is instantiated instead of when it is called, this should make it easier to catch errors.	2025-09-08 04:02:47 +02:00
Dreaded_X	e880efe4cf	refactor: Store callback function directly instead of in the registry	2025-09-08 04:02:47 +02:00
Dreaded_X	e2fb680cd6	feat: Log version string during startup	2025-09-08 04:02:40 +02:00