validate and generate lexicons with pkl

README.md

···
 To generate typescript from lexicons:
 
 ```bash
+bun run pkl:gen
 bun run lexgen
 ```
 

bun.lock

···
         "@atproto/sync": "^0.1.20",
         "@atproto/syntax": "^0.4.0",
         "@atproto/xrpc-server": "^0.7.15",
+        "@pkl-community/pkl": "^0.28.2",
+        "tsx": "^4.20.3",
+        "zx": "^8.5.5",
       },
       "devDependencies": {
         "@types/bun": "latest",
···
 
     "@cbor-extract/cbor-extract-win32-x64": ["@cbor-extract/cbor-extract-win32-x64@2.2.0", "", { "os": "win32", "cpu": "x64" }, "sha512-l2M+Z8DO2vbvADOBNLbbh9y5ST1RY5sqkWOg/58GkUPBYou/cuNZ68SGQ644f1CvZ8kcOxyZtw06+dxWHIoN/w=="],
 
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.5", "", { "os": "aix", "cpu": "ppc64" }, "sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.5", "", { "os": "android", "cpu": "arm" }, "sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.5", "", { "os": "android", "cpu": "arm64" }, "sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.5", "", { "os": "android", "cpu": "x64" }, "sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.5", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.5", "", { "os": "linux", "cpu": "arm" }, "sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.5", "", { "os": "linux", "cpu": "ia32" }, "sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.5", "", { "os": "linux", "cpu": "none" }, "sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.5", "", { "os": "linux", "cpu": "none" }, "sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.5", "", { "os": "linux", "cpu": "none" }, "sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.5", "", { "os": "linux", "cpu": "x64" }, "sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.5", "", { "os": "none", "cpu": "arm64" }, "sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.5", "", { "os": "none", "cpu": "x64" }, "sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.5", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.5", "", { "os": "openbsd", "cpu": "x64" }, "sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.5", "", { "os": "sunos", "cpu": "x64" }, "sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.5", "", { "os": "win32", "cpu": "x64" }, "sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g=="],
+
     "@ipld/dag-cbor": ["@ipld/dag-cbor@7.0.3", "", { "dependencies": { "cborg": "^1.6.0", "multiformats": "^9.5.4" } }, "sha512-1VVh2huHsuohdXC1bGJNE8WR72slZ9XE2T3wbBBq31dm7ZBatmKLLxrB+XAqafxfRFjv08RZmj/W/ZqaM13AuA=="],
 
     "@noble/curves": ["@noble/curves@1.9.0", "", { "dependencies": { "@noble/hashes": "1.8.0" } }, "sha512-7YDlXiNMdO1YZeH6t/kvopHHbIZzlxrCV9WLqCY6QhcXOoXiNCMDqJIglZ9Yjx5+w7Dz30TITFrlTjnRg7sKEg=="],
 
     "@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="],
 
+    "@pkl-community/pkl": ["@pkl-community/pkl@0.28.2", "", { "optionalDependencies": { "@pkl-community/pkl-darwin-arm64": "0.28.2", "@pkl-community/pkl-darwin-x64": "0.28.2", "@pkl-community/pkl-linux-arm64": "0.28.2", "@pkl-community/pkl-linux-x64": "0.28.2" }, "bin": { "pkl": "lib/main.js" } }, "sha512-seSZrwGvDEd1BeT9+dRRnqvyNit8vpFL2I+YBEJ+t3pBYpnpHaVHwQNPlMLvDQ0KZUCQkiWGZnbCMF9WtaxHNA=="],
+
+    "@pkl-community/pkl-darwin-arm64": ["@pkl-community/pkl-darwin-arm64@0.28.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-1CP5VayKnZeL1BUTaQUltiBu5wbn/pNizP3aSK1zbWMHDGK/S/rIs1X0GWEyOHWG7P/h9EBsNzHmJqg4kCn5jw=="],
+
+    "@pkl-community/pkl-darwin-x64": ["@pkl-community/pkl-darwin-x64@0.28.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-gGV3S9Hnyclga3/8wvspXWxKKEPMJrWzgeafIPpFPDa49DDlPCrf4zNkN0T29yylWd4aLwMUGRE15vswkjhdjA=="],
+
+    "@pkl-community/pkl-linux-arm64": ["@pkl-community/pkl-linux-arm64@0.28.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-IGJDm0maESl7Q+x2XukC7ia39m7Z++/C92cknrvTtyNdEROufGDobUv96ekq4e1gdcEgDvvDqCXLEQNC871Trg=="],
+
+    "@pkl-community/pkl-linux-x64": ["@pkl-community/pkl-linux-x64@0.28.2", "", { "os": "linux", "cpu": "x64" }, "sha512-9MndyTuiRhBRdrDqgcNadi6mT8mCNcLChwh28D5t5EDko8maUDTKHwHeuIzdBI5P0ZLNYPnT4McPufkeBu67vQ=="],
+
     "@ts-morph/common": ["@ts-morph/common@0.25.0", "", { "dependencies": { "minimatch": "^9.0.4", "path-browserify": "^1.0.1", "tinyglobby": "^0.2.9" } }, "sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg=="],
 
     "@types/bun": ["@types/bun@1.2.10", "", { "dependencies": { "bun-types": "1.2.10" } }, "sha512-eilv6WFM3M0c9ztJt7/g80BDusK98z/FrFwseZgT4bXCq2vPhXD4z8R3oddmAn+R/Nmz9vBn4kweJKmGTZj+lg=="],
···
 
     "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
 
+    "esbuild": ["esbuild@0.25.5", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.5", "@esbuild/android-arm": "0.25.5", "@esbuild/android-arm64": "0.25.5", "@esbuild/android-x64": "0.25.5", "@esbuild/darwin-arm64": "0.25.5", "@esbuild/darwin-x64": "0.25.5", "@esbuild/freebsd-arm64": "0.25.5", "@esbuild/freebsd-x64": "0.25.5", "@esbuild/linux-arm": "0.25.5", "@esbuild/linux-arm64": "0.25.5", "@esbuild/linux-ia32": "0.25.5", "@esbuild/linux-loong64": "0.25.5", "@esbuild/linux-mips64el": "0.25.5", "@esbuild/linux-ppc64": "0.25.5", "@esbuild/linux-riscv64": "0.25.5", "@esbuild/linux-s390x": "0.25.5", "@esbuild/linux-x64": "0.25.5", "@esbuild/netbsd-arm64": "0.25.5", "@esbuild/netbsd-x64": "0.25.5", "@esbuild/openbsd-arm64": "0.25.5", "@esbuild/openbsd-x64": "0.25.5", "@esbuild/sunos-x64": "0.25.5", "@esbuild/win32-arm64": "0.25.5", "@esbuild/win32-ia32": "0.25.5", "@esbuild/win32-x64": "0.25.5" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ=="],
+
     "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="],
 
     "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
···
 
     "fresh": ["fresh@0.5.2", "", {}, "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q=="],
 
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
     "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
 
     "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
 
     "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
+
+    "get-tsconfig": ["get-tsconfig@4.10.1", "", { "dependencies": { "resolve-pkg-maps": "^1.0.0" } }, "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ=="],
 
     "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
 
···
 
     "real-require": ["real-require@0.2.0", "", {}, "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg=="],
 
+    "resolve-pkg-maps": ["resolve-pkg-maps@1.0.0", "", {}, "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw=="],
+
     "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
 
     "safe-stable-stringify": ["safe-stable-stringify@2.5.0", "", {}, "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA=="],
···
 
     "ts-morph": ["ts-morph@24.0.0", "", { "dependencies": { "@ts-morph/common": "~0.25.0", "code-block-writer": "^13.0.3" } }, "sha512-2OAOg/Ob5yx9Et7ZX4CvTCc0UFoZHwLEJ+dpDPSUi5TgwwlTlX47w+iFRrEwzUZwYACjq83cgjS/Da50Ga37uw=="],
 
+    "tsx": ["tsx@4.20.3", "", { "dependencies": { "esbuild": "~0.25.0", "get-tsconfig": "^4.7.5" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "bin": { "tsx": "dist/cli.mjs" } }, "sha512-qjbnuR9Tr+FJOMBqJCW5ehvIo/buZq7vH7qD7JziU98h6l3qGy0a/yPFjwO+y0/T7GFpNgNAvEcPPVfyT8rrPQ=="],
+
     "type-is": ["type-is@1.6.18", "", { "dependencies": { "media-typer": "0.3.0", "mime-types": "~2.1.24" } }, "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g=="],
 
     "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
···
     "yesno": ["yesno@0.4.0", "", {}, "sha512-tdBxmHvbXPBKYIg81bMCB7bVeDmHkRzk5rVJyYYXurwKkHq/MCd8rz4HSJUP7hW0H2NlXiq8IFiWvYKEHhlotA=="],
 
     "zod": ["zod@3.24.3", "", {}, "sha512-HhY1oqzWCQWuUqvBFnsyrtZRhyPeR7SUGv+C4+MsisMuVfSPx8HpwWqH8tRahSlt6M3PiFAcoeFhZAqIXTxoSg=="],
+
+    "zx": ["zx@8.5.5", "", { "bin": { "zx": "build/cli.js" } }, "sha512-kzkjV3uqyEthw1IBDbA7Co2djji77vCP1DRvt58aYSMwiX4nyvAkFE8OBSEsOUbDJAst0Yo4asNvMTGG5HGPXA=="],
 
     "proxy-addr/ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],
 

lexicons/actor/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.defs",
+  "defs": {
+    "profileViewDetailed": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the actor."
+        },
+        "did": {
+          "type": "string",
+          "description": "The DID of the actor."
+        },
+        "handle": {
+          "type": "string",
+          "description": "The handle of the actor."
+        },
+        "displayName": {
+          "type": "string",
+          "description": "The display name of the actor."
+        },
+        "avatar": {
+          "type": "string",
+          "description": "The URL of the actor's avatar image.",
+          "format": "uri"
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the actor was created.",
+          "format": "datetime"
+        },
+        "updatedAt": {
+          "type": "string",
+          "description": "The date and time when the actor was last updated.",
+          "format": "datetime"
+        }
+      }
+    },
+    "profileViewBasic": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the actor."
+        },
+        "did": {
+          "type": "string",
+          "description": "The DID of the actor."
+        },
+        "handle": {
+          "type": "string",
+          "description": "The handle of the actor."
+        },
+        "displayName": {
+          "type": "string",
+          "description": "The display name of the actor."
+        },
+        "avatar": {
+          "type": "string",
+          "description": "The URL of the actor's avatar image.",
+          "format": "uri"
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the actor was created.",
+          "format": "datetime"
+        },
+        "updatedAt": {
+          "type": "string",
+          "description": "The date and time when the actor was last updated.",
+          "format": "datetime"
+        }
+      }
+    }
+  }
+}

lexicons/actor/getActorAlbums.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.getActorAlbums",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get albums for an actor",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of albums to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "albums": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.album.defs#albumViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/actor/getActorArtists.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.getActorArtists",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get artists for an actor",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of albums to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "artists": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.artist.defs#artistViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/actor/getActorLovedSongs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.getActorLovedSongs",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get loved songs for an actor",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of albums to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "tracks": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.song.defs#songViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/actor/getActorPlaylists.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.getActorPlaylists",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get playlists for an actor",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of albums to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "playlists": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.playlist.defs#playlistViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/actor/getActorScrobbles.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.getActorScrobbles",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get scrobbles for an actor",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of albums to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "scrobbles": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/actor/getActorSongs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.getActorSongs",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get songs for an actor",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of albums to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "songs": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.song.defs#songViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/actor/getProfile.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.actor.getProfile",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the profile of an actor",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.actor.defs#profileViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/actor/profile.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.actor.profile",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a Bluesky account profile.",
+      "key": "literal:self",
+      "record": {
+        "type": "object",
+        "properties": {
+          "displayName": {
+            "type": "string",
+            "maxGraphemes": 64,
+            "maxLength": 640
+          },
+          "description": {
+            "type": "string",
+            "description": "Free-form profile description text.",
+            "maxGraphemes": 256,
+            "maxLength": 2560
+          },
+          "avatar": {
+            "type": "blob",
+            "description": "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
+            "maxSize": 1000000
+          },
+          "banner": {
+            "type": "blob",
+            "description": "Larger horizontal image to display behind profile view.",
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
+            "maxSize": 10000000
+          },
+          "labels": {
+            "type": "union",
+            "description": "Self-label values, specific to the Bluesky application, on the overall account.",
+            "refs": [
+              "com.atproto.label.defs#selfLabels"
+            ]
+          },
+          "joinedViaStarterPack": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/album.json lexicons/album/album.json

···
   "defs": {
     "main": {
       "type": "record",
-      "key": "tid",
       "description": "A declaration of an album.",
+      "key": "tid",
       "record": {
         "type": "object",
         "required": [
···
           },
           "tidalLink": {
             "type": "string",
-            "description": "The Tidal link of the album.",
+            "description": "The tidal link of the album.",
             "format": "uri"
           },
           "appleMusicLink": {
···
           },
           "createdAt": {
             "type": "string",
-            "description": "The date the song was created.",
+            "description": "The date and time when the album was created.",
             "format": "datetime"
           }
         }
       }
     }
   }
-}
+}

lexicons/album/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.album.defs",
+  "defs": {
+    "albumViewBasic": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the album."
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the album.",
+          "format": "at-uri"
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the album."
+        },
+        "artist": {
+          "type": "string",
+          "description": "The artist of the album."
+        },
+        "artistUri": {
+          "type": "string",
+          "description": "The URI of the album's artist.",
+          "format": "at-uri"
+        },
+        "year": {
+          "type": "integer",
+          "description": "The year the album was released."
+        },
+        "albumArt": {
+          "type": "string",
+          "description": "The URL of the album art image.",
+          "format": "uri"
+        },
+        "releaseDate": {
+          "type": "string",
+          "description": "The release date of the album."
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the album."
+        },
+        "playCount": {
+          "type": "integer",
+          "description": "The number of times the album has been played.",
+          "minimum": 0
+        },
+        "uniqueListeners": {
+          "type": "integer",
+          "description": "The number of unique listeners who have played the album.",
+          "minimum": 0
+        }
+      }
+    },
+    "albumViewDetailed": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the album."
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the album.",
+          "format": "at-uri"
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the album."
+        },
+        "artist": {
+          "type": "string",
+          "description": "The artist of the album."
+        },
+        "artistUri": {
+          "type": "string",
+          "description": "The URI of the album's artist.",
+          "format": "at-uri"
+        },
+        "year": {
+          "type": "integer",
+          "description": "The year the album was released."
+        },
+        "albumArt": {
+          "type": "string",
+          "description": "The URL of the album art image.",
+          "format": "uri"
+        },
+        "releaseDate": {
+          "type": "string",
+          "description": "The release date of the album."
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the album."
+        },
+        "playCount": {
+          "type": "integer",
+          "description": "The number of times the album has been played.",
+          "minimum": 0
+        },
+        "uniqueListeners": {
+          "type": "integer",
+          "description": "The number of unique listeners who have played the album.",
+          "minimum": 0
+        },
+        "tracks": {
+          "type": "array",
+          "items": {
+            "type": "ref",
+            "ref": "app.rocksky.song.defs.songViewBasic"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/album/getAlbum.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.album.getAlbum",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get detailed album view",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the album to retrieve.",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.album.defs#albumViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/album/getAlbumTracks.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.album.getAlbumTracks",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get tracks for an album",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the album to retrieve tracks from",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "tracks": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.song.defs#songViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/album/getAlbums.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.album.getAlbums",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get albums",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of albums to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "albums": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.album.defs#albumViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/apikey/createApikey.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.apikey.createApikey",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new API key for the authenticated user",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "name"
+          ],
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "The name of the API key."
+            },
+            "description": {
+              "type": "string",
+              "description": "A description for the API key."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.apikey.defs#apiKey"
+        }
+      }
+    }
+  }
+}

lexicons/apikey/def.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.apikey.defs",
+  "defs": {
+    "apiKeyView": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the API key."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the API key."
+        },
+        "description": {
+          "type": "string",
+          "description": "A description for the API key."
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the API key was created.",
+          "format": "datetime"
+        }
+      }
+    }
+  }
+}

lexicons/apikey/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.apikeys.defs",
+  "defs": {}
+}

lexicons/apikey/getApikeys.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.apikey.getApikeys",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a list of API keys for the authenticated user",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "offset": {
+            "type": "integer",
+            "description": "The number of API keys to skip before starting to collect the result set."
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The number of API keys to return per page."
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "apiKeys": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.apikey.defs#apikeyView"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/apikey/removeApikey.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.apikey.removeApikey",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Remove an API key for the authenticated user",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "id"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "The ID of the API key to remove."
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.apikey.defs#apiKey"
+        }
+      }
+    }
+  }
+}

lexicons/apikey/updateApikey.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.apikey.updateApikey",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Update an existing API key for the authenticated user",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "id",
+            "name"
+          ],
+          "properties": {
+            "id": {
+              "type": "string",
+              "description": "The ID of the API key to update."
+            },
+            "name": {
+              "type": "string",
+              "description": "The new name of the API key."
+            },
+            "description": {
+              "type": "string",
+              "description": "A new description for the API key."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.apikey.defs#apiKey"
+        }
+      }
+    }
+  }
+}

lexicons/artist.json lexicons/artist/artist.json

···
   "defs": {
     "main": {
       "type": "record",
-      "key": "tid",
       "description": "A declaration of an artist.",
+      "key": "tid",
       "record": {
         "type": "object",
         "required": [
···
           },
           "createdAt": {
             "type": "string",
-            "description": "The date the song was created.",
+            "description": "The date when the artist was created.",
             "format": "datetime"
           }
         }
       }
     }
   }
-}
+}

lexicons/artist/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.artist.defs",
+  "defs": {
+    "artistViewBasic": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the artist."
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the artist.",
+          "format": "at-uri"
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the artist."
+        },
+        "picture": {
+          "type": "string",
+          "description": "The picture of the artist."
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the artist."
+        },
+        "playCount": {
+          "type": "integer",
+          "description": "The number of times the artist has been played.",
+          "minimum": 0
+        },
+        "uniqueListeners": {
+          "type": "integer",
+          "description": "The number of unique listeners who have played the artist.",
+          "minimum": 0
+        }
+      }
+    },
+    "artistViewDetailed": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the artist."
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the artist.",
+          "format": "at-uri"
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the artist."
+        },
+        "picture": {
+          "type": "string",
+          "description": "The picture of the artist."
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the artist."
+        },
+        "playCount": {
+          "type": "integer",
+          "description": "The number of times the artist has been played.",
+          "minimum": 0
+        },
+        "uniqueListeners": {
+          "type": "integer",
+          "description": "The number of unique listeners who have played the artist.",
+          "minimum": 0
+        }
+      }
+    }
+  }
+}

lexicons/artist/getArtist.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.artist.getArtist",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get artist details",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the artist to retrieve details from",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.artist.defs#artistViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/artist/getArtistAlbums.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.artist.getArtistAlbums",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get artist's albums",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the artist to retrieve albums from",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "albums": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.album.defs#albumViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/artist/getArtistTracks.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.artist.getArtistTracks",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get artist's tracks",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the artist to retrieve albums from",
+            "format": "at-uri"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of tracks to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "tracks": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.song.defs#songViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/artist/getArtists.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.artist.getArtists",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get artists",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of artists to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "artists": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.artist.defs#artistViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/charts/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.charts.defs",
+  "defs": {
+    "chartsView": {
+      "type": "object",
+      "properties": {
+        "scrobbles": {
+          "type": "array",
+          "items": {
+            "type": "ref",
+            "ref": "app.rocksky.charts.defs#scrobbleViewBasic"
+          }
+        }
+      }
+    },
+    "scrobbleViewBasic": {
+      "type": "object",
+      "properties": {
+        "date": {
+          "type": "string",
+          "description": "The date of the scrobble.",
+          "format": "datetime"
+        },
+        "count": {
+          "type": "integer",
+          "description": "The number of scrobbles on this date."
+        }
+      }
+    }
+  }
+}

lexicons/charts/getScrobblesChart.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.charts.getScrobblesChart",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the scrobbles chart",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "artisturi": {
+            "type": "string",
+            "description": "The URI of the artist to filter by",
+            "format": "at-uri"
+          },
+          "albumuri": {
+            "type": "string",
+            "description": "The URI of the album to filter by",
+            "format": "at-uri"
+          },
+          "songuri": {
+            "type": "string",
+            "description": "The URI of the track to filter by",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.charts.defs#chartsView"
+        }
+      }
+    }
+  }
+}

lexicons/dropbox/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.dropbox.defs",
+  "defs": {
+    "fileView": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the file."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the file."
+        },
+        "pathLower": {
+          "type": "string",
+          "description": "The lowercased path of the file."
+        },
+        "pathDisplay": {
+          "type": "string",
+          "description": "The display path of the file."
+        },
+        "clientModified": {
+          "type": "string",
+          "description": "The last modified date and time of the file on the client.",
+          "format": "datetime"
+        },
+        "serverModified": {
+          "type": "string",
+          "description": "The last modified date and time of the file on the server.",
+          "format": "datetime"
+        }
+      }
+    },
+    "fileListView": {
+      "type": "object",
+      "properties": {
+        "files": {
+          "type": "array",
+          "description": "A list of files in the Dropbox.",
+          "items": {
+            "type": "ref",
+            "ref": "app.rocksky.dropbox.defs#fileView"
+          }
+        }
+      }
+    },
+    "temporaryLinkView": {
+      "type": "object",
+      "properties": {
+        "link": {
+          "type": "string",
+          "description": "The temporary link to access the file.",
+          "format": "uri"
+        }
+      }
+    }
+  }
+}

lexicons/dropbox/downloadFile.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.dropbox.downloadFile",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Download a file from Dropbox by its unique identifier",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "fileId"
+        ],
+        "properties": {
+          "fileId": {
+            "type": "string",
+            "description": "The unique identifier of the file to download"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/octet-stream"
+      }
+    }
+  }
+}

lexicons/dropbox/getFiles.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.dropbox.getFiles",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Retrieve a list of files from Dropbox",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "at": {
+            "type": "string",
+            "description": "Path to the Dropbox folder or root directory"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.dropbox.defs#fileListView"
+        }
+      }
+    }
+  }
+}

lexicons/dropbox/getMetadata.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.dropbox.getMetadata",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Retrieve metadata of a file or folder in Dropbox",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "path"
+        ],
+        "properties": {
+          "path": {
+            "type": "string",
+            "description": "Path to the file or folder in Dropbox"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.dropbox.defs#fileView"
+        }
+      }
+    }
+  }
+}

lexicons/dropbox/getTemporaryLink.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.dropbox.getTemporaryLink",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Retrieve a temporary link to access a file in Dropbox",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "path"
+        ],
+        "properties": {
+          "path": {
+            "type": "string",
+            "description": "Path to the file in Dropbox"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.dropbox.defs#temporaryLinkView"
+        }
+      }
+    }
+  }
+}

lexicons/feed/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.feed.defs",
+  "defs": {
+    "searchResultsView": {
+      "type": "object",
+      "properties": {
+        "hits": {
+          "type": "array",
+          "items": {
+            "type": "union",
+            "refs": [
+              "app.rocksky.song.defs#songViewBasic",
+              "app.rocksky.album.defs#albumViewBasic",
+              "app.rocksky.artist.defs#artistViewBasic",
+              "app.rocksky.playlist.defs#playlistViewBasic",
+              "app.rocksky.actor.defs#profileViewBasic"
+            ]
+          }
+        },
+        "processingTimeMs": {
+          "type": "integer"
+        },
+        "limit": {
+          "type": "integer"
+        },
+        "offset": {
+          "type": "integer"
+        },
+        "estimatedTotalHits": {
+          "type": "integer"
+        }
+      }
+    },
+    "nowPlayingView": {
+      "type": "object",
+      "properties": {
+        "album": {
+          "type": "string"
+        },
+        "albumArt": {
+          "type": "string",
+          "format": "uri"
+        },
+        "albumArtist": {
+          "type": "string"
+        },
+        "albumUri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "artist": {
+          "type": "string"
+        },
+        "artistUri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "createdAt": {
+          "type": "string"
+        },
+        "did": {
+          "type": "string",
+          "format": "at-identifier"
+        },
+        "handle": {
+          "type": "string"
+        },
+        "id": {
+          "type": "string"
+        },
+        "title": {
+          "type": "string"
+        },
+        "trackId": {
+          "type": "string"
+        },
+        "trackUri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        }
+      }
+    },
+    "nowPlayingsView": {
+      "type": "object",
+      "properties": {
+        "nowPlayings": {
+          "type": "array",
+          "items": {
+            "type": "ref",
+            "ref": "app.rocksky.feed.defs#nowPlayingView"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/feed/getNowPlayings.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.feed.getNowPlayings",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get all currently playing tracks by users",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "size": {
+            "type": "integer",
+            "description": "The maximum number of now playing tracks to return.",
+            "minimum": 1
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.feed.defs#nowPlayingsView"
+        }
+      }
+    }
+  }
+}

lexicons/feed/search.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.feed.search",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Search for content in the feed",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "query"
+        ],
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "The search query string"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.feed.defs#searchResultsView"
+        }
+      }
+    }
+  }
+}

lexicons/googledrive/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.googledrive.defs",
+  "defs": {
+    "fileView": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the file."
+        }
+      }
+    },
+    "fileListView": {
+      "type": "object",
+      "properties": {
+        "files": {
+          "type": "array",
+          "items": {
+            "type": "ref",
+            "ref": "app.rocksky.googledrive.defs#fileView"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/googledrive/downloadFile.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.googledrive.downloadFile",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Download a file from Google Drive by its unique identifier",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "fileId"
+        ],
+        "properties": {
+          "fileId": {
+            "type": "string",
+            "description": "The unique identifier of the file to download"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/octet-stream"
+      }
+    }
+  }
+}

lexicons/googledrive/getFile.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.googledrive.getFile",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a file from Google Drive by its unique identifier",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "fileId"
+        ],
+        "properties": {
+          "fileId": {
+            "type": "string",
+            "description": "The unique identifier of the file to retrieve"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.googledrive.defs#fileView"
+        }
+      }
+    }
+  }
+}

lexicons/googledrive/getFiles.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.googledrive.getFiles",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a list of files from Google Drive",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "at": {
+            "type": "string",
+            "description": "Path to the Google Drive folder or root directory"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.googledrive.defs#fileListView"
+        }
+      }
+    }
+  }
+}

lexicons/like/dislikeShout.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.like.dislikeShout",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Dislike a shout",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "uri": {
+              "type": "string",
+              "description": "The unique identifier of the shout to dislike",
+              "format": "at-uri"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.shout.defs#shoutView"
+        }
+      }
+    }
+  }
+}

lexicons/like/dislikeSong.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.like.dislikeSong",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Dislike a song",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "uri": {
+              "type": "string",
+              "description": "The unique identifier of the song to dislike",
+              "format": "at-uri"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.song.defs#songViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/like/like.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.like",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a like.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "createdAt",
+          "subject"
+        ],
+        "properties": {
+          "createdAt": {
+            "type": "string",
+            "description": "The date when the like was created.",
+            "format": "datetime"
+          },
+          "subject": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/like/likeShout.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.like.likeShout",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Like a shout",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "uri": {
+              "type": "string",
+              "description": "The unique identifier of the shout to like",
+              "format": "at-uri"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.shout.defs#shoutView"
+        }
+      }
+    }
+  }
+}

lexicons/like/likeSong.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.like.likeSong",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Like a song",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "uri": {
+              "type": "string",
+              "description": "The unique identifier of the song to like",
+              "format": "at-uri"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.song.defs#songViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/player/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.player.defs",
+  "defs": {
+    "currentlyPlayingViewDetailed": {
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string",
+          "description": "The title of the currently playing track"
+        }
+      }
+    }
+  }
+}

lexicons/player/getCurrentlyPlaying.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.player.getCurrentlyPlaying",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the currently playing track",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "actor": {
+            "type": "string",
+            "description": "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.",
+            "format": "at-identifier"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.player.defs#currentlyPlayingViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/player/next.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.player.next",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Play the next track in the queue"
+    }
+  }
+}

lexicons/player/pause.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.player.pause",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Pause the currently playing track"
+    }
+  }
+}

lexicons/player/play.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.player.play",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Resume playback of the currently paused track"
+    }
+  }
+}

lexicons/player/previous.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.player.previous",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Play the previous track in the queue"
+    }
+  }
+}

lexicons/player/seek.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.player.seek",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Seek to a specific position in the currently playing track",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "position"
+        ],
+        "properties": {
+          "position": {
+            "type": "integer",
+            "description": "The position in seconds to seek to"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/playlist/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.playlist.defs",
+  "defs": {
+    "playlistViewDetailed": {
+      "type": "object",
+      "description": "Detailed view of a playlist, including its tracks and metadata",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the playlist."
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the playlist."
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the playlist.",
+          "format": "at-uri"
+        },
+        "curatorDid": {
+          "type": "string",
+          "description": "The DID of the curator of the playlist.",
+          "format": "at-identifier"
+        },
+        "curatorHandle": {
+          "type": "string",
+          "description": "The handle of the curator of the playlist.",
+          "format": "at-identifier"
+        },
+        "curatorName": {
+          "type": "string",
+          "description": "The name of the curator of the playlist."
+        },
+        "curatorAvatarUrl": {
+          "type": "string",
+          "description": "The URL of the avatar image of the curator.",
+          "format": "uri"
+        },
+        "description": {
+          "type": "string",
+          "description": "A description of the playlist."
+        },
+        "coverImageUrl": {
+          "type": "string",
+          "description": "The URL of the cover image for the playlist.",
+          "format": "uri"
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the playlist was created.",
+          "format": "datetime"
+        },
+        "tracks": {
+          "type": "array",
+          "description": "A list of tracks in the playlist.",
+          "items": {
+            "type": "ref",
+            "ref": "app.rocksky.song.defs#songViewBasic"
+          }
+        }
+      }
+    },
+    "playlistViewBasic": {
+      "type": "object",
+      "description": "Basic view of a playlist, including its metadata",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the playlist."
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the playlist."
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the playlist.",
+          "format": "at-uri"
+        },
+        "curatorDid": {
+          "type": "string",
+          "description": "The DID of the curator of the playlist.",
+          "format": "at-identifier"
+        },
+        "curatorHandle": {
+          "type": "string",
+          "description": "The handle of the curator of the playlist.",
+          "format": "at-identifier"
+        },
+        "curatorName": {
+          "type": "string",
+          "description": "The name of the curator of the playlist."
+        },
+        "curatorAvatarUrl": {
+          "type": "string",
+          "description": "The URL of the avatar image of the curator.",
+          "format": "uri"
+        },
+        "description": {
+          "type": "string",
+          "description": "A description of the playlist."
+        },
+        "coverImageUrl": {
+          "type": "string",
+          "description": "The URL of the cover image for the playlist.",
+          "format": "uri"
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the playlist was created.",
+          "format": "datetime"
+        },
+        "trackCount": {
+          "type": "integer",
+          "description": "The number of tracks in the playlist.",
+          "minimum": 0
+        }
+      }
+    }
+  }
+}

lexicons/playlist/getPlaylist.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.playlist.getPlaylist",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Retrieve a playlist by its ID",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the playlist to retrieve.",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.playlist.defs#playlistViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/playlist/getPlaylists.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.playlist.getPlaylists",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Retrieve a list of playlists",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of playlists to return."
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination, used to skip a number of playlists."
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "playlists": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.playlist.defs#playlistViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/playlist/playlist.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.playlist",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a playlist.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "name",
+          "createdAt"
+        ],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "The name of the playlist.",
+            "minLength": 1,
+            "maxLength": 512
+          },
+          "description": {
+            "type": "string",
+            "description": "The playlist description.",
+            "minLength": 1,
+            "maxLength": 256
+          },
+          "picture": {
+            "type": "blob",
+            "description": "The picture of the playlist.",
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
+            "maxSize": 2000000
+          },
+          "tracks": {
+            "type": "array",
+            "description": "The tracks in the playlist.",
+            "items": {
+              "type": "ref",
+              "ref": "app.rocksky.song#record"
+            }
+          },
+          "createdAt": {
+            "type": "string",
+            "description": "The date the playlist was created.",
+            "format": "datetime"
+          },
+          "spotifyLink": {
+            "type": "string",
+            "description": "The Spotify link of the playlist."
+          },
+          "tidalLink": {
+            "type": "string",
+            "description": "The Tidal link of the playlist."
+          },
+          "youtubeLink": {
+            "type": "string",
+            "description": "The YouTube link of the playlist."
+          },
+          "appleMusicLink": {
+            "type": "string",
+            "description": "The Apple Music link of the playlist."
+          }
+        }
+      }
+    }
+  }
+}

lexicons/radio/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.radio.defs",
+  "defs": {
+    "radioViewBasic": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the radio."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the radio."
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the radio."
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the radio was created.",
+          "format": "datetime"
+        }
+      }
+    },
+    "radioViewDetailed": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the radio."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the radio."
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the radio."
+        },
+        "website": {
+          "type": "string",
+          "description": "The website of the radio.",
+          "format": "uri"
+        },
+        "url": {
+          "type": "string",
+          "description": "The streaming URL of the radio.",
+          "format": "uri"
+        },
+        "genre": {
+          "type": "string",
+          "description": "The genre of the radio."
+        },
+        "logo": {
+          "type": "string",
+          "description": "The logo of the radio station."
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the radio was created.",
+          "format": "datetime"
+        }
+      }
+    }
+  }
+}

lexicons/radio/radio.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.radio",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a radio station.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "name",
+          "url",
+          "createdAt"
+        ],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "The name of the radio station.",
+            "minLength": 1,
+            "maxLength": 512
+          },
+          "url": {
+            "type": "string",
+            "description": "The URL of the radio station.",
+            "format": "uri"
+          },
+          "description": {
+            "type": "string",
+            "description": "A description of the radio station.",
+            "minLength": 1,
+            "maxLength": 1000
+          },
+          "genre": {
+            "type": "string",
+            "description": "The genre of the radio station.",
+            "minLength": 1,
+            "maxLength": 256
+          },
+          "logo": {
+            "type": "blob",
+            "description": "The logo of the radio station.",
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
+            "maxSize": 2000000
+          },
+          "website": {
+            "type": "string",
+            "description": "The website of the radio station.",
+            "format": "uri"
+          },
+          "createdAt": {
+            "type": "string",
+            "description": "The date when the radio station was created.",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/scrobble.json lexicons/scrobble/scrobble.json

···
   "defs": {
     "main": {
       "type": "record",
-      "key": "tid",
       "description": "A declaration of a scrobble.",
+      "key": "tid",
       "record": {
         "type": "object",
         "required": [
           "title",
           "artist",
+          "album",
           "albumArtist",
-          "album",
           "duration",
           "createdAt"
         ],
         "properties": {
-          "trackNumber": {
-            "type": "integer",
-            "description": "The track number of the song in the album.",
-            "minimum": 1
-          },
-          "discNumber": {
-            "type": "integer",
-            "description": "The disc number of the song in the album.",
-            "minimum": 1
-          },
           "title": {
             "type": "string",
             "description": "The title of the song.",
···
           },
           "albumArtist": {
             "type": "string",
-            "description": "The artist of the album the song is from.",
+            "description": "The album artist of the song.",
             "minLength": 1,
             "maxLength": 256
           },
           "album": {
             "type": "string",
-            "description": "The album the song is from.",
+            "description": "The album of the song.",
             "minLength": 1,
             "maxLength": 256
           },
···
             "description": "The duration of the song in seconds.",
             "minimum": 1
           },
+          "trackNumber": {
+            "type": "integer",
+            "description": "The track number of the song in the album.",
+            "minimum": 1
+          },
+          "discNumber": {
+            "type": "integer",
+            "description": "The disc number of the song in the album.",
+            "minimum": 1
+          },
           "releaseDate": {
             "type": "string",
             "description": "The release date of the song.",
···
           },
           "copyrightMessage": {
             "type": "string",
-            "description": "The copyright message.",
+            "description": "The copyright message of the song.",
             "maxLength": 256
           },
           "wiki": {
···
           },
           "createdAt": {
             "type": "string",
-            "description": "The date the song was created.",
+            "description": "The date when the song was created.",
             "format": "datetime"
           },
           "mbid": {
···
       }
     }
   }
-}
+}

lexicons/scrobble/createScrobble.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.scrobble.createScrobble",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new scrobble",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "title",
+            "artist"
+          ],
+          "properties": {
+            "title": {
+              "type": "string",
+              "description": "The title of the track being scrobbled"
+            },
+            "artist": {
+              "type": "string",
+              "description": "The artist of the track being scrobbled"
+            },
+            "album": {
+              "type": "string",
+              "description": "The album of the track being scrobbled"
+            },
+            "duration": {
+              "type": "integer",
+              "description": "The duration of the track in seconds"
+            },
+            "mbId": {
+              "type": "string",
+              "description": "The MusicBrainz ID of the track, if available"
+            },
+            "albumArt": {
+              "type": "string",
+              "description": "The URL of the album art for the track",
+              "format": "uri"
+            },
+            "trackNumber": {
+              "type": "integer",
+              "description": "The track number of the track in the album"
+            },
+            "releaseDate": {
+              "type": "string",
+              "description": "The release date of the track, formatted as YYYY-MM-DD"
+            },
+            "year": {
+              "type": "integer",
+              "description": "The year the track was released"
+            },
+            "discNumber": {
+              "type": "integer",
+              "description": "The disc number of the track in the album, if applicable"
+            },
+            "lyrics": {
+              "type": "string",
+              "description": "The lyrics of the track, if available"
+            },
+            "composer": {
+              "type": "string",
+              "description": "The composer of the track, if available"
+            },
+            "copyrightMessage": {
+              "type": "string",
+              "description": "The copyright message for the track, if available"
+            },
+            "label": {
+              "type": "string",
+              "description": "The record label of the track, if available"
+            },
+            "artistPicture": {
+              "type": "string",
+              "description": "The URL of the artist's picture, if available",
+              "format": "uri"
+            },
+            "spotifyLink": {
+              "type": "string",
+              "description": "The Spotify link for the track, if available",
+              "format": "uri"
+            },
+            "lastfmLink": {
+              "type": "string",
+              "description": "The Last.fm link for the track, if available",
+              "format": "uri"
+            },
+            "tidalLink": {
+              "type": "string",
+              "description": "The Tidal link for the track, if available",
+              "format": "uri"
+            },
+            "appleMusicLink": {
+              "type": "string",
+              "description": "The Apple Music link for the track, if available",
+              "format": "uri"
+            },
+            "youtubeLink": {
+              "type": "string",
+              "description": "The Youtube link for the track, if available",
+              "format": "uri"
+            },
+            "deezerLink": {
+              "type": "string",
+              "description": "The Deezer link for the track, if available",
+              "format": "uri"
+            },
+            "timestamp": {
+              "type": "integer",
+              "description": "The timestamp of the scrobble in milliseconds since epoch"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"
+        }
+      }
+    }
+  }
+}

lexicons/scrobble/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.scrobble.defs",
+  "defs": {
+    "scrobbleViewBasic": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the scrobble."
+        },
+        "user": {
+          "type": "string",
+          "description": "The handle of the user who created the scrobble."
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the scrobble."
+        },
+        "artist": {
+          "type": "string",
+          "description": "The artist of the song."
+        },
+        "artistUri": {
+          "type": "string",
+          "description": "The URI of the artist.",
+          "format": "at-uri"
+        },
+        "album": {
+          "type": "string",
+          "description": "The album of the song."
+        },
+        "albumUri": {
+          "type": "string",
+          "description": "The URI of the album.",
+          "format": "at-uri"
+        },
+        "cover": {
+          "type": "string",
+          "description": "The album art URL of the song.",
+          "format": "uri"
+        },
+        "date": {
+          "type": "string",
+          "description": "The timestamp when the scrobble was created.",
+          "format": "datetime"
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the scrobble.",
+          "format": "uri"
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the scrobble data."
+        }
+      }
+    },
+    "scrobbleViewDetailed": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the scrobble."
+        },
+        "user": {
+          "type": "string",
+          "description": "The handle of the user who created the scrobble."
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the scrobble."
+        },
+        "artist": {
+          "type": "string",
+          "description": "The artist of the song."
+        },
+        "artistUri": {
+          "type": "string",
+          "description": "The URI of the artist.",
+          "format": "at-uri"
+        },
+        "album": {
+          "type": "string",
+          "description": "The album of the song."
+        },
+        "albumUri": {
+          "type": "string",
+          "description": "The URI of the album.",
+          "format": "at-uri"
+        },
+        "cover": {
+          "type": "string",
+          "description": "The album art URL of the song.",
+          "format": "uri"
+        },
+        "date": {
+          "type": "string",
+          "description": "The timestamp when the scrobble was created.",
+          "format": "datetime"
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the scrobble.",
+          "format": "uri"
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the scrobble data."
+        },
+        "listeners": {
+          "type": "integer",
+          "description": "The number of listeners"
+        },
+        "scrobbles": {
+          "type": "integer",
+          "description": "The number of scrobbles for this song"
+        }
+      }
+    }
+  }
+}

lexicons/scrobble/getScrobble.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.scrobble.getScrobble",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a scrobble by its unique identifier",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The unique identifier of the scrobble",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.scrobble.defs#scrobbleViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/scrobble/getScrobbles.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.scrobble.getScrobbles",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get scrobbles all scrobbles",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of scrobbles to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "scrobbles": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/shout/createShout.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.createShout",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new shout",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "message": {
+              "type": "string",
+              "description": "The content of the shout",
+              "minLength": 1
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.shout.defs#shoutView"
+        }
+      }
+    }
+  }
+}

lexicons/shout/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.defs",
+  "defs": {
+    "author": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the author."
+        },
+        "did": {
+          "type": "string",
+          "description": "The decentralized identifier (DID) of the author.",
+          "format": "at-identifier"
+        },
+        "handle": {
+          "type": "string",
+          "description": "The handle of the author.",
+          "format": "at-identifier"
+        },
+        "displayName": {
+          "type": "string",
+          "description": "The display name of the author."
+        },
+        "avatar": {
+          "type": "string",
+          "description": "The URL of the author's avatar image.",
+          "format": "uri"
+        }
+      }
+    },
+    "shoutView": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the shout."
+        },
+        "message": {
+          "type": "string",
+          "description": "The content of the shout."
+        },
+        "parent": {
+          "type": "string",
+          "description": "The ID of the parent shout if this is a reply, otherwise null."
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The date and time when the shout was created.",
+          "format": "datetime"
+        },
+        "author": {
+          "type": "ref",
+          "description": "The author of the shout.",
+          "ref": "app.rocksky.shout.defs#author"
+        }
+      }
+    }
+  }
+}

lexicons/shout/getAlbumShouts.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.getAlbumShouts",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get shouts for an album",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The unique identifier of the album to retrieve shouts for",
+            "format": "at-uri"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of shouts to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The number of shouts to skip before starting to collect the result set",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "shouts": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.shout.defs#shoutViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/shout/getArtistShouts.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.getArtistShouts",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get shouts for an artist",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the artist to retrieve shouts for",
+            "format": "at-uri"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of shouts to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The number of shouts to skip before starting to collect the result set",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "shouts": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.shout.defs#shoutViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/shout/getProfileShouts.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.getProfileShouts",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the shouts of an actor's profile",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the actor",
+            "format": "at-identifier"
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of shouts to return",
+            "minimum": 1
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "shouts": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.shout.defs#shoutViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/shout/getShoutReplies.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.getShoutReplies",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get replies to a shout",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the shout to retrieve replies for",
+            "format": "at-uri"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of shouts to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The number of shouts to skip before starting to collect the result set",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "shouts": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.shout.defs#shoutViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/shout/getTrackShouts.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.getTrackShouts",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get all shouts for a specific track",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The URI of the track to retrieve shouts for",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "shouts": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.shout.defs#shoutViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/shout/removeShout.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.removeShout",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Remove a shout by its ID",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "id"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "The ID of the shout to be removed"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.shout.defs#shoutView"
+        }
+      }
+    }
+  }
+}

lexicons/shout/replyShout.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.replyShout",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Reply to a shout",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "shoutId",
+            "message"
+          ],
+          "properties": {
+            "shoutId": {
+              "type": "string",
+              "description": "The unique identifier of the shout to reply to"
+            },
+            "message": {
+              "type": "string",
+              "description": "The content of the reply",
+              "minLength": 1
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.shout.defs#shoutView"
+        }
+      }
+    }
+  }
+}

lexicons/shout/reportShout.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout.reportShout",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Report a shout for moderation",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "shoutId"
+          ],
+          "properties": {
+            "shoutId": {
+              "type": "string",
+              "description": "The unique identifier of the shout to report"
+            },
+            "reason": {
+              "type": "string",
+              "description": "The reason for reporting the shout",
+              "minLength": 1
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.shout.defs#shoutView"
+        }
+      }
+    }
+  }
+}

lexicons/shout/shout.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.shout",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a shout.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "message",
+          "createdAt",
+          "subject"
+        ],
+        "properties": {
+          "message": {
+            "type": "string",
+            "description": "The message of the shout.",
+            "minLength": 1,
+            "maxLength": 1000
+          },
+          "createdAt": {
+            "type": "string",
+            "description": "The date when the shout was created.",
+            "format": "datetime"
+          },
+          "parent": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          },
+          "subject": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/song.json lexicons/song/song.json

···
   "defs": {
     "main": {
       "type": "record",
-      "key": "tid",
       "description": "A declaration of a song.",
+      "key": "tid",
       "record": {
         "type": "object",
         "required": [
···
           "createdAt"
         ],
         "properties": {
-          "trackNumber": {
-            "type": "integer",
-            "description": "The track number of the song in the album.",
-            "minimum": 1
-          },
-          "discNumber": {
-            "type": "integer",
-            "description": "The disc number of the song in the album.",
-            "minimum": 1
-          },
           "title": {
             "type": "string",
             "description": "The title of the song.",
···
           },
           "albumArtist": {
             "type": "string",
-            "description": "The artist of the album the song is from.",
+            "description": "The album artist of the song.",
             "minLength": 1,
             "maxLength": 256
           },
           "album": {
             "type": "string",
-            "description": "The album the song is from.",
+            "description": "The album of the song.",
             "minLength": 1,
             "maxLength": 256
           },
···
             "description": "The duration of the song in seconds.",
             "minimum": 1
           },
+          "trackNumber": {
+            "type": "integer",
+            "description": "The track number of the song in the album.",
+            "minimum": 1
+          },
+          "discNumber": {
+            "type": "integer",
+            "description": "The disc number of the song in the album.",
+            "minimum": 1
+          },
           "releaseDate": {
             "type": "string",
             "description": "The release date of the song.",
···
           },
           "copyrightMessage": {
             "type": "string",
-            "description": "The copyright message.",
+            "description": "The copyright message of the song.",
             "maxLength": 256
           },
           "wiki": {
···
           },
           "createdAt": {
             "type": "string",
-            "description": "The date the song was created.",
+            "description": "The date when the song was created.",
             "format": "datetime"
           },
           "mbid": {
···
       }
     }
   }
-}
+}

lexicons/song/createSong.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.song.createSong",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new song",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "title",
+            "artist",
+            "album",
+            "albumArtist"
+          ],
+          "properties": {
+            "title": {
+              "type": "string",
+              "description": "The title of the song"
+            },
+            "artist": {
+              "type": "string",
+              "description": "The artist of the song"
+            },
+            "albumArtist": {
+              "type": "string",
+              "description": "The album artist of the song, if different from the main artist"
+            },
+            "album": {
+              "type": "string",
+              "description": "The album of the song, if applicable"
+            },
+            "duration": {
+              "type": "integer",
+              "description": "The duration of the song in seconds"
+            },
+            "mbId": {
+              "type": "string",
+              "description": "The MusicBrainz ID of the song, if available"
+            },
+            "albumArt": {
+              "type": "string",
+              "description": "The URL of the album art for the song",
+              "format": "uri"
+            },
+            "trackNumber": {
+              "type": "integer",
+              "description": "The track number of the song in the album, if applicable"
+            },
+            "releaseDate": {
+              "type": "string",
+              "description": "The release date of the song, formatted as YYYY-MM-DD"
+            },
+            "year": {
+              "type": "integer",
+              "description": "The year the song was released"
+            },
+            "discNumber": {
+              "type": "integer",
+              "description": "The disc number of the song in the album, if applicable"
+            },
+            "lyrics": {
+              "type": "string",
+              "description": "The lyrics of the song, if available"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.song.defs#songViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/song/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.song.defs",
+  "defs": {
+    "songViewBasic": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the song."
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the song."
+        },
+        "artist": {
+          "type": "string",
+          "description": "The artist of the song."
+        },
+        "albumArtist": {
+          "type": "string",
+          "description": "The artist of the album the song belongs to."
+        },
+        "albumArt": {
+          "type": "string",
+          "description": "The URL of the album art image.",
+          "format": "uri"
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the song.",
+          "format": "at-uri"
+        },
+        "album": {
+          "type": "string",
+          "description": "The album of the song."
+        },
+        "duration": {
+          "type": "integer",
+          "description": "The duration of the song in milliseconds."
+        },
+        "trackNumber": {
+          "type": "integer",
+          "description": "The track number of the song in the album."
+        },
+        "discNumber": {
+          "type": "integer",
+          "description": "The disc number of the song in the album."
+        },
+        "playCount": {
+          "type": "integer",
+          "description": "The number of times the song has been played.",
+          "minimum": 0
+        },
+        "uniqueListeners": {
+          "type": "integer",
+          "description": "The number of unique listeners who have played the song.",
+          "minimum": 0
+        },
+        "albumUri": {
+          "type": "string",
+          "description": "The URI of the album the song belongs to.",
+          "format": "at-uri"
+        },
+        "artistUri": {
+          "type": "string",
+          "description": "The URI of the artist of the song.",
+          "format": "at-uri"
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the song."
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The timestamp when the song was created.",
+          "format": "datetime"
+        }
+      }
+    },
+    "songViewDetailed": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the song."
+        },
+        "title": {
+          "type": "string",
+          "description": "The title of the song."
+        },
+        "artist": {
+          "type": "string",
+          "description": "The artist of the song."
+        },
+        "albumArtist": {
+          "type": "string",
+          "description": "The artist of the album the song belongs to."
+        },
+        "albumArt": {
+          "type": "string",
+          "description": "The URL of the album art image.",
+          "format": "uri"
+        },
+        "uri": {
+          "type": "string",
+          "description": "The URI of the song.",
+          "format": "at-uri"
+        },
+        "album": {
+          "type": "string",
+          "description": "The album of the song."
+        },
+        "duration": {
+          "type": "integer",
+          "description": "The duration of the song in milliseconds."
+        },
+        "trackNumber": {
+          "type": "integer",
+          "description": "The track number of the song in the album."
+        },
+        "discNumber": {
+          "type": "integer",
+          "description": "The disc number of the song in the album."
+        },
+        "playCount": {
+          "type": "integer",
+          "description": "The number of times the song has been played.",
+          "minimum": 0
+        },
+        "uniqueListeners": {
+          "type": "integer",
+          "description": "The number of unique listeners who have played the song.",
+          "minimum": 0
+        },
+        "albumUri": {
+          "type": "string",
+          "description": "The URI of the album the song belongs to.",
+          "format": "at-uri"
+        },
+        "artistUri": {
+          "type": "string",
+          "description": "The URI of the artist of the song.",
+          "format": "at-uri"
+        },
+        "sha256": {
+          "type": "string",
+          "description": "The SHA256 hash of the song."
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "The timestamp when the song was created.",
+          "format": "datetime"
+        }
+      }
+    }
+  }
+}

lexicons/song/getSong.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.song.getSong",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a song by its uri",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "uri"
+        ],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The unique identifier of the song to retrieve",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.song.defs#songViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/song/getSongs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.song.getSongs",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get songs",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "limit": {
+            "type": "integer",
+            "description": "The maximum number of songs to return",
+            "minimum": 1
+          },
+          "offset": {
+            "type": "integer",
+            "description": "The offset for pagination",
+            "minimum": 0
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "songs": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "app.rocksky.song.defs#songViewBasic"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/song/lovedSong.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.lovedSong",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a song.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "title",
+          "artist",
+          "album",
+          "duration",
+          "createdAt"
+        ],
+        "properties": {
+          "title": {
+            "type": "string",
+            "description": "The title of the song.",
+            "minLength": 1,
+            "maxLength": 512
+          },
+          "artist": {
+            "type": "string",
+            "description": "The artist of the song.",
+            "minLength": 1,
+            "maxLength": 256
+          },
+          "albumArtist": {
+            "type": "string",
+            "description": "The album artist of the song.",
+            "minLength": 1,
+            "maxLength": 256
+          },
+          "album": {
+            "type": "string",
+            "description": "The album of the song.",
+            "minLength": 1,
+            "maxLength": 256
+          },
+          "duration": {
+            "type": "integer",
+            "description": "The duration of the song in seconds.",
+            "minimum": 1
+          },
+          "trackNumber": {
+            "type": "integer",
+            "description": "The track number of the song in the album.",
+            "minimum": 1
+          },
+          "discNumber": {
+            "type": "integer",
+            "description": "The disc number of the song in the album.",
+            "minimum": 1
+          },
+          "releaseDate": {
+            "type": "string",
+            "description": "The release date of the song.",
+            "format": "datetime"
+          },
+          "year": {
+            "type": "integer",
+            "description": "The year the song was released."
+          },
+          "genre": {
+            "type": "string",
+            "description": "The genre of the song.",
+            "maxLength": 256
+          },
+          "tags": {
+            "type": "array",
+            "description": "The tags of the song.",
+            "items": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 256
+            }
+          },
+          "composer": {
+            "type": "string",
+            "description": "The composer of the song.",
+            "maxLength": 256
+          },
+          "lyrics": {
+            "type": "string",
+            "description": "The lyrics of the song.",
+            "maxLength": 10000
+          },
+          "copyrightMessage": {
+            "type": "string",
+            "description": "The copyright message of the song.",
+            "minLength": 1,
+            "maxLength": 256
+          },
+          "wiki": {
+            "type": "string",
+            "description": "Informations about the song",
+            "maxLength": 10000
+          },
+          "albumArt": {
+            "type": "blob",
+            "description": "The album art of the song.",
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
+            "maxSize": 2000000
+          },
+          "youtubeLink": {
+            "type": "string",
+            "description": "The YouTube link of the song.",
+            "format": "uri"
+          },
+          "spotifyLink": {
+            "type": "string",
+            "description": "The Spotify link of the song.",
+            "format": "uri"
+          },
+          "tidalLink": {
+            "type": "string",
+            "description": "The Tidal link of the song.",
+            "format": "uri"
+          },
+          "appleMusicLink": {
+            "type": "string",
+            "description": "The Apple Music link of the song.",
+            "format": "uri"
+          },
+          "createdAt": {
+            "type": "string",
+            "description": "The date when the song was created.",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/spotify/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.spotify.defs",
+  "defs": {
+    "spotifyTrackView": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "The unique identifier of the Spotify track."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the track."
+        },
+        "artist": {
+          "type": "string",
+          "description": "The name of the artist."
+        },
+        "album": {
+          "type": "string",
+          "description": "The name of the album."
+        },
+        "duration": {
+          "type": "integer",
+          "description": "The duration of the track in milliseconds."
+        },
+        "previewUrl": {
+          "type": "string",
+          "description": "A URL to a preview of the track."
+        }
+      }
+    }
+  }
+}

lexicons/spotify/getCurrentlyPlaying.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.spotify.getCurrentlyPlaying",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the currently playing track",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "actor": {
+            "type": "string",
+            "description": "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.",
+            "format": "at-identifier"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.player.defs#currentlyPlayingViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/spotify/next.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.spotify.next",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Play the next track in the queue"
+    }
+  }
+}

lexicons/spotify/pause.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.spotify.pause",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Pause the currently playing track"
+    }
+  }
+}

lexicons/spotify/play.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.spotify.play",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Resume playback of the currently paused track"
+    }
+  }
+}

lexicons/spotify/previous.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.spotify.previous",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Play the previous track in the queue"
+    }
+  }
+}

lexicons/spotify/seek.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.spotify.seek",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Seek to a specific position in the currently playing track",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "position"
+        ],
+        "properties": {
+          "position": {
+            "type": "integer",
+            "description": "The position in seconds to seek to"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/stats/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.stats.defs",
+  "defs": {
+    "statsView": {
+      "type": "object",
+      "properties": {
+        "scrobbles": {
+          "type": "integer",
+          "description": "The total number of scrobbles."
+        },
+        "artists": {
+          "type": "integer",
+          "description": "The total number of unique artists scrobbled."
+        },
+        "lovedTracks": {
+          "type": "integer",
+          "description": "The total number of tracks marked as loved."
+        },
+        "albums": {
+          "type": "integer",
+          "description": "The total number of unique albums scrobbled."
+        },
+        "tracks": {
+          "type": "integer",
+          "description": "The total number of unique tracks scrobbled."
+        }
+      }
+    }
+  }
+}

lexicons/stats/getStats.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.stats.getStats",
+  "defs": {
+    "main": {
+      "type": "query",
+      "parameters": {
+        "type": "params",
+        "required": [
+          "did"
+        ],
+        "properties": {
+          "did": {
+            "type": "string",
+            "description": "The DID or handle of the user to get stats for.",
+            "format": "at-identifier"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.stats.defs#statsView"
+        }
+      }
+    }
+  }
+}

lexicons/strongRef.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.repo.strongRef",
+  "description": "A URI with a content-hash fingerprint.",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        }
+      }
+    }
+  }
+}

package.json

···
   "type": "module",
   "private": false,
   "scripts": {
-    "lexgen": "lex gen-server ./src/lexicon ./lexicons/*"
+    "lexgen": "lex gen-server ./src/lexicon ./lexicons/**/* ./lexicons/*",
+    "pkl:gen": "tsx ./scripts/pkl.ts"
   },
   "devDependencies": {
     "@types/bun": "latest"
···
     "@atproto/oauth-client-node": "^0.2.16",
     "@atproto/sync": "^0.1.20",
     "@atproto/syntax": "^0.4.0",
-    "@atproto/xrpc-server": "^0.7.15"
+    "@atproto/xrpc-server": "^0.7.15",
+    "@pkl-community/pkl": "^0.28.2",
+    "tsx": "^4.20.3",
+    "zx": "^8.5.5"
   }
 }

pkl/defs/actor/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.defs"
+defs = new Mapping<String, ObjectType> {
+  ["profileViewDetailed"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the actor."
+      }
+
+      ["did"] = new StringType {
+        type = "string"
+        description = "The DID of the actor."
+      }
+
+      ["handle"] = new StringType {
+        type = "string"
+        description = "The handle of the actor."
+      }
+
+      ["displayName"] = new StringType {
+        type = "string"
+        description = "The display name of the actor."
+      }
+
+      ["avatar"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the actor's avatar image."
+      }
+
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the actor was created."
+      }
+
+      ["updatedAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the actor was last updated."
+      }
+
+    }
+  }
+  ["profileViewBasic"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the actor."
+      }
+
+      ["did"] = new StringType {
+        type = "string"
+        description = "The DID of the actor."
+      }
+
+      ["handle"] = new StringType {
+        type = "string"
+        description = "The handle of the actor."
+      }
+
+      ["displayName"] = new StringType {
+        type = "string"
+        description = "The display name of the actor."
+      }
+
+      ["avatar"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the actor's avatar image."
+      }
+
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the actor was created."
+      }
+
+      ["updatedAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the actor was last updated."
+      }
+    }
+  }
+}

pkl/defs/actor/getActorAlbums.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.getActorAlbums"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get albums for an actor"
+    parameters = new Params {
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+         ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of albums to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["albums"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.album.defs#albumViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/actor/getActorArtists.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.getActorArtists"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get artists for an actor"
+    parameters = new Params {
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+         ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of albums to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["artists"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.artist.defs#artistViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/actor/getActorLovedSongs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.getActorLovedSongs"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get loved songs for an actor"
+    parameters = new Params {
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+         ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of albums to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["tracks"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.song.defs#songViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/actor/getActorPlaylists.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.getActorPlaylists"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get playlists for an actor"
+    parameters = new Params {
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+         ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of albums to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["playlists"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.playlist.defs#playlistViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/actor/getActorScrobbles.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.getActorScrobbles"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get scrobbles for an actor"
+    parameters = new Params {
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+         ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of albums to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["scrobbles"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.scrobble.defs#scrobbleViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/actor/getActorSongs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.getActorSongs"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get songs for an actor"
+    parameters = new Params {
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of albums to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+   output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["songs"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.song.defs#songViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/actor/getProfile.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.actor.getProfile"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get the profile of an actor"
+    parameters = new Params {
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        ref = "app.rocksky.actor.defs#profileViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/actor/profile.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.bsky.actor.profile"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    description = "A declaration of a Bluesky account profile."
+    key = "literal:self"
+    `record` {
+      type = "object"
+      properties {
+        ["displayName"] = new StringType {
+          type = "string"
+          maxGraphemes = 64
+          maxLength = 640
+        }
+        ["description"] = new StringType {
+          type = "string"
+          description = "Free-form profile description text."
+          maxGraphemes = 256
+          maxLength = 2560
+        }
+        ["avatar"] = new Blob {
+          type = "blob"
+          description = "Small image to be displayed next to posts from account. AKA, 'profile picture'"
+          accept = List("image/png", "image/jpeg")
+          maxSize = 1000000
+        }
+        ["banner"] = new Blob {
+          type = "blob"
+          description = "Larger horizontal image to display behind profile view."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 10000000
+        }
+        ["labels"] = new Union {
+          type = "union"
+          description = "Self-label values, specific to the Bluesky application, on the overall account."
+          refs = List("com.atproto.label.defs#selfLabels")
+        }
+        ["joinedViaStarterPack"] = new Ref {
+          type = "ref"
+          ref = "com.atproto.repo.strongRef"
+        }
+        ["createdAt"] = new StringType {
+          type = "string"
+          format = "datetime"
+        }
+      }
+    }
+  }
+}

pkl/defs/album/album.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.album"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of an album."
+    `record` {
+      type = "object"
+      required = List("title", "artist", "createdAt")
+      properties {
+        ["title"] = new StringType {
+          type = "string"
+          description = "The title of the album."
+          minLength = 1
+          maxLength = 512
+        }
+
+        ["artist"] = new StringType {
+          type = "string"
+          description = "The artist of the album."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["duration"] = new IntegerType {
+          type = "integer"
+          description = "The duration of the album in seconds."
+        }
+
+        ["releaseDate"] = new StringType {
+          type = "string"
+          description = "The release date of the album."
+          format = "datetime"
+        }
+
+        ["year"] = new IntegerType {
+          type = "integer"
+          description = "The year the album was released."
+        }
+
+        ["genre"] = new StringType {
+          type = "string"
+          description = "The genre of the album."
+          maxLength = 256
+        }
+
+        ["albumArt"] = new Blob {
+          type = "blob"
+          description = "The album art of the album."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 2000000
+        }
+
+        ["tags"] = new Array {
+          type = "array"
+          description = "The tags of the album."
+          items = new StringType {
+            type = "string"
+            minLength = 1
+            maxLength = 256
+          }
+        }
+
+        ["youtubeLink"] = new StringType {
+          type = "string"
+          description = "The YouTube link of the album."
+          format = "uri"
+        }
+
+        ["spotifyLink"] = new StringType {
+          type = "string"
+          description = "The Spotify link of the album."
+          format = "uri"
+        }
+
+        ["tidalLink"] = new StringType {
+          type = "string"
+          description = "The tidal link of the album."
+          format = "uri"
+        }
+
+        ["appleMusicLink"] = new StringType {
+          type = "string"
+          description = "The Apple Music link of the album."
+          format = "uri"
+        }
+
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date and time when the album was created."
+          format = "datetime"
+        }
+      }
+    }
+  }
+}

pkl/defs/album/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.album.defs"
+defs = new Mapping<String, ObjectType> {
+  ["albumViewBasic"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the album."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the album."
+      }
+
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the album."
+      }
+
+      ["artist"] = new StringType {
+        type = "string"
+        description = "The artist of the album."
+      }
+
+      ["artistUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the album's artist."
+      }
+
+      ["year"] = new IntegerType {
+        type = "integer"
+        description = "The year the album was released."
+      }
+
+      ["albumArt"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the album art image."
+      }
+
+      ["releaseDate"] = new StringType {
+        type = "string"
+        description = "The release date of the album."
+      }
+
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the album."
+      }
+
+      ["playCount"] = new IntegerType {
+        type = "integer"
+        description = "The number of times the album has been played."
+        minimum = 0
+      }
+
+      ["uniqueListeners"] = new IntegerType {
+        type = "integer"
+        description = "The number of unique listeners who have played the album."
+        minimum = 0
+      }
+    }
+  }
+  ["albumViewDetailed"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the album."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the album."
+      }
+
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the album."
+      }
+
+      ["artist"] = new StringType {
+        type = "string"
+        description = "The artist of the album."
+      }
+
+      ["artistUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the album's artist."
+      }
+
+      ["year"] = new IntegerType {
+        type = "integer"
+        description = "The year the album was released."
+      }
+
+      ["albumArt"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the album art image."
+      }
+
+      ["releaseDate"] = new StringType {
+        type = "string"
+        description = "The release date of the album."
+      }
+
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the album."
+      }
+
+      ["playCount"] = new IntegerType {
+        type = "integer"
+        description = "The number of times the album has been played."
+        minimum = 0
+      }
+
+      ["uniqueListeners"] = new IntegerType {
+        type = "integer"
+        description = "The number of unique listeners who have played the album."
+        minimum = 0
+      }
+
+      ["tracks"] = new Array {
+        type = "array"
+        items = new Ref {
+          type = "ref"
+          ref = "app.rocksky.song.defs.songViewBasic"
+        }
+      }
+    }
+  }
+}

pkl/defs/album/getAlbum.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.album.getAlbum"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get detailed album view"
+    parameters {
+      type = "params"
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          type = "string"
+          format = "at-uri"
+          description = "The URI of the album to retrieve."
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.album.defs#albumViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/album/getAlbumTracks.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.album.getAlbumTracks"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get tracks for an album"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The URI of the album to retrieve tracks from"
+          format = "at-uri"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["tracks"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.song.defs#songViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/album/getAlbums.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.album.getAlbums"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get albums"
+    parameters = new Params {
+      properties {
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of albums to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["albums"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.album.defs#albumViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/apikey/createApikey.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.apikey.createApikey"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Create a new API key for the authenticated user"
+    input {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        required = List("name")
+        properties {
+          ["name"] = new StringType {
+            type = "string"
+            description = "The name of the API key."
+          }
+          ["description"] = new StringType {
+            type = "string"
+            description = "A description for the API key."
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.apikey.defs#apiKey"
+      }
+    }
+  }
+}

pkl/defs/apikey/def.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.apikey.defs"
+defs = new Mapping<String, ObjectType> {
+  ["apiKeyView"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the API key."
+      }
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the API key."
+      }
+      ["description"] = new StringType {
+        type = "string"
+        description = "A description for the API key."
+      }
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the API key was created."
+      }
+    }
+  }
+}

pkl/defs/apikey/getApikeys.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.apikey.getApikeys"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get a list of API keys for the authenticated user"
+    parameters {
+      type = "params"
+      properties {
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The number of API keys to skip before starting to collect the result set."
+        }
+
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The number of API keys to return per page."
+        }
+
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["apiKeys"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.apikey.defs#apikeyView"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/apikey/removeApikey.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.apikey.removeApikey"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Remove an API key for the authenticated user"
+    parameters {
+      type = "params"
+      required = List("id")
+      properties {
+        ["id"] = new StringType {
+          type = "string"
+          description = "The ID of the API key to remove."
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.apikey.defs#apiKey"
+      }
+    }
+  }
+}

pkl/defs/apikey/updateApikey.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.apikey.updateApikey"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Update an existing API key for the authenticated user"
+    input {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        required = List("id", "name")
+        properties {
+          ["id"] = new StringType {
+            type = "string"
+            description = "The ID of the API key to update."
+          }
+          ["name"] = new StringType {
+            type = "string"
+            description = "The new name of the API key."
+          }
+          ["description"] = new StringType {
+            type = "string"
+            description = "A new description for the API key."
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.apikey.defs#apiKey"
+      }
+    }
+  }
+}

pkl/defs/artist/artist.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.artist"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of an artist."
+    `record` {
+      type = "object"
+      required = List("name", "createdAt")
+      properties {
+        ["name"] = new StringType {
+          type = "string"
+          description = "The name of the artist."
+          minLength = 1
+          maxLength = 512
+        }
+
+        ["bio"] = new StringType {
+          type = "string"
+          description = "The biography of the artist."
+          maxLength = 1000
+        }
+
+        ["picture"] = new Blob {
+          type = "blob"
+          description = "The picture of the artist."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 2000000
+        }
+
+        ["tags"] = new Array {
+          type = "array"
+          description = "The tags of the artist."
+          items = new StringType {
+            type = "string"
+            minLength = 1
+            maxLength = 256
+          }
+        }
+        ["born"] = new StringType {
+          type = "string"
+          description = "The birth date of the artist."
+          format = "datetime"
+        }
+        ["died"] = new StringType {
+          type = "string"
+          description = "The death date of the artist."
+          format = "datetime"
+        }
+        ["bornIn"] = new StringType {
+          type = "string"
+          description = "The birth place of the artist."
+          maxLength = 256
+        }
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date when the artist was created."
+          format = "datetime"
+        }
+      }
+    }
+  }
+}

pkl/defs/artist/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.artist.defs"
+defs = new Mapping<String, ObjectType> {
+  ["artistViewBasic"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the artist."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the artist."
+      }
+
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the artist."
+      }
+
+      ["picture"] = new StringType {
+        type = "string"
+        description = "The picture of the artist."
+      }
+
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the artist."
+      }
+
+      ["playCount"] = new IntegerType {
+        type = "integer"
+        description = "The number of times the artist has been played."
+        minimum = 0
+      }
+
+      ["uniqueListeners"] = new IntegerType {
+        type = "integer"
+        description = "The number of unique listeners who have played the artist."
+        minimum = 0
+      }
+
+    }
+  }
+
+  ["artistViewDetailed"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the artist."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the artist."
+      }
+
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the artist."
+      }
+
+      ["picture"] = new StringType {
+        type = "string"
+        description = "The picture of the artist."
+      }
+
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the artist."
+      }
+
+      ["playCount"] = new IntegerType {
+        type = "integer"
+        description = "The number of times the artist has been played."
+        minimum = 0
+      }
+
+      ["uniqueListeners"] = new IntegerType {
+        type = "integer"
+        description = "The number of unique listeners who have played the artist."
+        minimum = 0
+      }
+
+    }
+  }
+}

pkl/defs/artist/getArtist.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.artist.getArtist"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get artist details"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The URI of the artist to retrieve details from"
+          format = "at-uri"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.artist.defs#artistViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/artist/getArtistAlbums.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.artist.getArtistAlbums"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get artist's albums"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The URI of the artist to retrieve albums from"
+          format = "at-uri"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["albums"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.album.defs#albumViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/artist/getArtistTracks.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.artist.getArtistTracks"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get artist's tracks"
+    parameters = new Params {
+      properties {
+         ["uri"] = new StringType {
+          description = "The URI of the artist to retrieve albums from"
+          format = "at-uri"
+        }
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of tracks to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["tracks"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.song.defs#songViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/artist/getArtists.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.artist.getArtists"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get artists"
+    parameters = new Params {
+      properties {
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of artists to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["artists"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.artist.defs#artistViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/charts/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.charts.defs"
+defs = new Mapping<String, ObjectType> {
+  ["chartsView"] {
+    type = "object"
+    properties {
+      ["scrobbles"] = new Array {
+        type = "array"
+        items = new Ref {
+          type = "ref"
+          ref = "app.rocksky.charts.defs#scrobbleViewBasic"
+        }
+      }
+    }
+  }
+  ["scrobbleViewBasic"] {
+    type = "object"
+    properties {
+      ["date"] = new StringType {
+        type = "string"
+        description = "The date of the scrobble."
+        format = "datetime"
+      }
+      ["count"] = new IntegerType {
+        type = "integer"
+        description = "The number of scrobbles on this date."
+      }
+    }
+  }
+}

pkl/defs/charts/getScrobblesChart.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.charts.getScrobblesChart"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get the scrobbles chart"
+    parameters = new Params {
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+
+        ["artisturi"] = new StringType {
+          description = "The URI of the artist to filter by"
+          format = "at-uri"
+        }
+
+        ["albumuri"] = new StringType {
+          description = "The URI of the album to filter by"
+          format = "at-uri"
+        }
+
+        ["songuri"] = new StringType {
+          description = "The URI of the track to filter by"
+          format = "at-uri"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        ref = "app.rocksky.charts.defs#chartsView"
+      }
+    }
+  }
+}

pkl/defs/dropbox/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.dropbox.defs"
+defs = new Mapping<String, ObjectType> {
+  ["fileView"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the file."
+      }
+
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the file."
+      }
+
+      ["pathLower"] = new StringType {
+        type = "string"
+        description = "The lowercased path of the file."
+      }
+
+      ["pathDisplay"] = new StringType {
+        type = "string"
+        description = "The display path of the file."
+      }
+
+      ["clientModified"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The last modified date and time of the file on the client."
+      }
+
+      ["serverModified"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The last modified date and time of the file on the server."
+      }
+    }
+  }
+  ["fileListView"] {
+    type = "object"
+    properties {
+      ["files"] = new Array {
+        type = "array"
+        items = new Ref {
+          type = "ref"
+          ref = "app.rocksky.dropbox.defs#fileView"
+        }
+        description = "A list of files in the Dropbox."
+      }
+    }
+  }
+  ["temporaryLinkView"] {
+    type = "object"
+    properties {
+      ["link"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The temporary link to access the file."
+      }
+    }
+  }
+}

pkl/defs/dropbox/downloadFile.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.dropbox.downloadFile"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Download a file from Dropbox by its unique identifier"
+    parameters = new Params {
+      required = List("fileId")
+      properties {
+        ["fileId"] = new StringType {
+          description = "The unique identifier of the file to download"
+        }
+      }
+    }
+    output {
+      encoding = "application/octet-stream"
+    }
+  }
+}

pkl/defs/dropbox/getFiles.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.dropbox.getFiles"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Retrieve a list of files from Dropbox"
+    parameters {
+      properties {
+        ["at"] = new StringType {
+          description = "Path to the Dropbox folder or root directory"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.dropbox.defs#fileListView"
+      }
+    }
+  }
+}

pkl/defs/dropbox/getMetadata.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.dropbox.getMetadata"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Retrieve metadata of a file or folder in Dropbox"
+    parameters {
+      required = List("path")
+      properties {
+        ["path"] = new StringType {
+          description = "Path to the file or folder in Dropbox"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.dropbox.defs#fileView"
+      }
+    }
+  }
+}

pkl/defs/dropbox/getTemporaryLink.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.dropbox.getTemporaryLink"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Retrieve a temporary link to access a file in Dropbox"
+    parameters {
+      required = List("path")
+      properties {
+        ["path"] = new StringType {
+          description = "Path to the file in Dropbox"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.dropbox.defs#temporaryLinkView"
+      }
+    }
+  }
+}

pkl/defs/feed/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.feed.defs"
+defs = new Mapping<String, ObjectType> {
+   ["searchResultsView"] = new ObjectType {
+    type = "object"
+    properties  {
+      ["hits"] = new Array {
+        type = "array"
+        items = new Union {
+          type = "union"
+          refs = List(
+            "app.rocksky.song.defs#songViewBasic",
+            "app.rocksky.album.defs#albumViewBasic",
+            "app.rocksky.artist.defs#artistViewBasic",
+            "app.rocksky.playlist.defs#playlistViewBasic",
+            "app.rocksky.actor.defs#profileViewBasic"
+            )
+        }
+      }
+      ["processingTimeMs"] = new IntegerType {
+        type = "integer"
+      }
+      ["limit"] = new IntegerType {
+        type = "integer"
+      }
+      ["offset"] = new IntegerType {
+        type = "integer"
+      }
+      ["estimatedTotalHits"] = new IntegerType {
+        type = "integer"
+      }
+    }
+
+  }
+  ["nowPlayingView"] = new ObjectType {
+    type = "object"
+    properties {
+      ["album"] = new StringType {
+        type = "string"
+      }
+      ["albumArt"] = new StringType {
+        type = "string"
+        format = "uri"
+      }
+      ["albumArtist"] = new StringType {
+        type = "string"
+      }
+      ["albumUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+      }
+      ["artist"] = new StringType {
+        type = "string"
+      }
+      ["artistUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+      }
+      ["avatar"] = new StringType {
+        type = "string"
+        format = "uri"
+      }
+      ["createdAt"] = new StringType {
+        type = "string"
+      }
+      ["did"] = new StringType {
+        type = "string"
+        format = "at-identifier"
+      }
+      ["handle"] = new StringType {
+        type = "string"
+      }
+      ["id"] = new StringType {
+        type = "string"
+      }
+      ["title"] = new StringType {
+        type = "string"
+      }
+      ["trackId"] = new StringType {
+        type = "string"
+      }
+      ["trackUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+      }
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+      }
+    }
+  }
+   ["nowPlayingsView"] = new ObjectType {
+    type = "object"
+    properties  {
+      ["nowPlayings"] = new Array {
+        type = "array"
+        items = new Ref {
+          type = "ref"
+          ref = "app.rocksky.feed.defs#nowPlayingView"
+        }
+      }
+    }
+  }
+}

pkl/defs/feed/getNowPlayings.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.feed.getNowPlayings"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get all currently playing tracks by users"
+    parameters {
+      type = "params"
+      properties {
+        ["size"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of now playing tracks to return."
+          minimum = 1
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.feed.defs#nowPlayingsView"
+      }
+    }
+  }
+}

pkl/defs/feed/search.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.feed.search"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Search for content in the feed"
+    parameters {
+      type = "params"
+      required = List("query")
+      properties {
+        ["query"] = new StringType {
+          description = "The search query string"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.feed.defs#searchResultsView"
+      }
+    }
+  }
+}

pkl/defs/googledrive/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.googledrive.defs"
+defs = new Mapping<String, ObjectType> {
+  ["fileView"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the file."
+      }
+    }
+  }
+  ["fileListView"] {
+    type = "object"
+    properties {
+      ["files"] = new Array {
+        type = "array"
+        items = new Ref {
+          type = "ref"
+          ref = "app.rocksky.googledrive.defs#fileView"
+        }
+      }
+    }
+  }
+}

pkl/defs/googledrive/downloadFile.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.googledrive.downloadFile"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Download a file from Google Drive by its unique identifier"
+    parameters = new Params {
+      required = List("fileId")
+      properties {
+        ["fileId"] = new StringType {
+          description = "The unique identifier of the file to download"
+        }
+      }
+    }
+    output {
+      encoding = "application/octet-stream"
+    }
+  }
+}

pkl/defs/googledrive/getFile.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.googledrive.getFile"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get a file from Google Drive by its unique identifier"
+    parameters = new Params {
+      required = List("fileId")
+      properties {
+        ["fileId"] = new StringType {
+          description = "The unique identifier of the file to retrieve"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        ref = "app.rocksky.googledrive.defs#fileView"
+      }
+    }
+  }
+}

pkl/defs/googledrive/getFiles.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.googledrive.getFiles"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get a list of files from Google Drive"
+    parameters = new Params {
+      properties {
+        ["at"] = new StringType {
+          description = "Path to the Google Drive folder or root directory"
+        }
+      }
+    }
+
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.googledrive.defs#fileListView"
+      }
+    }
+  }
+}

pkl/defs/like/dislikeShout.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.like.dislikeShout"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Dislike a shout"
+    input {
+      encoding = "application/json"
+      schema {
+        type = "object"
+        properties {
+          ["uri"] = new StringType {
+            type = "string"
+            description = "The unique identifier of the shout to dislike"
+            format = "at-uri"
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.shout.defs#shoutView"
+      }
+    }
+  }
+}

pkl/defs/like/dislikeSong.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.like.dislikeSong"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Dislike a song"
+    input {
+      encoding = "application/json"
+      schema {
+        type = "object"
+        properties {
+          ["uri"] = new StringType {
+            type = "string"
+            description = "The unique identifier of the song to dislike"
+            format = "at-uri"
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.song.defs#songViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/like/like.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.like"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of a like."
+    `record` {
+      type = "object"
+      required = List("createdAt", "subject")
+      properties {
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date when the like was created."
+          format = "datetime"
+        }
+
+        ["subject"] = new Ref {
+          type = "ref"
+          ref = "com.atproto.repo.strongRef"
+        }
+      }
+    }
+  }
+}

pkl/defs/like/likeShout.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.like.likeShout"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Like a shout"
+    input {
+      encoding = "application/json"
+      schema {
+        type = "object"
+        properties {
+          ["uri"] = new StringType {
+            type = "string"
+            description = "The unique identifier of the shout to like"
+            format = "at-uri"
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.shout.defs#shoutView"
+      }
+    }
+  }
+}

pkl/defs/like/likeSong.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.like.likeSong"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Like a song"
+    input {
+      encoding = "application/json"
+      schema {
+        type = "object"
+        properties {
+          ["uri"] = new StringType {
+            type = "string"
+            description = "The unique identifier of the song to like"
+            format = "at-uri"
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.song.defs#songViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/player/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.player.defs"
+defs = new Mapping<String, ObjectType> {
+  ["currentlyPlayingViewDetailed"] {
+    type = "object"
+    properties {
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the currently playing track"
+      }
+    }
+  }
+}

pkl/defs/player/getCurrentlyPlaying.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.player.getCurrentlyPlaying"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get the currently playing track"
+    parameters {
+      type = "params"
+      properties {
+        ["actor"] = new StringType {
+          type = "string"
+          format = "at-identifier"
+          description = "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user."
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.player.defs#currentlyPlayingViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/player/next.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.player.next"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Play the next track in the queue"
+  }
+}

pkl/defs/player/pause.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.player.pause"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Pause the currently playing track"
+  }
+}

pkl/defs/player/play.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.player.play"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Resume playback of the currently paused track"
+  }
+}

pkl/defs/player/previous.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.player.previous"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Play the previous track in the queue"
+  }
+}

pkl/defs/player/seek.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.player.seek"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Seek to a specific position in the currently playing track"
+    parameters {
+      type = "params"
+      required = List("position")
+      properties = new Mapping<String, IntegerType> {
+        ["position"] {
+          type = "integer"
+          description = "The position in seconds to seek to"
+        }
+      }
+    }
+  }
+}

pkl/defs/playlist/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.playlist.defs"
+defs = new Mapping<String, ObjectType> {
+  ["playlistViewDetailed"] {
+    type = "object"
+    description = "Detailed view of a playlist, including its tracks and metadata"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the playlist."
+      }
+
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the playlist."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the playlist."
+      }
+
+      ["curatorDid"] = new StringType {
+        type = "string"
+        description = "The DID of the curator of the playlist."
+        format = "at-identifier"
+      }
+
+      ["curatorHandle"] = new StringType {
+        type = "string"
+        description = "The handle of the curator of the playlist."
+        format = "at-identifier"
+      }
+
+      ["curatorName"] = new StringType {
+        type = "string"
+        description = "The name of the curator of the playlist."
+      }
+
+      ["curatorAvatarUrl"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the avatar image of the curator."
+      }
+
+      ["description"] = new StringType {
+        type = "string"
+        description = "A description of the playlist."
+      }
+
+      ["coverImageUrl"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the cover image for the playlist."
+      }
+
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the playlist was created."
+      }
+
+      ["tracks"] = new Array {
+        description = "A list of tracks in the playlist."
+        items = new Ref {
+          type = "ref"
+          ref = "app.rocksky.song.defs#songViewBasic"
+        }
+      }
+    }
+  }
+
+  ["playlistViewBasic"] {
+    type = "object"
+    description = "Basic view of a playlist, including its metadata"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the playlist."
+      }
+
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the playlist."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the playlist."
+      }
+
+      ["curatorDid"] = new StringType {
+        type = "string"
+        description = "The DID of the curator of the playlist."
+        format = "at-identifier"
+      }
+
+      ["curatorHandle"] = new StringType {
+        type = "string"
+        description = "The handle of the curator of the playlist."
+        format = "at-identifier"
+      }
+
+      ["curatorName"] = new StringType {
+        type = "string"
+        description = "The name of the curator of the playlist."
+      }
+
+      ["curatorAvatarUrl"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the avatar image of the curator."
+      }
+
+      ["description"] = new StringType {
+        type = "string"
+        description = "A description of the playlist."
+      }
+
+      ["coverImageUrl"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the cover image for the playlist."
+      }
+
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the playlist was created."
+      }
+
+      ["trackCount"] = new IntegerType {
+        type = "integer"
+        description = "The number of tracks in the playlist."
+        minimum = 0
+      }
+    }
+  }
+}

pkl/defs/playlist/getPlaylist.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.playlist.getPlaylist"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Retrieve a playlist by its ID"
+    parameters {
+      type = "params"
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          type = "string"
+          format = "at-uri"
+          description = "The URI of the playlist to retrieve."
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.playlist.defs#playlistViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/playlist/getPlaylists.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.playlist.getPlaylists"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Retrieve a list of playlists"
+    parameters {
+      type = "params"
+      properties {
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of playlists to return."
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination, used to skip a number of playlists."
+        }
+      }
+    }
+   output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["playlists"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.playlist.defs#playlistViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/playlist/playlist.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.playlist"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of a playlist."
+    `record` {
+      type = "object"
+      required = List("name", "createdAt")
+      properties {
+        ["name"] = new StringType {
+          type = "string"
+          description = "The name of the playlist."
+          minLength = 1
+          maxLength = 512
+        }
+        ["description"] = new StringType {
+          type = "string"
+          description = "The playlist description."
+          minLength = 1
+          maxLength = 256
+        }
+        ["picture"] = new Blob {
+          type = "blob"
+          description = "The picture of the playlist."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 2000000
+        }
+        ["tracks"] = new Array {
+          type = "array"
+          description = "The tracks in the playlist."
+          items = new Ref {
+            type = "ref"
+            ref = "app.rocksky.song#record"
+          }
+        }
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date the playlist was created."
+          format = "datetime"
+        }
+        ["spotifyLink"] = new StringType {
+          type = "string"
+          description = "The Spotify link of the playlist."
+        }
+        ["tidalLink"] = new StringType {
+          type = "string"
+          description = "The Tidal link of the playlist."
+        }
+        ["youtubeLink"] = new StringType {
+          type = "string"
+          description = "The YouTube link of the playlist."
+        }
+        ["appleMusicLink"] = new StringType {
+          type = "string"
+          description = "The Apple Music link of the playlist."
+        }
+      }
+    }
+  }
+}

pkl/defs/radio/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.radio.defs"
+defs = new Mapping<String, ObjectType> {
+  ["radioViewBasic"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the radio."
+      }
+
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the radio."
+      }
+
+      ["description"] = new StringType {
+        type = "string"
+        description = "A brief description of the radio."
+      }
+
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the radio was created."
+      }
+    }
+  }
+  ["radioViewDetailed"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the radio."
+      }
+
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the radio."
+      }
+
+      ["description"] = new StringType {
+        type = "string"
+        description = "A brief description of the radio."
+      }
+
+      ["website"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The website of the radio."
+      }
+
+      ["url"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The streaming URL of the radio."
+      }
+
+      ["genre"] = new StringType {
+        type = "string"
+        description = "The genre of the radio."
+      }
+
+      ["logo"] = new StringType {
+        type = "string"
+        description = "The logo of the radio station."
+      }
+
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the radio was created."
+      }
+    }
+  }
+}

pkl/defs/radio/radio.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.radio"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of a radio station."
+    `record` {
+      type = "object"
+      required = List("name", "url", "createdAt")
+      properties {
+        ["name"] = new StringType {
+          type = "string"
+          description = "The name of the radio station."
+          minLength = 1
+          maxLength = 512
+        }
+
+        ["url"] = new StringType {
+          type = "string"
+          description = "The URL of the radio station."
+          format = "uri"
+        }
+
+        ["description"] = new StringType {
+          type = "string"
+          description = "A description of the radio station."
+          minLength = 1
+          maxLength = 1000
+        }
+
+        ["genre"] = new StringType {
+          type = "string"
+          description = "The genre of the radio station."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["logo"] = new Blob {
+          type = "blob"
+          description = "The logo of the radio station."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 2000000
+        }
+
+        ["website"] = new StringType {
+          type = "string"
+          description = "The website of the radio station."
+          format = "uri"
+        }
+
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date when the radio station was created."
+          format = "datetime"
+        }
+
+      }
+    }
+  }
+}

pkl/defs/scrobble/createScrobble.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.scrobble.createScrobble"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Create a new scrobble"
+    input {
+      encoding = "application/json"
+      schema {
+        type = "object"
+        required = List("title", "artist")
+        properties  {
+          ["title"] = new StringType {
+            type = "string"
+            description = "The title of the track being scrobbled"
+          }
+          ["artist"] = new StringType {
+            type = "string"
+            description = "The artist of the track being scrobbled"
+          }
+          ["album"] = new StringType {
+            type = "string"
+            description = "The album of the track being scrobbled"
+          }
+          ["duration"] = new IntegerType {
+            type = "integer"
+            description = "The duration of the track in seconds"
+          }
+          ["mbId"] = new StringType {
+            type = "string"
+            description = "The MusicBrainz ID of the track, if available"
+          }
+          ["albumArt"] = new StringType {
+            type = "string"
+            description = "The URL of the album art for the track"
+            format = "uri"
+          }
+          ["trackNumber"] = new IntegerType {
+            type = "integer"
+            description = "The track number of the track in the album"
+          }
+          ["releaseDate"] = new StringType {
+            type = "string"
+            description = "The release date of the track, formatted as YYYY-MM-DD"
+          }
+          ["year"] = new IntegerType {
+            type = "integer"
+            description = "The year the track was released"
+          }
+          ["discNumber"] = new IntegerType {
+            type = "integer"
+            description = "The disc number of the track in the album, if applicable"
+          }
+          ["lyrics"] = new StringType {
+            type = "string"
+            description = "The lyrics of the track, if available"
+          }
+          ["composer"] = new StringType {
+            type = "string"
+            description = "The composer of the track, if available"
+          }
+          ["copyrightMessage"] = new StringType {
+            type = "string"
+            description = "The copyright message for the track, if available"
+          }
+          ["label"] = new StringType {
+            type = "string"
+            description = "The record label of the track, if available"
+          }
+          ["artistPicture"] = new StringType {
+            type = "string"
+            description = "The URL of the artist's picture, if available"
+            format = "uri"
+          }
+          ["spotifyLink"] = new StringType {
+            type = "string"
+            description = "The Spotify link for the track, if available"
+            format = "uri"
+          }
+          ["lastfmLink"] = new StringType {
+            type = "string"
+            description = "The Last.fm link for the track, if available"
+            format = "uri"
+          }
+          ["tidalLink"] = new StringType {
+            type = "string"
+            description = "The Tidal link for the track, if available"
+            format = "uri"
+          }
+          ["appleMusicLink"] = new StringType {
+            type = "string"
+            description = "The Apple Music link for the track, if available"
+            format = "uri"
+          }
+          ["youtubeLink"] = new StringType {
+            type = "string"
+            description = "The Youtube link for the track, if available"
+            format = "uri"
+          }
+          ["deezerLink"] = new StringType {
+            type = "string"
+            description = "The Deezer link for the track, if available"
+            format = "uri"
+          }
+          ["timestamp"] = new IntegerType {
+            type = "integer"
+            description = "The timestamp of the scrobble in milliseconds since epoch"
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.scrobble.defs#scrobbleViewBasic"
+      }
+    }
+  }
+}

pkl/defs/scrobble/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.scrobble.defs"
+defs = new Mapping<String, ObjectType> {
+  ["scrobbleViewBasic"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the scrobble."
+      }
+      ["user"] = new StringType {
+        type = "string"
+        description = "The handle of the user who created the scrobble."
+      }
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the scrobble."
+      }
+
+      ["artist"] = new StringType {
+        type = "string"
+        description = "The artist of the song."
+      }
+
+      ["artistUri"] = new StringType {
+        type = "string"
+        description = "The URI of the artist."
+        format = "at-uri"
+      }
+
+      ["album"] = new StringType {
+        type = "string"
+        description = "The album of the song."
+      }
+
+      ["albumUri"] = new StringType {
+        type = "string"
+        description = "The URI of the album."
+        format = "at-uri"
+      }
+
+      ["cover"] = new StringType {
+        type = "string"
+        description = "The album art URL of the song."
+        format = "uri"
+      }
+
+      ["date"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The timestamp when the scrobble was created."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URI of the scrobble."
+      }
+
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the scrobble data."
+      }
+
+    }
+  }
+
+  ["scrobbleViewDetailed"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the scrobble."
+      }
+      ["user"] = new StringType {
+        type = "string"
+        description = "The handle of the user who created the scrobble."
+      }
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the scrobble."
+      }
+
+      ["artist"] = new StringType {
+        type = "string"
+        description = "The artist of the song."
+      }
+
+      ["artistUri"] = new StringType {
+        type = "string"
+        description = "The URI of the artist."
+        format = "at-uri"
+      }
+
+      ["album"] = new StringType {
+        type = "string"
+        description = "The album of the song."
+      }
+
+      ["albumUri"] = new StringType {
+        type = "string"
+        description = "The URI of the album."
+        format = "at-uri"
+      }
+
+      ["cover"] = new StringType {
+        type = "string"
+        description = "The album art URL of the song."
+        format = "uri"
+      }
+
+      ["date"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The timestamp when the scrobble was created."
+      }
+
+      ["uri"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URI of the scrobble."
+      }
+
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the scrobble data."
+      }
+
+      ["listeners"] = new IntegerType {
+        type = "integer"
+        description = "The number of listeners"
+      }
+
+      ["scrobbles"] = new IntegerType {
+        type = "integer"
+        description = "The number of scrobbles for this song"
+      }
+    }
+  }
+}

pkl/defs/scrobble/getScrobble.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.scrobble.getScrobble"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get a scrobble by its unique identifier"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The unique identifier of the scrobble"
+          format = "at-uri"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        ref = "app.rocksky.scrobble.defs#scrobbleViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/scrobble/getScrobbles.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.scrobble.getScrobbles"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get scrobbles all scrobbles"
+    parameters = new Params {
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of scrobbles to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["scrobbles"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.scrobble.defs#scrobbleViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/scrobble/scrobble.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.scrobble"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of a scrobble."
+    `record` {
+      type = "object"
+      required = List("title", "artist", "album", "albumArtist", "duration", "createdAt")
+      properties {
+        ["title"] = new StringType {
+          type = "string"
+          description = "The title of the song."
+          minLength = 1
+          maxLength = 512
+        }
+
+        ["artist"] = new StringType {
+          type = "string"
+          description = "The artist of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["albumArtist"] = new StringType {
+          type = "string"
+          description = "The album artist of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["album"] = new StringType {
+          type = "string"
+          description = "The album of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["duration"] = new IntegerType {
+          type = "integer"
+          description = "The duration of the song in seconds."
+          minimum = 1
+        }
+
+        ["trackNumber"] = new IntegerType {
+          type = "integer"
+          description = "The track number of the song in the album."
+          minimum = 1
+        }
+
+        ["discNumber"] = new IntegerType {
+          type = "integer"
+          description = "The disc number of the song in the album."
+          minimum = 1
+        }
+
+        ["releaseDate"] = new StringType {
+          type = "string"
+          description = "The release date of the song."
+          format = "datetime"
+        }
+
+        ["year"] = new IntegerType {
+          type = "integer"
+          description = "The year the song was released."
+        }
+
+        ["genre"] = new StringType {
+          type = "string"
+          description = "The genre of the song."
+          maxLength = 256
+        }
+
+        ["tags"] = new Array {
+          type = "array"
+          description = "The tags of the song."
+          items = new StringType {
+            type = "string"
+            minLength = 1
+            maxLength = 256
+          }
+        }
+
+        ["composer"] = new StringType {
+          type = "string"
+          description = "The composer of the song."
+          maxLength = 256
+        }
+
+        ["lyrics"] = new StringType {
+          type = "string"
+          description = "The lyrics of the song."
+          maxLength = 10000
+        }
+
+        ["copyrightMessage"] = new StringType {
+          type = "string"
+          description = "The copyright message of the song."
+          maxLength = 256
+        }
+
+        ["wiki"] = new StringType {
+          type = "string"
+          description = "Informations about the song"
+          maxLength = 10000
+        }
+
+        ["albumArt"] = new Blob {
+          type = "blob"
+          description = "The album art of the song."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 2000000
+        }
+
+        ["youtubeLink"] = new StringType {
+          type = "string"
+          description = "The YouTube link of the song."
+          format = "uri"
+        }
+
+        ["spotifyLink"] = new StringType {
+          type = "string"
+          description = "The Spotify link of the song."
+          format = "uri"
+        }
+
+        ["tidalLink"] = new StringType {
+          type = "string"
+          description = "The Tidal link of the song."
+          format = "uri"
+        }
+
+        ["appleMusicLink"] = new StringType {
+          type = "string"
+          description = "The Apple Music link of the song."
+          format = "uri"
+        }
+
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date when the song was created."
+          format = "datetime"
+        }
+
+        ["mbid"] = new StringType {
+          type = "string"
+          description = "The MusicBrainz ID of the song."
+        }
+
+        ["label"] = new StringType {
+          type = "string"
+          description = "The label of the song."
+          maxLength = 256
+        }
+      }
+    }
+  }
+}

pkl/defs/shout/createShout.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.createShout"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Create a new shout"
+    input {
+      encoding = "application/json"
+      schema {
+        type = "object"
+        properties  {
+          ["message"] = new StringType {
+            type = "string"
+            description = "The content of the shout"
+            minLength = 1
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.shout.defs#shoutView"
+      }
+    }
+  }
+}

pkl/defs/shout/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.defs"
+defs = new Mapping<String, ObjectType> {
+  ["author"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the author."
+      }
+
+      ["did"] = new StringType {
+        type = "string"
+        format = "at-identifier"
+        description = "The decentralized identifier (DID) of the author."
+      }
+
+      ["handle"] = new StringType {
+        type = "string"
+        format = "at-identifier"
+        description = "The handle of the author."
+      }
+
+      ["displayName"] = new StringType {
+        type = "string"
+        description = "The display name of the author."
+      }
+
+      ["avatar"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the author's avatar image."
+      }
+    }
+  }
+  ["shoutView"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the shout."
+      }
+
+      ["message"] = new StringType {
+        type = "string"
+        description = "The content of the shout."
+      }
+
+      ["parent"] = new StringType {
+        type = "string"
+        description = "The ID of the parent shout if this is a reply, otherwise null."
+      }
+
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The date and time when the shout was created."
+      }
+
+      ["author"] = new Ref {
+        type = "ref"
+        description = "The author of the shout."
+        ref = "app.rocksky.shout.defs#author"
+      }
+    }
+  }
+}

pkl/defs/shout/getAlbumShouts.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.getAlbumShouts"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get shouts for an album"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The unique identifier of the album to retrieve shouts for"
+          format = "at-uri"
+        }
+        ["limit"] = new IntegerType {
+          description = "The maximum number of shouts to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          description = "The number of shouts to skip before starting to collect the result set"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["shouts"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.shout.defs#shoutViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/shout/getArtistShouts.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.getArtistShouts"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get shouts for an artist"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The URI of the artist to retrieve shouts for"
+          format = "at-uri"
+        }
+        ["limit"] = new IntegerType {
+          description = "The maximum number of shouts to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          description = "The number of shouts to skip before starting to collect the result set"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["shouts"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.shout.defs#shoutViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/shout/getProfileShouts.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.getProfileShouts"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get the shouts of an actor's profile"
+    parameters = new Params {
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          description = "The DID or handle of the actor"
+          format = "at-identifier"
+        }
+        ["offset"] = new IntegerType {
+          description = "The offset for pagination"
+          minimum = 0
+        }
+        ["limit"] = new IntegerType {
+          description = "The maximum number of shouts to return"
+          minimum = 1
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["shouts"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.shout.defs#shoutViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/shout/getShoutReplies.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.getShoutReplies"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get replies to a shout"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The URI of the shout to retrieve replies for"
+          format = "at-uri"
+        }
+        ["limit"] = new IntegerType {
+          description = "The maximum number of shouts to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          description = "The number of shouts to skip before starting to collect the result set"
+          minimum = 0
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["shouts"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.shout.defs#shoutViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/shout/getTrackShouts.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.getTrackShouts"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get all shouts for a specific track"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The URI of the track to retrieve shouts for"
+          format = "at-uri"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["shouts"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.shout.defs#shoutViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/shout/removeShout.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.removeShout"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Remove a shout by its ID"
+    parameters {
+      type = "params"
+      required = List("id")
+      properties = new Mapping<String, StringType> {
+        ["id"] {
+          type = "string"
+          description = "The ID of the shout to be removed"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.shout.defs#shoutView"
+      }
+    }
+  }
+}

pkl/defs/shout/replyShout.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.replyShout"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Reply to a shout"
+    input {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        required = List("shoutId", "message")
+        properties {
+          ["shoutId"] = new StringType {
+            type = "string"
+            description = "The unique identifier of the shout to reply to"
+          }
+          ["message"] = new StringType {
+            type = "string"
+            description = "The content of the reply"
+            minLength = 1
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.shout.defs#shoutView"
+      }
+    }
+  }
+}

pkl/defs/shout/reportShout.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout.reportShout"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Report a shout for moderation"
+    input {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        required = List("shoutId")
+        properties {
+          ["shoutId"] = new StringType {
+            type = "string"
+            description = "The unique identifier of the shout to report"
+          }
+          ["reason"] = new StringType {
+            type = "string"
+            description = "The reason for reporting the shout"
+            minLength = 1
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.shout.defs#shoutView"
+      }
+    }
+  }
+}

pkl/defs/shout/shout.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.shout"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of a shout."
+    `record` {
+      type = "object"
+      required = List("message", "createdAt", "subject")
+      properties {
+        ["message"] = new StringType {
+          type = "string"
+          description = "The message of the shout."
+          minLength = 1
+          maxLength = 1000
+        }
+
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date when the shout was created."
+          format = "datetime"
+        }
+
+        ["parent"] = new Ref {
+          type = "ref"
+          ref = "com.atproto.repo.strongRef"
+        }
+
+        ["subject"] = new Ref {
+          type = "ref"
+          ref = "com.atproto.repo.strongRef"
+        }
+      }
+    }
+  }
+}

pkl/defs/song/createSong.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.song.createSong"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Create a new song"
+    input {
+      encoding = "application/json"
+      schema {
+        type = "object"
+        required = List("title", "artist", "album", "albumArtist")
+        properties  {
+          ["title"] = new StringType {
+            type = "string"
+            description = "The title of the song"
+          }
+          ["artist"] = new StringType {
+            type = "string"
+            description = "The artist of the song"
+          }
+          ["albumArtist"] = new StringType {
+            type = "string"
+            description = "The album artist of the song, if different from the main artist"
+          }
+          ["album"] = new StringType {
+            type = "string"
+            description = "The album of the song, if applicable"
+          }
+          ["duration"] = new IntegerType {
+            type = "integer"
+            description = "The duration of the song in seconds"
+          }
+          ["mbId"] = new StringType {
+            type = "string"
+            description = "The MusicBrainz ID of the song, if available"
+          }
+          ["albumArt"] = new StringType {
+            type = "string"
+            description = "The URL of the album art for the song"
+            format = "uri"
+          }
+          ["trackNumber"] = new IntegerType {
+            type = "integer"
+            description = "The track number of the song in the album, if applicable"
+          }
+          ["releaseDate"] = new StringType {
+            type = "string"
+            description = "The release date of the song, formatted as YYYY-MM-DD"
+          }
+          ["year"] = new IntegerType {
+            type = "integer"
+            description = "The year the song was released"
+          }
+          ["discNumber"] = new IntegerType {
+            type = "integer"
+            description = "The disc number of the song in the album, if applicable"
+          }
+          ["lyrics"] = new StringType {
+            type = "string"
+            description = "The lyrics of the song, if available"
+          }
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.song.defs#songViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/song/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.song.defs"
+defs = new Mapping<String, ObjectType> {
+  ["songViewBasic"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the song."
+      }
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the song."
+      }
+      ["artist"] = new StringType {
+        type = "string"
+        description = "The artist of the song."
+      }
+      ["albumArtist"] = new StringType {
+        type = "string"
+        description = "The artist of the album the song belongs to."
+      }
+      ["albumArt"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the album art image."
+      }
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the song."
+      }
+      ["album"] = new StringType {
+        type = "string"
+        description = "The album of the song."
+      }
+      ["duration"] = new IntegerType {
+        type = "integer"
+        description = "The duration of the song in milliseconds."
+      }
+      ["trackNumber"] = new IntegerType {
+        type = "integer"
+        description = "The track number of the song in the album."
+      }
+      ["discNumber"] = new IntegerType {
+        type = "integer"
+        description = "The disc number of the song in the album."
+      }
+      ["playCount"] = new IntegerType {
+        type = "integer"
+        description = "The number of times the song has been played."
+        minimum = 0
+      }
+      ["uniqueListeners"] = new IntegerType {
+        type = "integer"
+        description = "The number of unique listeners who have played the song."
+        minimum = 0
+      }
+      ["albumUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the album the song belongs to."
+      }
+      ["artistUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the artist of the song."
+      }
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the song."
+      }
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The timestamp when the song was created."
+      }
+    }
+  }
+  ["songViewDetailed"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the song."
+      }
+      ["title"] = new StringType {
+        type = "string"
+        description = "The title of the song."
+      }
+      ["artist"] = new StringType {
+        type = "string"
+        description = "The artist of the song."
+      }
+      ["albumArtist"] = new StringType {
+        type = "string"
+        description = "The artist of the album the song belongs to."
+      }
+      ["albumArt"] = new StringType {
+        type = "string"
+        format = "uri"
+        description = "The URL of the album art image."
+      }
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the song."
+      }
+      ["album"] = new StringType {
+        type = "string"
+        description = "The album of the song."
+      }
+      ["duration"] = new IntegerType {
+        type = "integer"
+        description = "The duration of the song in milliseconds."
+      }
+      ["trackNumber"] = new IntegerType {
+        type = "integer"
+        description = "The track number of the song in the album."
+      }
+      ["discNumber"] = new IntegerType {
+        type = "integer"
+        description = "The disc number of the song in the album."
+      }
+      ["playCount"] = new IntegerType {
+        type = "integer"
+        description = "The number of times the song has been played."
+        minimum = 0
+      }
+      ["uniqueListeners"] = new IntegerType {
+        type = "integer"
+        description = "The number of unique listeners who have played the song."
+        minimum = 0
+      }
+      ["albumUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the album the song belongs to."
+      }
+      ["artistUri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+        description = "The URI of the artist of the song."
+      }
+      ["sha256"] = new StringType {
+        type = "string"
+        description = "The SHA256 hash of the song."
+      }
+      ["createdAt"] = new StringType {
+        type = "string"
+        format = "datetime"
+        description = "The timestamp when the song was created."
+      }
+    }
+  }
+}

pkl/defs/song/getSong.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.song.getSong"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get a song by its uri"
+    parameters = new Params {
+      required = List("uri")
+      properties {
+        ["uri"] = new StringType {
+          description = "The unique identifier of the song to retrieve"
+          format = "at-uri"
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.song.defs#songViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/song/getSongs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.song.getSongs"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get songs"
+    parameters = new Params {
+      properties {
+        ["limit"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of songs to return"
+          minimum = 1
+        }
+        ["offset"] = new IntegerType {
+          type = "integer"
+          description = "The offset for pagination"
+          minimum = 0
+        }
+      }
+    }
+   output {
+      encoding = "application/json"
+      schema = new ObjectType {
+        type = "object"
+        properties = new Mapping<String, Array> {
+          ["songs"] = new Array {
+            type = "array"
+            items = new Ref {
+              ref = "app.rocksky.song.defs#songViewBasic"
+            }
+          }
+        }
+      }
+    }
+  }
+}

pkl/defs/song/lovedSong.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.lovedSong"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of a song."
+    `record` {
+      type = "object"
+      required = List("title", "artist", "album", "duration", "createdAt")
+      properties {
+        ["title"] = new StringType {
+          type = "string"
+          description = "The title of the song."
+          minLength = 1
+          maxLength = 512
+        }
+
+        ["artist"] = new StringType {
+          type = "string"
+          description = "The artist of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["albumArtist"] = new StringType {
+          type = "string"
+          description = "The album artist of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["album"] = new StringType {
+          type = "string"
+          description = "The album of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["duration"] = new IntegerType {
+          type = "integer"
+          description = "The duration of the song in seconds."
+          minimum = 1
+        }
+
+        ["trackNumber"] = new IntegerType {
+          type = "integer"
+          description = "The track number of the song in the album."
+          minimum = 1
+        }
+
+        ["discNumber"] = new IntegerType {
+          type = "integer"
+          description = "The disc number of the song in the album."
+          minimum = 1
+        }
+
+        ["releaseDate"] = new StringType {
+          type = "string"
+          description = "The release date of the song."
+          format = "datetime"
+        }
+
+        ["year"] = new IntegerType {
+          type = "integer"
+          description = "The year the song was released."
+        }
+
+        ["genre"] = new StringType {
+          type = "string"
+          description = "The genre of the song."
+          maxLength = 256
+        }
+
+        ["tags"] = new Array {
+          type = "array"
+          description = "The tags of the song."
+          items = new StringType {
+            type = "string"
+            minLength = 1
+            maxLength = 256
+          }
+        }
+
+        ["composer"] = new StringType {
+          type = "string"
+          description = "The composer of the song."
+          maxLength = 256
+        }
+
+        ["lyrics"] = new StringType {
+          type = "string"
+          description = "The lyrics of the song."
+          maxLength = 10000
+        }
+
+        ["copyrightMessage"] = new StringType {
+          type = "string"
+          description = "The copyright message of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["wiki"] = new StringType {
+          type = "string"
+          description = "Informations about the song"
+          maxLength = 10000
+        }
+
+        ["albumArt"] = new Blob {
+          type = "blob"
+          description = "The album art of the song."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 2000000
+        }
+
+        ["youtubeLink"] = new StringType {
+          type = "string"
+          description = "The YouTube link of the song."
+          format = "uri"
+        }
+
+        ["spotifyLink"] = new StringType {
+          type = "string"
+          description = "The Spotify link of the song."
+          format = "uri"
+        }
+
+        ["tidalLink"] = new StringType {
+          type = "string"
+          description = "The Tidal link of the song."
+          format = "uri"
+        }
+
+        ["appleMusicLink"] = new StringType {
+          type = "string"
+          description = "The Apple Music link of the song."
+          format = "uri"
+        }
+
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date when the song was created."
+          format = "datetime"
+        }
+      }
+    }
+  }
+}

pkl/defs/song/song.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.song"
+defs = new Mapping<String, Record> {
+  ["main"] {
+    type = "record"
+    key = "tid"
+    description = "A declaration of a song."
+    `record` {
+      type = "object"
+      required = List("title", "artist", "album", "albumArtist", "duration", "createdAt")
+      properties {
+        ["title"] = new StringType {
+          type = "string"
+          description = "The title of the song."
+          minLength = 1
+          maxLength = 512
+        }
+
+        ["artist"] = new StringType {
+          type = "string"
+          description = "The artist of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["albumArtist"] = new StringType {
+          type = "string"
+          description = "The album artist of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["album"] = new StringType {
+          type = "string"
+          description = "The album of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["duration"] = new IntegerType {
+          type = "integer"
+          description = "The duration of the song in seconds."
+          minimum = 1
+        }
+
+        ["trackNumber"] = new IntegerType {
+          type = "integer"
+          description = "The track number of the song in the album."
+          minimum = 1
+        }
+
+        ["discNumber"] = new IntegerType {
+          type = "integer"
+          description = "The disc number of the song in the album."
+          minimum = 1
+        }
+
+        ["releaseDate"] = new StringType {
+          type = "string"
+          description = "The release date of the song."
+          format = "datetime"
+        }
+
+        ["year"] = new IntegerType {
+          type = "integer"
+          description = "The year the song was released."
+        }
+
+        ["genre"] = new StringType {
+          type = "string"
+          description = "The genre of the song."
+          minLength = 1
+          maxLength = 256
+        }
+
+        ["tags"] = new Array {
+          type = "array"
+          description = "The tags of the song."
+          items = new StringType {
+            type = "string"
+            minLength = 1
+            maxLength = 256
+          }
+        }
+
+        ["composer"] = new StringType {
+          type = "string"
+          description = "The composer of the song."
+          maxLength = 256
+        }
+
+        ["lyrics"] = new StringType {
+          type = "string"
+          description = "The lyrics of the song."
+          maxLength = 10000
+        }
+
+        ["copyrightMessage"] = new StringType {
+          type = "string"
+          description = "The copyright message of the song."
+          maxLength = 256
+        }
+
+        ["wiki"] = new StringType {
+          type = "string"
+          description = "Informations about the song"
+          maxLength = 10000
+        }
+
+        ["albumArt"] = new Blob {
+          type = "blob"
+          description = "The album art of the song."
+          accept = List("image/png", "image/jpeg")
+          maxSize = 2000000
+        }
+
+        ["youtubeLink"] = new StringType {
+          type = "string"
+          description = "The YouTube link of the song."
+          format = "uri"
+        }
+
+        ["spotifyLink"] = new StringType {
+          type = "string"
+          description = "The Spotify link of the song."
+          format = "uri"
+        }
+
+        ["tidalLink"] = new StringType {
+          type = "string"
+          description = "The Tidal link of the song."
+          format = "uri"
+        }
+
+        ["appleMusicLink"] = new StringType {
+          type = "string"
+          description = "The Apple Music link of the song."
+          format = "uri"
+        }
+
+        ["createdAt"] = new StringType {
+          type = "string"
+          description = "The date when the song was created."
+          format = "datetime"
+        }
+
+        ["mbid"] = new StringType {
+          type = "string"
+          description = "The MusicBrainz ID of the song."
+        }
+
+        ["label"] = new StringType {
+          type = "string"
+          description = "The label of the song."
+          maxLength = 256
+        }
+      }
+    }
+  }
+}

pkl/defs/spotify/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.spotify.defs"
+defs = new Mapping<String, ObjectType> {
+  ["spotifyTrackView"] {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+        description = "The unique identifier of the Spotify track."
+      }
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the track."
+      }
+      ["artist"] = new StringType {
+        type = "string"
+        description = "The name of the artist."
+      }
+      ["album"] = new StringType {
+        type = "string"
+        description = "The name of the album."
+      }
+      ["duration"] = new IntegerType {
+        type = "integer"
+        description = "The duration of the track in milliseconds."
+      }
+      ["previewUrl"] = new StringType {
+        type = "string"
+        description = "A URL to a preview of the track."
+      }
+    }
+  }
+}

pkl/defs/spotify/getCurrentlyPlaying.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.spotify.getCurrentlyPlaying"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get the currently playing track"
+    parameters {
+      type = "params"
+      properties {
+        ["actor"] = new StringType {
+          type = "string"
+          format = "at-identifier"
+          description = "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user."
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.player.defs#currentlyPlayingViewDetailed"
+      }
+    }
+  }
+}

pkl/defs/spotify/next.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.spotify.next"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Play the next track in the queue"
+  }
+}

pkl/defs/spotify/pause.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.spotify.pause"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Pause the currently playing track"
+  }
+}

pkl/defs/spotify/play.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.spotify.play"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Resume playback of the currently paused track"
+  }
+}

pkl/defs/spotify/previous.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.spotify.previous"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Play the previous track in the queue"
+  }
+}

pkl/defs/spotify/seek.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.spotify.seek"
+defs = new Mapping<String, Procedure> {
+  ["main"] {
+    type = "procedure"
+    description = "Seek to a specific position in the currently playing track"
+    parameters {
+      type = "params"
+      required = List("position")
+      properties = new Mapping<String, IntegerType> {
+        ["position"] {
+          type = "integer"
+          description = "The position in seconds to seek to"
+        }
+      }
+    }
+  }
+}

pkl/defs/stats/defs.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.stats.defs"
+defs = new Mapping<String, ObjectType> {
+  ["statsView"] {
+    type = "object"
+    properties {
+      ["scrobbles"] = new IntegerType {
+        type = "integer"
+        description = "The total number of scrobbles."
+      }
+      ["artists"] = new IntegerType {
+        type = "integer"
+        description = "The total number of unique artists scrobbled."
+      }
+      ["lovedTracks"] = new IntegerType {
+        type = "integer"
+        description = "The total number of tracks marked as loved."
+      }
+      ["albums"] = new IntegerType {
+        type = "integer"
+        description = "The total number of unique albums scrobbled."
+      }
+      ["tracks"] = new IntegerType {
+        type = "integer"
+        description = "The total number of unique tracks scrobbled."
+      }
+    }
+  }
+}

pkl/defs/stats/getStats.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.stats.getStats"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    parameters {
+      type = "params"
+      required = List("did")
+      properties {
+        ["did"] = new StringType {
+          type = "string"
+          description = "The DID or handle of the user to get stats for."
+          format = "at-identifier"
+        }
+      }
+    }
+    output = new Output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.stats.defs#statsView"
+      }
+    }
+  }
+}

pkl/defs/strongRef.pkl

···
+amends  "../schema/lexicon.pkl"
+
+lexicon = 1
+id = "com.atproto.repo.strongRef"
+description = "A URI with a content-hash fingerprint."
+defs = new Mapping {
+  ["main"] = new ObjectType {
+    type = "object"
+    required = List("uri", "cid")
+    properties {
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+      }
+      ["cid"] = new StringType {
+        type = "string"
+        format = "cid"
+      }
+    }
+  }
+}

pkl/schema/lexicon.pkl

···
+
+open class BaseType {
+  type: String
+  description: String?
+}
+
+class StringType extends BaseType {
+  type: "string"
+  maxGraphemes: Int?
+  minLength: Int?
+  maxLength: Int?
+  format: "uri" | "datetime" | "cid" | "at-uri" | "at-identifier" | Null = null
+}
+
+class IntegerType extends BaseType {
+  type: "integer"
+  minimum: Int?
+}
+
+class Blob extends BaseType {
+  type: "blob"
+  accept: List<String>
+  maxSize: Int
+}
+
+class Array extends BaseType {
+  type: "array"
+  items: StringType | IntegerType | Blob | Ref | Union
+}
+
+class Params {
+  type: "params"
+  required: List<String>?
+  properties: Mapping<String, StringType | IntegerType | Blob | Ref | Array>
+}
+
+class ObjectType extends BaseType {
+  type: "object"
+  required: List<String>?
+  properties: Mapping<String, StringType | IntegerType | Blob | Ref | Union | Array>
+}
+
+class Union extends BaseType {
+  type: "union"
+  refs: List<String>
+}
+
+class Ref extends BaseType {
+  type: "ref"
+  ref: String
+}
+
+class Input {
+  encoding: "application/json"
+  schema: ObjectType
+}
+
+class Output {
+  encoding: "application/json" | "application/octet-stream"
+  schema: ObjectType | Ref | Array | Null = null
+}
+
+class Query extends BaseType {
+  type: "query"
+  parameters: Params
+  output: Output
+}
+
+class Procedure extends BaseType {
+  type: "procedure"
+  parameters: Params?
+  input: Input?
+  output: Output?
+}
+
+class Record extends BaseType {
+  type: "record"
+  key: String
+  `record`: ObjectType
+}
+
+lexicon: Int = 1
+id: String
+description: String?
+defs: Mapping<String, Procedure> | Mapping<String, Record> | Mapping<String, ObjectType> | Mapping<String, Query> | Mapping<String, Array> |  Mapping<String, ObjectType | Array> | Null = null
+
+

scripts/pkl.ts

···
+import chalk from "chalk";
+import { readdirSync, statSync } from "fs";
+import { join } from "path";
+import { $ } from "zx";
+
+function getPklFilesRecursive(dir: string): string[] {
+  const entries = readdirSync(dir);
+  const files: string[] = [];
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stats = statSync(fullPath);
+
+    if (stats.isDirectory()) {
+      files.push(...getPklFilesRecursive(fullPath));
+      continue;
+    }
+
+    if (entry.endsWith(".pkl")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+const files = await getPklFilesRecursive(join("pkl", "defs"));
+
+await Promise.all(
+  files.map(async (fullPath) => {
+    console.log(`pkl eval ${chalk.cyan(fullPath)}`);
+    await $`pkl eval -f json ${fullPath} > ${fullPath.replace(/\.pkl$/, ".json").replace(/pkl[\\\/]defs/g, "lexicons")}`;
+  })
+);

src/lexicon/index.ts

···
   type StreamAuthVerifier,
 } from '@atproto/xrpc-server'
 import { schemas } from './lexicons.js'
+import * as AppRockskyActorGetActorAlbums from './types/app/rocksky/actor/getActorAlbums.js'
+import * as AppRockskyActorGetActorArtists from './types/app/rocksky/actor/getActorArtists.js'
+import * as AppRockskyActorGetActorLovedSongs from './types/app/rocksky/actor/getActorLovedSongs.js'
+import * as AppRockskyActorGetActorPlaylists from './types/app/rocksky/actor/getActorPlaylists.js'
+import * as AppRockskyActorGetActorScrobbles from './types/app/rocksky/actor/getActorScrobbles.js'
+import * as AppRockskyActorGetActorSongs from './types/app/rocksky/actor/getActorSongs.js'
+import * as AppRockskyActorGetProfile from './types/app/rocksky/actor/getProfile.js'
+import * as AppRockskyAlbumGetAlbum from './types/app/rocksky/album/getAlbum.js'
+import * as AppRockskyAlbumGetAlbums from './types/app/rocksky/album/getAlbums.js'
+import * as AppRockskyAlbumGetAlbumTracks from './types/app/rocksky/album/getAlbumTracks.js'
+import * as AppRockskyApikeyCreateApikey from './types/app/rocksky/apikey/createApikey.js'
+import * as AppRockskyApikeyGetApikeys from './types/app/rocksky/apikey/getApikeys.js'
+import * as AppRockskyApikeyRemoveApikey from './types/app/rocksky/apikey/removeApikey.js'
+import * as AppRockskyApikeyUpdateApikey from './types/app/rocksky/apikey/updateApikey.js'
+import * as AppRockskyArtistGetArtistAlbums from './types/app/rocksky/artist/getArtistAlbums.js'
+import * as AppRockskyArtistGetArtist from './types/app/rocksky/artist/getArtist.js'
+import * as AppRockskyArtistGetArtists from './types/app/rocksky/artist/getArtists.js'
+import * as AppRockskyArtistGetArtistTracks from './types/app/rocksky/artist/getArtistTracks.js'
+import * as AppRockskyChartsGetScrobblesChart from './types/app/rocksky/charts/getScrobblesChart.js'
+import * as AppRockskyDropboxDownloadFile from './types/app/rocksky/dropbox/downloadFile.js'
+import * as AppRockskyDropboxGetFiles from './types/app/rocksky/dropbox/getFiles.js'
+import * as AppRockskyDropboxGetMetadata from './types/app/rocksky/dropbox/getMetadata.js'
+import * as AppRockskyDropboxGetTemporaryLink from './types/app/rocksky/dropbox/getTemporaryLink.js'
+import * as AppRockskyFeedGetNowPlayings from './types/app/rocksky/feed/getNowPlayings.js'
+import * as AppRockskyFeedSearch from './types/app/rocksky/feed/search.js'
+import * as AppRockskyGoogledriveDownloadFile from './types/app/rocksky/googledrive/downloadFile.js'
+import * as AppRockskyGoogledriveGetFile from './types/app/rocksky/googledrive/getFile.js'
+import * as AppRockskyGoogledriveGetFiles from './types/app/rocksky/googledrive/getFiles.js'
+import * as AppRockskyLikeDislikeShout from './types/app/rocksky/like/dislikeShout.js'
+import * as AppRockskyLikeDislikeSong from './types/app/rocksky/like/dislikeSong.js'
+import * as AppRockskyLikeLikeShout from './types/app/rocksky/like/likeShout.js'
+import * as AppRockskyLikeLikeSong from './types/app/rocksky/like/likeSong.js'
+import * as AppRockskyPlayerGetCurrentlyPlaying from './types/app/rocksky/player/getCurrentlyPlaying.js'
+import * as AppRockskyPlayerNext from './types/app/rocksky/player/next.js'
+import * as AppRockskyPlayerPause from './types/app/rocksky/player/pause.js'
+import * as AppRockskyPlayerPlay from './types/app/rocksky/player/play.js'
+import * as AppRockskyPlayerPrevious from './types/app/rocksky/player/previous.js'
+import * as AppRockskyPlayerSeek from './types/app/rocksky/player/seek.js'
+import * as AppRockskyPlaylistGetPlaylist from './types/app/rocksky/playlist/getPlaylist.js'
+import * as AppRockskyPlaylistGetPlaylists from './types/app/rocksky/playlist/getPlaylists.js'
+import * as AppRockskyScrobbleCreateScrobble from './types/app/rocksky/scrobble/createScrobble.js'
+import * as AppRockskyScrobbleGetScrobble from './types/app/rocksky/scrobble/getScrobble.js'
+import * as AppRockskyScrobbleGetScrobbles from './types/app/rocksky/scrobble/getScrobbles.js'
+import * as AppRockskyShoutCreateShout from './types/app/rocksky/shout/createShout.js'
+import * as AppRockskyShoutGetAlbumShouts from './types/app/rocksky/shout/getAlbumShouts.js'
+import * as AppRockskyShoutGetArtistShouts from './types/app/rocksky/shout/getArtistShouts.js'
+import * as AppRockskyShoutGetProfileShouts from './types/app/rocksky/shout/getProfileShouts.js'
+import * as AppRockskyShoutGetShoutReplies from './types/app/rocksky/shout/getShoutReplies.js'
+import * as AppRockskyShoutGetTrackShouts from './types/app/rocksky/shout/getTrackShouts.js'
+import * as AppRockskyShoutRemoveShout from './types/app/rocksky/shout/removeShout.js'
+import * as AppRockskyShoutReplyShout from './types/app/rocksky/shout/replyShout.js'
+import * as AppRockskyShoutReportShout from './types/app/rocksky/shout/reportShout.js'
+import * as AppRockskySongCreateSong from './types/app/rocksky/song/createSong.js'
+import * as AppRockskySongGetSong from './types/app/rocksky/song/getSong.js'
+import * as AppRockskySongGetSongs from './types/app/rocksky/song/getSongs.js'
+import * as AppRockskySpotifyGetCurrentlyPlaying from './types/app/rocksky/spotify/getCurrentlyPlaying.js'
+import * as AppRockskySpotifyNext from './types/app/rocksky/spotify/next.js'
+import * as AppRockskySpotifyPause from './types/app/rocksky/spotify/pause.js'
+import * as AppRockskySpotifyPlay from './types/app/rocksky/spotify/play.js'
+import * as AppRockskySpotifyPrevious from './types/app/rocksky/spotify/previous.js'
+import * as AppRockskySpotifySeek from './types/app/rocksky/spotify/seek.js'
+import * as AppRockskyStatsGetStats from './types/app/rocksky/stats/getStats.js'
 
 export function createServer(options?: XrpcOptions): Server {
   return new Server(options)
···
 export class Server {
   xrpc: XrpcServer
   app: AppNS
+  com: ComNS
 
   constructor(options?: XrpcOptions) {
     this.xrpc = createXrpcServer(schemas, options)
     this.app = new AppNS(this)
+    this.com = new ComNS(this)
   }
 }
 
 export class AppNS {
   _server: Server
   rocksky: AppRockskyNS
+  bsky: AppBskyNS
 
   constructor(server: Server) {
     this._server = server
     this.rocksky = new AppRockskyNS(server)
+    this.bsky = new AppBskyNS(server)
   }
 }
 
 export class AppRockskyNS {
+  _server: Server
+  actor: AppRockskyActorNS
+  album: AppRockskyAlbumNS
+  apikey: AppRockskyApikeyNS
+  artist: AppRockskyArtistNS
+  charts: AppRockskyChartsNS
+  dropbox: AppRockskyDropboxNS
+  feed: AppRockskyFeedNS
+  googledrive: AppRockskyGoogledriveNS
+  like: AppRockskyLikeNS
+  player: AppRockskyPlayerNS
+  playlist: AppRockskyPlaylistNS
+  scrobble: AppRockskyScrobbleNS
+  shout: AppRockskyShoutNS
+  song: AppRockskySongNS
+  spotify: AppRockskySpotifyNS
+  stats: AppRockskyStatsNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.actor = new AppRockskyActorNS(server)
+    this.album = new AppRockskyAlbumNS(server)
+    this.apikey = new AppRockskyApikeyNS(server)
+    this.artist = new AppRockskyArtistNS(server)
+    this.charts = new AppRockskyChartsNS(server)
+    this.dropbox = new AppRockskyDropboxNS(server)
+    this.feed = new AppRockskyFeedNS(server)
+    this.googledrive = new AppRockskyGoogledriveNS(server)
+    this.like = new AppRockskyLikeNS(server)
+    this.player = new AppRockskyPlayerNS(server)
+    this.playlist = new AppRockskyPlaylistNS(server)
+    this.scrobble = new AppRockskyScrobbleNS(server)
+    this.shout = new AppRockskyShoutNS(server)
+    this.song = new AppRockskySongNS(server)
+    this.spotify = new AppRockskySpotifyNS(server)
+    this.stats = new AppRockskyStatsNS(server)
+  }
+}
+
+export class AppRockskyActorNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getActorAlbums<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyActorGetActorAlbums.Handler<ExtractAuth<AV>>,
+      AppRockskyActorGetActorAlbums.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.actor.getActorAlbums' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getActorArtists<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyActorGetActorArtists.Handler<ExtractAuth<AV>>,
+      AppRockskyActorGetActorArtists.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.actor.getActorArtists' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getActorLovedSongs<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyActorGetActorLovedSongs.Handler<ExtractAuth<AV>>,
+      AppRockskyActorGetActorLovedSongs.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.actor.getActorLovedSongs' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getActorPlaylists<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyActorGetActorPlaylists.Handler<ExtractAuth<AV>>,
+      AppRockskyActorGetActorPlaylists.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.actor.getActorPlaylists' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getActorScrobbles<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyActorGetActorScrobbles.Handler<ExtractAuth<AV>>,
+      AppRockskyActorGetActorScrobbles.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.actor.getActorScrobbles' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getActorSongs<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyActorGetActorSongs.Handler<ExtractAuth<AV>>,
+      AppRockskyActorGetActorSongs.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.actor.getActorSongs' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getProfile<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyActorGetProfile.Handler<ExtractAuth<AV>>,
+      AppRockskyActorGetProfile.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.actor.getProfile' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyAlbumNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getAlbum<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyAlbumGetAlbum.Handler<ExtractAuth<AV>>,
+      AppRockskyAlbumGetAlbum.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.album.getAlbum' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getAlbums<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>,
+      AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.album.getAlbums' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getAlbumTracks<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>,
+      AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.album.getAlbumTracks' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyApikeyNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  createApikey<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyApikeyCreateApikey.Handler<ExtractAuth<AV>>,
+      AppRockskyApikeyCreateApikey.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.apikey.createApikey' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getApikeys<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyApikeyGetApikeys.Handler<ExtractAuth<AV>>,
+      AppRockskyApikeyGetApikeys.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.apikey.getApikeys' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  removeApikey<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyApikeyRemoveApikey.Handler<ExtractAuth<AV>>,
+      AppRockskyApikeyRemoveApikey.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.apikey.removeApikey' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  updateApikey<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyApikeyUpdateApikey.Handler<ExtractAuth<AV>>,
+      AppRockskyApikeyUpdateApikey.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.apikey.updateApikey' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyArtistNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getArtistAlbums<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.artist.getArtistAlbums' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getArtist<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.artist.getArtist' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getArtists<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.artist.getArtists' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getArtistTracks<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.artist.getArtistTracks' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyChartsNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getScrobblesChart<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyChartsGetScrobblesChart.Handler<ExtractAuth<AV>>,
+      AppRockskyChartsGetScrobblesChart.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.charts.getScrobblesChart' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyDropboxNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  downloadFile<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyDropboxDownloadFile.Handler<ExtractAuth<AV>>,
+      AppRockskyDropboxDownloadFile.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.dropbox.downloadFile' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getFiles<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyDropboxGetFiles.Handler<ExtractAuth<AV>>,
+      AppRockskyDropboxGetFiles.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.dropbox.getFiles' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getMetadata<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyDropboxGetMetadata.Handler<ExtractAuth<AV>>,
+      AppRockskyDropboxGetMetadata.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.dropbox.getMetadata' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getTemporaryLink<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyDropboxGetTemporaryLink.Handler<ExtractAuth<AV>>,
+      AppRockskyDropboxGetTemporaryLink.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.dropbox.getTemporaryLink' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyFeedNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getNowPlayings<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyFeedGetNowPlayings.Handler<ExtractAuth<AV>>,
+      AppRockskyFeedGetNowPlayings.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.feed.getNowPlayings' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  search<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyFeedSearch.Handler<ExtractAuth<AV>>,
+      AppRockskyFeedSearch.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.feed.search' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyGoogledriveNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  downloadFile<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyGoogledriveDownloadFile.Handler<ExtractAuth<AV>>,
+      AppRockskyGoogledriveDownloadFile.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.googledrive.downloadFile' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getFile<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyGoogledriveGetFile.Handler<ExtractAuth<AV>>,
+      AppRockskyGoogledriveGetFile.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.googledrive.getFile' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getFiles<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyGoogledriveGetFiles.Handler<ExtractAuth<AV>>,
+      AppRockskyGoogledriveGetFiles.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.googledrive.getFiles' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyLikeNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  dislikeShout<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyLikeDislikeShout.Handler<ExtractAuth<AV>>,
+      AppRockskyLikeDislikeShout.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.like.dislikeShout' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  dislikeSong<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyLikeDislikeSong.Handler<ExtractAuth<AV>>,
+      AppRockskyLikeDislikeSong.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.like.dislikeSong' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  likeShout<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyLikeLikeShout.Handler<ExtractAuth<AV>>,
+      AppRockskyLikeLikeShout.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.like.likeShout' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  likeSong<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyLikeLikeSong.Handler<ExtractAuth<AV>>,
+      AppRockskyLikeLikeSong.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.like.likeSong' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyPlayerNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getCurrentlyPlaying<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerGetCurrentlyPlaying.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerGetCurrentlyPlaying.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.player.getCurrentlyPlaying' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  next<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerNext.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerNext.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.player.next' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  pause<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerPause.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerPause.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.player.pause' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  play<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.player.play' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  previous<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerPrevious.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerPrevious.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.player.previous' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  seek<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerSeek.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerSeek.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.player.seek' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyPlaylistNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getPlaylist<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlaylistGetPlaylist.Handler<ExtractAuth<AV>>,
+      AppRockskyPlaylistGetPlaylist.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.playlist.getPlaylist' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getPlaylists<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlaylistGetPlaylists.Handler<ExtractAuth<AV>>,
+      AppRockskyPlaylistGetPlaylists.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.playlist.getPlaylists' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyScrobbleNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  createScrobble<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyScrobbleCreateScrobble.Handler<ExtractAuth<AV>>,
+      AppRockskyScrobbleCreateScrobble.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.scrobble.createScrobble' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getScrobble<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyScrobbleGetScrobble.Handler<ExtractAuth<AV>>,
+      AppRockskyScrobbleGetScrobble.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.scrobble.getScrobble' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getScrobbles<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyScrobbleGetScrobbles.Handler<ExtractAuth<AV>>,
+      AppRockskyScrobbleGetScrobbles.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.scrobble.getScrobbles' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyShoutNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  createShout<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutCreateShout.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutCreateShout.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.createShout' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getAlbumShouts<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutGetAlbumShouts.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutGetAlbumShouts.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.getAlbumShouts' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getArtistShouts<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutGetArtistShouts.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutGetArtistShouts.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.getArtistShouts' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getProfileShouts<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutGetProfileShouts.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutGetProfileShouts.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.getProfileShouts' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getShoutReplies<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutGetShoutReplies.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutGetShoutReplies.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.getShoutReplies' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getTrackShouts<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutGetTrackShouts.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutGetTrackShouts.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.getTrackShouts' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  removeShout<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutRemoveShout.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutRemoveShout.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.removeShout' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  replyShout<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutReplyShout.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutReplyShout.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.replyShout' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  reportShout<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyShoutReportShout.Handler<ExtractAuth<AV>>,
+      AppRockskyShoutReportShout.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.shout.reportShout' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskySongNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  createSong<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySongCreateSong.Handler<ExtractAuth<AV>>,
+      AppRockskySongCreateSong.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.song.createSong' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getSong<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySongGetSong.Handler<ExtractAuth<AV>>,
+      AppRockskySongGetSong.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.song.getSong' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getSongs<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySongGetSongs.Handler<ExtractAuth<AV>>,
+      AppRockskySongGetSongs.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.song.getSongs' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskySpotifyNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getCurrentlyPlaying<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySpotifyGetCurrentlyPlaying.Handler<ExtractAuth<AV>>,
+      AppRockskySpotifyGetCurrentlyPlaying.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.spotify.getCurrentlyPlaying' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  next<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySpotifyNext.Handler<ExtractAuth<AV>>,
+      AppRockskySpotifyNext.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.spotify.next' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  pause<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySpotifyPause.Handler<ExtractAuth<AV>>,
+      AppRockskySpotifyPause.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.spotify.pause' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  play<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySpotifyPlay.Handler<ExtractAuth<AV>>,
+      AppRockskySpotifyPlay.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.spotify.play' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  previous<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySpotifyPrevious.Handler<ExtractAuth<AV>>,
+      AppRockskySpotifyPrevious.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.spotify.previous' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  seek<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskySpotifySeek.Handler<ExtractAuth<AV>>,
+      AppRockskySpotifySeek.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.spotify.seek' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppRockskyStatsNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getStats<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyStatsGetStats.Handler<ExtractAuth<AV>>,
+      AppRockskyStatsGetStats.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.rocksky.stats.getStats' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppBskyNS {
+  _server: Server
+  actor: AppBskyActorNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.actor = new AppBskyActorNS(server)
+  }
+}
+
+export class AppBskyActorNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}
+
+export class ComNS {
+  _server: Server
+  atproto: ComAtprotoNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.atproto = new ComAtprotoNS(server)
+  }
+}
+
+export class ComAtprotoNS {
+  _server: Server
+  repo: ComAtprotoRepoNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.repo = new ComAtprotoRepoNS(server)
+  }
+}
+
+export class ComAtprotoRepoNS {
   _server: Server
 
   constructor(server: Server) {

src/lexicon/lexicons.ts

···
 import { type $Typed, is$typed, maybe$typed } from './util.js'
 
 export const schemaDict = {
+  AppRockskyActorDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.defs',
+    defs: {
+      profileViewDetailed: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the actor.',
+          },
+          did: {
+            type: 'string',
+            description: 'The DID of the actor.',
+          },
+          handle: {
+            type: 'string',
+            description: 'The handle of the actor.',
+          },
+          displayName: {
+            type: 'string',
+            description: 'The display name of the actor.',
+          },
+          avatar: {
+            type: 'string',
+            description: "The URL of the actor's avatar image.",
+            format: 'uri',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the actor was created.',
+            format: 'datetime',
+          },
+          updatedAt: {
+            type: 'string',
+            description: 'The date and time when the actor was last updated.',
+            format: 'datetime',
+          },
+        },
+      },
+      profileViewBasic: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the actor.',
+          },
+          did: {
+            type: 'string',
+            description: 'The DID of the actor.',
+          },
+          handle: {
+            type: 'string',
+            description: 'The handle of the actor.',
+          },
+          displayName: {
+            type: 'string',
+            description: 'The display name of the actor.',
+          },
+          avatar: {
+            type: 'string',
+            description: "The URL of the actor's avatar image.",
+            format: 'uri',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the actor was created.',
+            format: 'datetime',
+          },
+          updatedAt: {
+            type: 'string',
+            description: 'The date and time when the actor was last updated.',
+            format: 'datetime',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyActorGetActorAlbums: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.getActorAlbums',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get albums for an actor',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of albums to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              albums: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.album.defs#albumViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyActorGetActorArtists: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.getActorArtists',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get artists for an actor',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of albums to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              artists: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.artist.defs#artistViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyActorGetActorLovedSongs: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.getActorLovedSongs',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get loved songs for an actor',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of albums to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              tracks: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.song.defs#songViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyActorGetActorPlaylists: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.getActorPlaylists',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get playlists for an actor',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of albums to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              playlists: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.playlist.defs#playlistViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyActorGetActorScrobbles: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.getActorScrobbles',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get scrobbles for an actor',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of albums to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              scrobbles: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyActorGetActorSongs: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.getActorSongs',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get songs for an actor',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of albums to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              songs: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.song.defs#songViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyActorGetProfile: {
+    lexicon: 1,
+    id: 'app.rocksky.actor.getProfile',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get the profile of an actor',
+        parameters: {
+          type: 'params',
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.actor.defs#profileViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppBskyActorProfile: {
+    lexicon: 1,
+    id: 'app.bsky.actor.profile',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a Bluesky account profile.',
+        key: 'literal:self',
+        record: {
+          type: 'object',
+          properties: {
+            displayName: {
+              type: 'string',
+              maxGraphemes: 64,
+              maxLength: 640,
+            },
+            description: {
+              type: 'string',
+              description: 'Free-form profile description text.',
+              maxGraphemes: 256,
+              maxLength: 2560,
+            },
+            avatar: {
+              type: 'blob',
+              description:
+                "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            banner: {
+              type: 'blob',
+              description:
+                'Larger horizontal image to display behind profile view.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 10000000,
+            },
+            labels: {
+              type: 'union',
+              description:
+                'Self-label values, specific to the Bluesky application, on the overall account.',
+              refs: ['lex:com.atproto.label.defs#selfLabels'],
+            },
+            joinedViaStarterPack: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
   AppRockskyAlbum: {
     lexicon: 1,
     id: 'app.rocksky.album',
     defs: {
       main: {
         type: 'record',
-        key: 'tid',
         description: 'A declaration of an album.',
+        key: 'tid',
         record: {
           type: 'object',
           required: ['title', 'artist', 'createdAt'],
···
             },
             tidalLink: {
               type: 'string',
-              description: 'The Tidal link of the album.',
+              description: 'The tidal link of the album.',
               format: 'uri',
             },
             appleMusicLink: {
···
             },
             createdAt: {
               type: 'string',
-              description: 'The date the song was created.',
+              description: 'The date and time when the album was created.',
               format: 'datetime',
             },
           },
···
       },
     },
   },
+  AppRockskyAlbumDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.album.defs',
+    defs: {
+      albumViewBasic: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the album.',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the album.',
+            format: 'at-uri',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the album.',
+          },
+          artist: {
+            type: 'string',
+            description: 'The artist of the album.',
+          },
+          artistUri: {
+            type: 'string',
+            description: "The URI of the album's artist.",
+            format: 'at-uri',
+          },
+          year: {
+            type: 'integer',
+            description: 'The year the album was released.',
+          },
+          albumArt: {
+            type: 'string',
+            description: 'The URL of the album art image.',
+            format: 'uri',
+          },
+          releaseDate: {
+            type: 'string',
+            description: 'The release date of the album.',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the album.',
+          },
+          playCount: {
+            type: 'integer',
+            description: 'The number of times the album has been played.',
+            minimum: 0,
+          },
+          uniqueListeners: {
+            type: 'integer',
+            description:
+              'The number of unique listeners who have played the album.',
+            minimum: 0,
+          },
+        },
+      },
+      albumViewDetailed: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the album.',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the album.',
+            format: 'at-uri',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the album.',
+          },
+          artist: {
+            type: 'string',
+            description: 'The artist of the album.',
+          },
+          artistUri: {
+            type: 'string',
+            description: "The URI of the album's artist.",
+            format: 'at-uri',
+          },
+          year: {
+            type: 'integer',
+            description: 'The year the album was released.',
+          },
+          albumArt: {
+            type: 'string',
+            description: 'The URL of the album art image.',
+            format: 'uri',
+          },
+          releaseDate: {
+            type: 'string',
+            description: 'The release date of the album.',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the album.',
+          },
+          playCount: {
+            type: 'integer',
+            description: 'The number of times the album has been played.',
+            minimum: 0,
+          },
+          uniqueListeners: {
+            type: 'integer',
+            description:
+              'The number of unique listeners who have played the album.',
+            minimum: 0,
+          },
+          tracks: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.rocksky.song.defs.songViewBasic',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyAlbumGetAlbum: {
+    lexicon: 1,
+    id: 'app.rocksky.album.getAlbum',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get detailed album view',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the album to retrieve.',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.album.defs#albumViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyAlbumGetAlbums: {
+    lexicon: 1,
+    id: 'app.rocksky.album.getAlbums',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get albums',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of albums to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              albums: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.album.defs#albumViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyAlbumGetAlbumTracks: {
+    lexicon: 1,
+    id: 'app.rocksky.album.getAlbumTracks',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get tracks for an album',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the album to retrieve tracks from',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              tracks: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.song.defs#songViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyApikeyCreateApikey: {
+    lexicon: 1,
+    id: 'app.rocksky.apikey.createApikey',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new API key for the authenticated user',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['name'],
+            properties: {
+              name: {
+                type: 'string',
+                description: 'The name of the API key.',
+              },
+              description: {
+                type: 'string',
+                description: 'A description for the API key.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.apikey.defs#apiKey',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyApikeyDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.apikey.defs',
+    defs: {
+      apiKeyView: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the API key.',
+          },
+          name: {
+            type: 'string',
+            description: 'The name of the API key.',
+          },
+          description: {
+            type: 'string',
+            description: 'A description for the API key.',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the API key was created.',
+            format: 'datetime',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyApikeysDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.apikeys.defs',
+    defs: {},
+  },
+  AppRockskyApikeyGetApikeys: {
+    lexicon: 1,
+    id: 'app.rocksky.apikey.getApikeys',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a list of API keys for the authenticated user',
+        parameters: {
+          type: 'params',
+          properties: {
+            offset: {
+              type: 'integer',
+              description:
+                'The number of API keys to skip before starting to collect the result set.',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The number of API keys to return per page.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              apiKeys: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.apikey.defs#apikeyView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyApikeyRemoveApikey: {
+    lexicon: 1,
+    id: 'app.rocksky.apikey.removeApikey',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Remove an API key for the authenticated user',
+        parameters: {
+          type: 'params',
+          required: ['id'],
+          properties: {
+            id: {
+              type: 'string',
+              description: 'The ID of the API key to remove.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.apikey.defs#apiKey',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyApikeyUpdateApikey: {
+    lexicon: 1,
+    id: 'app.rocksky.apikey.updateApikey',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Update an existing API key for the authenticated user',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['id', 'name'],
+            properties: {
+              id: {
+                type: 'string',
+                description: 'The ID of the API key to update.',
+              },
+              name: {
+                type: 'string',
+                description: 'The new name of the API key.',
+              },
+              description: {
+                type: 'string',
+                description: 'A new description for the API key.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.apikey.defs#apiKey',
+          },
+        },
+      },
+    },
+  },
   AppRockskyArtist: {
     lexicon: 1,
     id: 'app.rocksky.artist',
     defs: {
       main: {
         type: 'record',
-        key: 'tid',
         description: 'A declaration of an artist.',
+        key: 'tid',
         record: {
           type: 'object',
           required: ['name', 'createdAt'],
···
             },
             createdAt: {
               type: 'string',
-              description: 'The date the song was created.',
+              description: 'The date when the artist was created.',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyArtistDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.artist.defs',
+    defs: {
+      artistViewBasic: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the artist.',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the artist.',
+            format: 'at-uri',
+          },
+          name: {
+            type: 'string',
+            description: 'The name of the artist.',
+          },
+          picture: {
+            type: 'string',
+            description: 'The picture of the artist.',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the artist.',
+          },
+          playCount: {
+            type: 'integer',
+            description: 'The number of times the artist has been played.',
+            minimum: 0,
+          },
+          uniqueListeners: {
+            type: 'integer',
+            description:
+              'The number of unique listeners who have played the artist.',
+            minimum: 0,
+          },
+        },
+      },
+      artistViewDetailed: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the artist.',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the artist.',
+            format: 'at-uri',
+          },
+          name: {
+            type: 'string',
+            description: 'The name of the artist.',
+          },
+          picture: {
+            type: 'string',
+            description: 'The picture of the artist.',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the artist.',
+          },
+          playCount: {
+            type: 'integer',
+            description: 'The number of times the artist has been played.',
+            minimum: 0,
+          },
+          uniqueListeners: {
+            type: 'integer',
+            description:
+              'The number of unique listeners who have played the artist.',
+            minimum: 0,
+          },
+        },
+      },
+    },
+  },
+  AppRockskyArtistGetArtistAlbums: {
+    lexicon: 1,
+    id: 'app.rocksky.artist.getArtistAlbums',
+    defs: {
+      main: {
+        type: 'query',
+        description: "Get artist's albums",
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the artist to retrieve albums from',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              albums: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.album.defs#albumViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyArtistGetArtist: {
+    lexicon: 1,
+    id: 'app.rocksky.artist.getArtist',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get artist details',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the artist to retrieve details from',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.artist.defs#artistViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyArtistGetArtists: {
+    lexicon: 1,
+    id: 'app.rocksky.artist.getArtists',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get artists',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of artists to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              artists: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.artist.defs#artistViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyArtistGetArtistTracks: {
+    lexicon: 1,
+    id: 'app.rocksky.artist.getArtistTracks',
+    defs: {
+      main: {
+        type: 'query',
+        description: "Get artist's tracks",
+        parameters: {
+          type: 'params',
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the artist to retrieve albums from',
+              format: 'at-uri',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of tracks to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              tracks: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.song.defs#songViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyChartsDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.charts.defs',
+    defs: {
+      chartsView: {
+        type: 'object',
+        properties: {
+          scrobbles: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.rocksky.charts.defs#scrobbleViewBasic',
+            },
+          },
+        },
+      },
+      scrobbleViewBasic: {
+        type: 'object',
+        properties: {
+          date: {
+            type: 'string',
+            description: 'The date of the scrobble.',
+            format: 'datetime',
+          },
+          count: {
+            type: 'integer',
+            description: 'The number of scrobbles on this date.',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyChartsGetScrobblesChart: {
+    lexicon: 1,
+    id: 'app.rocksky.charts.getScrobblesChart',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get the scrobbles chart',
+        parameters: {
+          type: 'params',
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            artisturi: {
+              type: 'string',
+              description: 'The URI of the artist to filter by',
+              format: 'at-uri',
+            },
+            albumuri: {
+              type: 'string',
+              description: 'The URI of the album to filter by',
+              format: 'at-uri',
+            },
+            songuri: {
+              type: 'string',
+              description: 'The URI of the track to filter by',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.charts.defs#chartsView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyDropboxDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.dropbox.defs',
+    defs: {
+      fileView: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the file.',
+          },
+          name: {
+            type: 'string',
+            description: 'The name of the file.',
+          },
+          pathLower: {
+            type: 'string',
+            description: 'The lowercased path of the file.',
+          },
+          pathDisplay: {
+            type: 'string',
+            description: 'The display path of the file.',
+          },
+          clientModified: {
+            type: 'string',
+            description:
+              'The last modified date and time of the file on the client.',
+            format: 'datetime',
+          },
+          serverModified: {
+            type: 'string',
+            description:
+              'The last modified date and time of the file on the server.',
+            format: 'datetime',
+          },
+        },
+      },
+      fileListView: {
+        type: 'object',
+        properties: {
+          files: {
+            type: 'array',
+            description: 'A list of files in the Dropbox.',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.rocksky.dropbox.defs#fileView',
+            },
+          },
+        },
+      },
+      temporaryLinkView: {
+        type: 'object',
+        properties: {
+          link: {
+            type: 'string',
+            description: 'The temporary link to access the file.',
+            format: 'uri',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyDropboxDownloadFile: {
+    lexicon: 1,
+    id: 'app.rocksky.dropbox.downloadFile',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Download a file from Dropbox by its unique identifier',
+        parameters: {
+          type: 'params',
+          required: ['fileId'],
+          properties: {
+            fileId: {
+              type: 'string',
+              description: 'The unique identifier of the file to download',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/octet-stream',
+        },
+      },
+    },
+  },
+  AppRockskyDropboxGetFiles: {
+    lexicon: 1,
+    id: 'app.rocksky.dropbox.getFiles',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Retrieve a list of files from Dropbox',
+        parameters: {
+          type: 'params',
+          properties: {
+            at: {
+              type: 'string',
+              description: 'Path to the Dropbox folder or root directory',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.dropbox.defs#fileListView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyDropboxGetMetadata: {
+    lexicon: 1,
+    id: 'app.rocksky.dropbox.getMetadata',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Retrieve metadata of a file or folder in Dropbox',
+        parameters: {
+          type: 'params',
+          required: ['path'],
+          properties: {
+            path: {
+              type: 'string',
+              description: 'Path to the file or folder in Dropbox',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.dropbox.defs#fileView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyDropboxGetTemporaryLink: {
+    lexicon: 1,
+    id: 'app.rocksky.dropbox.getTemporaryLink',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Retrieve a temporary link to access a file in Dropbox',
+        parameters: {
+          type: 'params',
+          required: ['path'],
+          properties: {
+            path: {
+              type: 'string',
+              description: 'Path to the file in Dropbox',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.dropbox.defs#temporaryLinkView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyFeedDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.feed.defs',
+    defs: {
+      searchResultsView: {
+        type: 'object',
+        properties: {
+          hits: {
+            type: 'array',
+            items: {
+              type: 'union',
+              refs: [
+                'lex:app.rocksky.song.defs#songViewBasic',
+                'lex:app.rocksky.album.defs#albumViewBasic',
+                'lex:app.rocksky.artist.defs#artistViewBasic',
+                'lex:app.rocksky.playlist.defs#playlistViewBasic',
+                'lex:app.rocksky.actor.defs#profileViewBasic',
+              ],
+            },
+          },
+          processingTimeMs: {
+            type: 'integer',
+          },
+          limit: {
+            type: 'integer',
+          },
+          offset: {
+            type: 'integer',
+          },
+          estimatedTotalHits: {
+            type: 'integer',
+          },
+        },
+      },
+      nowPlayingView: {
+        type: 'object',
+        properties: {
+          album: {
+            type: 'string',
+          },
+          albumArt: {
+            type: 'string',
+            format: 'uri',
+          },
+          albumArtist: {
+            type: 'string',
+          },
+          albumUri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          artist: {
+            type: 'string',
+          },
+          artistUri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          avatar: {
+            type: 'string',
+            format: 'uri',
+          },
+          createdAt: {
+            type: 'string',
+          },
+          did: {
+            type: 'string',
+            format: 'at-identifier',
+          },
+          handle: {
+            type: 'string',
+          },
+          id: {
+            type: 'string',
+          },
+          title: {
+            type: 'string',
+          },
+          trackId: {
+            type: 'string',
+          },
+          trackUri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+        },
+      },
+      nowPlayingsView: {
+        type: 'object',
+        properties: {
+          nowPlayings: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.rocksky.feed.defs#nowPlayingView',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyFeedGetNowPlayings: {
+    lexicon: 1,
+    id: 'app.rocksky.feed.getNowPlayings',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get all currently playing tracks by users',
+        parameters: {
+          type: 'params',
+          properties: {
+            size: {
+              type: 'integer',
+              description:
+                'The maximum number of now playing tracks to return.',
+              minimum: 1,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.feed.defs#nowPlayingsView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyFeedSearch: {
+    lexicon: 1,
+    id: 'app.rocksky.feed.search',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Search for content in the feed',
+        parameters: {
+          type: 'params',
+          required: ['query'],
+          properties: {
+            query: {
+              type: 'string',
+              description: 'The search query string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.feed.defs#searchResultsView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyGoogledriveDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.googledrive.defs',
+    defs: {
+      fileView: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the file.',
+          },
+        },
+      },
+      fileListView: {
+        type: 'object',
+        properties: {
+          files: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.rocksky.googledrive.defs#fileView',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyGoogledriveDownloadFile: {
+    lexicon: 1,
+    id: 'app.rocksky.googledrive.downloadFile',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Download a file from Google Drive by its unique identifier',
+        parameters: {
+          type: 'params',
+          required: ['fileId'],
+          properties: {
+            fileId: {
+              type: 'string',
+              description: 'The unique identifier of the file to download',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/octet-stream',
+        },
+      },
+    },
+  },
+  AppRockskyGoogledriveGetFile: {
+    lexicon: 1,
+    id: 'app.rocksky.googledrive.getFile',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a file from Google Drive by its unique identifier',
+        parameters: {
+          type: 'params',
+          required: ['fileId'],
+          properties: {
+            fileId: {
+              type: 'string',
+              description: 'The unique identifier of the file to retrieve',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.googledrive.defs#fileView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyGoogledriveGetFiles: {
+    lexicon: 1,
+    id: 'app.rocksky.googledrive.getFiles',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a list of files from Google Drive',
+        parameters: {
+          type: 'params',
+          properties: {
+            at: {
+              type: 'string',
+              description: 'Path to the Google Drive folder or root directory',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.googledrive.defs#fileListView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyLikeDislikeShout: {
+    lexicon: 1,
+    id: 'app.rocksky.like.dislikeShout',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Dislike a shout',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              uri: {
+                type: 'string',
+                description: 'The unique identifier of the shout to dislike',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.shout.defs#shoutView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyLikeDislikeSong: {
+    lexicon: 1,
+    id: 'app.rocksky.like.dislikeSong',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Dislike a song',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              uri: {
+                type: 'string',
+                description: 'The unique identifier of the song to dislike',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.song.defs#songViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyLike: {
+    lexicon: 1,
+    id: 'app.rocksky.like',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a like.',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['createdAt', 'subject'],
+          properties: {
+            createdAt: {
+              type: 'string',
+              description: 'The date when the like was created.',
+              format: 'datetime',
+            },
+            subject: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyLikeLikeShout: {
+    lexicon: 1,
+    id: 'app.rocksky.like.likeShout',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Like a shout',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              uri: {
+                type: 'string',
+                description: 'The unique identifier of the shout to like',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.shout.defs#shoutView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyLikeLikeSong: {
+    lexicon: 1,
+    id: 'app.rocksky.like.likeSong',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Like a song',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              uri: {
+                type: 'string',
+                description: 'The unique identifier of the song to like',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.song.defs#songViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyPlayerDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.player.defs',
+    defs: {
+      currentlyPlayingViewDetailed: {
+        type: 'object',
+        properties: {
+          title: {
+            type: 'string',
+            description: 'The title of the currently playing track',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyPlayerGetCurrentlyPlaying: {
+    lexicon: 1,
+    id: 'app.rocksky.player.getCurrentlyPlaying',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get the currently playing track',
+        parameters: {
+          type: 'params',
+          properties: {
+            actor: {
+              type: 'string',
+              description:
+                'Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.',
+              format: 'at-identifier',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.player.defs#currentlyPlayingViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyPlayerNext: {
+    lexicon: 1,
+    id: 'app.rocksky.player.next',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Play the next track in the queue',
+      },
+    },
+  },
+  AppRockskyPlayerPause: {
+    lexicon: 1,
+    id: 'app.rocksky.player.pause',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Pause the currently playing track',
+      },
+    },
+  },
+  AppRockskyPlayerPlay: {
+    lexicon: 1,
+    id: 'app.rocksky.player.play',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Resume playback of the currently paused track',
+      },
+    },
+  },
+  AppRockskyPlayerPrevious: {
+    lexicon: 1,
+    id: 'app.rocksky.player.previous',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Play the previous track in the queue',
+      },
+    },
+  },
+  AppRockskyPlayerSeek: {
+    lexicon: 1,
+    id: 'app.rocksky.player.seek',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Seek to a specific position in the currently playing track',
+        parameters: {
+          type: 'params',
+          required: ['position'],
+          properties: {
+            position: {
+              type: 'integer',
+              description: 'The position in seconds to seek to',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyPlaylistDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.playlist.defs',
+    defs: {
+      playlistViewDetailed: {
+        type: 'object',
+        description:
+          'Detailed view of a playlist, including its tracks and metadata',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the playlist.',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the playlist.',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the playlist.',
+            format: 'at-uri',
+          },
+          curatorDid: {
+            type: 'string',
+            description: 'The DID of the curator of the playlist.',
+            format: 'at-identifier',
+          },
+          curatorHandle: {
+            type: 'string',
+            description: 'The handle of the curator of the playlist.',
+            format: 'at-identifier',
+          },
+          curatorName: {
+            type: 'string',
+            description: 'The name of the curator of the playlist.',
+          },
+          curatorAvatarUrl: {
+            type: 'string',
+            description: 'The URL of the avatar image of the curator.',
+            format: 'uri',
+          },
+          description: {
+            type: 'string',
+            description: 'A description of the playlist.',
+          },
+          coverImageUrl: {
+            type: 'string',
+            description: 'The URL of the cover image for the playlist.',
+            format: 'uri',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the playlist was created.',
+            format: 'datetime',
+          },
+          tracks: {
+            type: 'array',
+            description: 'A list of tracks in the playlist.',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.rocksky.song.defs#songViewBasic',
+            },
+          },
+        },
+      },
+      playlistViewBasic: {
+        type: 'object',
+        description: 'Basic view of a playlist, including its metadata',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the playlist.',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the playlist.',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the playlist.',
+            format: 'at-uri',
+          },
+          curatorDid: {
+            type: 'string',
+            description: 'The DID of the curator of the playlist.',
+            format: 'at-identifier',
+          },
+          curatorHandle: {
+            type: 'string',
+            description: 'The handle of the curator of the playlist.',
+            format: 'at-identifier',
+          },
+          curatorName: {
+            type: 'string',
+            description: 'The name of the curator of the playlist.',
+          },
+          curatorAvatarUrl: {
+            type: 'string',
+            description: 'The URL of the avatar image of the curator.',
+            format: 'uri',
+          },
+          description: {
+            type: 'string',
+            description: 'A description of the playlist.',
+          },
+          coverImageUrl: {
+            type: 'string',
+            description: 'The URL of the cover image for the playlist.',
+            format: 'uri',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the playlist was created.',
+            format: 'datetime',
+          },
+          trackCount: {
+            type: 'integer',
+            description: 'The number of tracks in the playlist.',
+            minimum: 0,
+          },
+        },
+      },
+    },
+  },
+  AppRockskyPlaylistGetPlaylist: {
+    lexicon: 1,
+    id: 'app.rocksky.playlist.getPlaylist',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Retrieve a playlist by its ID',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the playlist to retrieve.',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.playlist.defs#playlistViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyPlaylistGetPlaylists: {
+    lexicon: 1,
+    id: 'app.rocksky.playlist.getPlaylists',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Retrieve a list of playlists',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of playlists to return.',
+            },
+            offset: {
+              type: 'integer',
+              description:
+                'The offset for pagination, used to skip a number of playlists.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              playlists: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.playlist.defs#playlistViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyPlaylist: {
+    lexicon: 1,
+    id: 'app.rocksky.playlist',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a playlist.',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['name', 'createdAt'],
+          properties: {
+            name: {
+              type: 'string',
+              description: 'The name of the playlist.',
+              minLength: 1,
+              maxLength: 512,
+            },
+            description: {
+              type: 'string',
+              description: 'The playlist description.',
+              minLength: 1,
+              maxLength: 256,
+            },
+            picture: {
+              type: 'blob',
+              description: 'The picture of the playlist.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 2000000,
+            },
+            tracks: {
+              type: 'array',
+              description: 'The tracks in the playlist.',
+              items: {
+                type: 'ref',
+                ref: 'lex:app.rocksky.song#record',
+              },
+            },
+            createdAt: {
+              type: 'string',
+              description: 'The date the playlist was created.',
+              format: 'datetime',
+            },
+            spotifyLink: {
+              type: 'string',
+              description: 'The Spotify link of the playlist.',
+            },
+            tidalLink: {
+              type: 'string',
+              description: 'The Tidal link of the playlist.',
+            },
+            youtubeLink: {
+              type: 'string',
+              description: 'The YouTube link of the playlist.',
+            },
+            appleMusicLink: {
+              type: 'string',
+              description: 'The Apple Music link of the playlist.',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyRadioDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.radio.defs',
+    defs: {
+      radioViewBasic: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the radio.',
+          },
+          name: {
+            type: 'string',
+            description: 'The name of the radio.',
+          },
+          description: {
+            type: 'string',
+            description: 'A brief description of the radio.',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the radio was created.',
+            format: 'datetime',
+          },
+        },
+      },
+      radioViewDetailed: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the radio.',
+          },
+          name: {
+            type: 'string',
+            description: 'The name of the radio.',
+          },
+          description: {
+            type: 'string',
+            description: 'A brief description of the radio.',
+          },
+          website: {
+            type: 'string',
+            description: 'The website of the radio.',
+            format: 'uri',
+          },
+          url: {
+            type: 'string',
+            description: 'The streaming URL of the radio.',
+            format: 'uri',
+          },
+          genre: {
+            type: 'string',
+            description: 'The genre of the radio.',
+          },
+          logo: {
+            type: 'string',
+            description: 'The logo of the radio station.',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the radio was created.',
+            format: 'datetime',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyRadio: {
+    lexicon: 1,
+    id: 'app.rocksky.radio',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a radio station.',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['name', 'url', 'createdAt'],
+          properties: {
+            name: {
+              type: 'string',
+              description: 'The name of the radio station.',
+              minLength: 1,
+              maxLength: 512,
+            },
+            url: {
+              type: 'string',
+              description: 'The URL of the radio station.',
+              format: 'uri',
+            },
+            description: {
+              type: 'string',
+              description: 'A description of the radio station.',
+              minLength: 1,
+              maxLength: 1000,
+            },
+            genre: {
+              type: 'string',
+              description: 'The genre of the radio station.',
+              minLength: 1,
+              maxLength: 256,
+            },
+            logo: {
+              type: 'blob',
+              description: 'The logo of the radio station.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 2000000,
+            },
+            website: {
+              type: 'string',
+              description: 'The website of the radio station.',
+              format: 'uri',
+            },
+            createdAt: {
+              type: 'string',
+              description: 'The date when the radio station was created.',
               format: 'datetime',
             },
           },
···
       },
     },
   },
+  AppRockskyScrobbleCreateScrobble: {
+    lexicon: 1,
+    id: 'app.rocksky.scrobble.createScrobble',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new scrobble',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['title', 'artist'],
+            properties: {
+              title: {
+                type: 'string',
+                description: 'The title of the track being scrobbled',
+              },
+              artist: {
+                type: 'string',
+                description: 'The artist of the track being scrobbled',
+              },
+              album: {
+                type: 'string',
+                description: 'The album of the track being scrobbled',
+              },
+              duration: {
+                type: 'integer',
+                description: 'The duration of the track in seconds',
+              },
+              mbId: {
+                type: 'string',
+                description: 'The MusicBrainz ID of the track, if available',
+              },
+              albumArt: {
+                type: 'string',
+                description: 'The URL of the album art for the track',
+                format: 'uri',
+              },
+              trackNumber: {
+                type: 'integer',
+                description: 'The track number of the track in the album',
+              },
+              releaseDate: {
+                type: 'string',
+                description:
+                  'The release date of the track, formatted as YYYY-MM-DD',
+              },
+              year: {
+                type: 'integer',
+                description: 'The year the track was released',
+              },
+              discNumber: {
+                type: 'integer',
+                description:
+                  'The disc number of the track in the album, if applicable',
+              },
+              lyrics: {
+                type: 'string',
+                description: 'The lyrics of the track, if available',
+              },
+              composer: {
+                type: 'string',
+                description: 'The composer of the track, if available',
+              },
+              copyrightMessage: {
+                type: 'string',
+                description:
+                  'The copyright message for the track, if available',
+              },
+              label: {
+                type: 'string',
+                description: 'The record label of the track, if available',
+              },
+              artistPicture: {
+                type: 'string',
+                description: "The URL of the artist's picture, if available",
+                format: 'uri',
+              },
+              spotifyLink: {
+                type: 'string',
+                description: 'The Spotify link for the track, if available',
+                format: 'uri',
+              },
+              lastfmLink: {
+                type: 'string',
+                description: 'The Last.fm link for the track, if available',
+                format: 'uri',
+              },
+              tidalLink: {
+                type: 'string',
+                description: 'The Tidal link for the track, if available',
+                format: 'uri',
+              },
+              appleMusicLink: {
+                type: 'string',
+                description: 'The Apple Music link for the track, if available',
+                format: 'uri',
+              },
+              youtubeLink: {
+                type: 'string',
+                description: 'The Youtube link for the track, if available',
+                format: 'uri',
+              },
+              deezerLink: {
+                type: 'string',
+                description: 'The Deezer link for the track, if available',
+                format: 'uri',
+              },
+              timestamp: {
+                type: 'integer',
+                description:
+                  'The timestamp of the scrobble in milliseconds since epoch',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyScrobbleDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.scrobble.defs',
+    defs: {
+      scrobbleViewBasic: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the scrobble.',
+          },
+          user: {
+            type: 'string',
+            description: 'The handle of the user who created the scrobble.',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the scrobble.',
+          },
+          artist: {
+            type: 'string',
+            description: 'The artist of the song.',
+          },
+          artistUri: {
+            type: 'string',
+            description: 'The URI of the artist.',
+            format: 'at-uri',
+          },
+          album: {
+            type: 'string',
+            description: 'The album of the song.',
+          },
+          albumUri: {
+            type: 'string',
+            description: 'The URI of the album.',
+            format: 'at-uri',
+          },
+          cover: {
+            type: 'string',
+            description: 'The album art URL of the song.',
+            format: 'uri',
+          },
+          date: {
+            type: 'string',
+            description: 'The timestamp when the scrobble was created.',
+            format: 'datetime',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the scrobble.',
+            format: 'uri',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the scrobble data.',
+          },
+        },
+      },
+      scrobbleViewDetailed: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the scrobble.',
+          },
+          user: {
+            type: 'string',
+            description: 'The handle of the user who created the scrobble.',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the scrobble.',
+          },
+          artist: {
+            type: 'string',
+            description: 'The artist of the song.',
+          },
+          artistUri: {
+            type: 'string',
+            description: 'The URI of the artist.',
+            format: 'at-uri',
+          },
+          album: {
+            type: 'string',
+            description: 'The album of the song.',
+          },
+          albumUri: {
+            type: 'string',
+            description: 'The URI of the album.',
+            format: 'at-uri',
+          },
+          cover: {
+            type: 'string',
+            description: 'The album art URL of the song.',
+            format: 'uri',
+          },
+          date: {
+            type: 'string',
+            description: 'The timestamp when the scrobble was created.',
+            format: 'datetime',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the scrobble.',
+            format: 'uri',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the scrobble data.',
+          },
+          listeners: {
+            type: 'integer',
+            description: 'The number of listeners',
+          },
+          scrobbles: {
+            type: 'integer',
+            description: 'The number of scrobbles for this song',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyScrobbleGetScrobble: {
+    lexicon: 1,
+    id: 'app.rocksky.scrobble.getScrobble',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a scrobble by its unique identifier',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The unique identifier of the scrobble',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyScrobbleGetScrobbles: {
+    lexicon: 1,
+    id: 'app.rocksky.scrobble.getScrobbles',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get scrobbles all scrobbles',
+        parameters: {
+          type: 'params',
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of scrobbles to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              scrobbles: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   AppRockskyScrobble: {
     lexicon: 1,
     id: 'app.rocksky.scrobble',
     defs: {
       main: {
         type: 'record',
+        description: 'A declaration of a scrobble.',
         key: 'tid',
-        description: 'A declaration of a scrobble.',
         record: {
           type: 'object',
           required: [
             'title',
             'artist',
-            'albumArtist',
             'album',
+            'albumArtist',
             'duration',
             'createdAt',
           ],
           properties: {
+            title: {
+              type: 'string',
+              description: 'The title of the song.',
+              minLength: 1,
+              maxLength: 512,
+            },
+            artist: {
+              type: 'string',
+              description: 'The artist of the song.',
+              minLength: 1,
+              maxLength: 256,
+            },
+            albumArtist: {
+              type: 'string',
+              description: 'The album artist of the song.',
+              minLength: 1,
+              maxLength: 256,
+            },
+            album: {
+              type: 'string',
+              description: 'The album of the song.',
+              minLength: 1,
+              maxLength: 256,
+            },
+            duration: {
+              type: 'integer',
+              description: 'The duration of the song in seconds.',
+              minimum: 1,
+            },
             trackNumber: {
               type: 'integer',
               description: 'The track number of the song in the album.',
···
               description: 'The disc number of the song in the album.',
               minimum: 1,
             },
+            releaseDate: {
+              type: 'string',
+              description: 'The release date of the song.',
+              format: 'datetime',
+            },
+            year: {
+              type: 'integer',
+              description: 'The year the song was released.',
+            },
+            genre: {
+              type: 'string',
+              description: 'The genre of the song.',
+              maxLength: 256,
+            },
+            tags: {
+              type: 'array',
+              description: 'The tags of the song.',
+              items: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 256,
+              },
+            },
+            composer: {
+              type: 'string',
+              description: 'The composer of the song.',
+              maxLength: 256,
+            },
+            lyrics: {
+              type: 'string',
+              description: 'The lyrics of the song.',
+              maxLength: 10000,
+            },
+            copyrightMessage: {
+              type: 'string',
+              description: 'The copyright message of the song.',
+              maxLength: 256,
+            },
+            wiki: {
+              type: 'string',
+              description: 'Informations about the song',
+              maxLength: 10000,
+            },
+            albumArt: {
+              type: 'blob',
+              description: 'The album art of the song.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 2000000,
+            },
+            youtubeLink: {
+              type: 'string',
+              description: 'The YouTube link of the song.',
+              format: 'uri',
+            },
+            spotifyLink: {
+              type: 'string',
+              description: 'The Spotify link of the song.',
+              format: 'uri',
+            },
+            tidalLink: {
+              type: 'string',
+              description: 'The Tidal link of the song.',
+              format: 'uri',
+            },
+            appleMusicLink: {
+              type: 'string',
+              description: 'The Apple Music link of the song.',
+              format: 'uri',
+            },
+            createdAt: {
+              type: 'string',
+              description: 'The date when the song was created.',
+              format: 'datetime',
+            },
+            mbid: {
+              type: 'string',
+              description: 'The MusicBrainz ID of the song.',
+            },
+            label: {
+              type: 'string',
+              description: 'The label of the song.',
+              maxLength: 256,
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutCreateShout: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.createShout',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new shout',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              message: {
+                type: 'string',
+                description: 'The content of the shout',
+                minLength: 1,
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.shout.defs#shoutView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.defs',
+    defs: {
+      author: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the author.',
+          },
+          did: {
+            type: 'string',
+            description: 'The decentralized identifier (DID) of the author.',
+            format: 'at-identifier',
+          },
+          handle: {
+            type: 'string',
+            description: 'The handle of the author.',
+            format: 'at-identifier',
+          },
+          displayName: {
+            type: 'string',
+            description: 'The display name of the author.',
+          },
+          avatar: {
+            type: 'string',
+            description: "The URL of the author's avatar image.",
+            format: 'uri',
+          },
+        },
+      },
+      shoutView: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the shout.',
+          },
+          message: {
+            type: 'string',
+            description: 'The content of the shout.',
+          },
+          parent: {
+            type: 'string',
+            description:
+              'The ID of the parent shout if this is a reply, otherwise null.',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The date and time when the shout was created.',
+            format: 'datetime',
+          },
+          author: {
+            type: 'ref',
+            description: 'The author of the shout.',
+            ref: 'lex:app.rocksky.shout.defs#author',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutGetAlbumShouts: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.getAlbumShouts',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get shouts for an album',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description:
+                'The unique identifier of the album to retrieve shouts for',
+              format: 'at-uri',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of shouts to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description:
+                'The number of shouts to skip before starting to collect the result set',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              shouts: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutGetArtistShouts: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.getArtistShouts',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get shouts for an artist',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the artist to retrieve shouts for',
+              format: 'at-uri',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of shouts to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description:
+                'The number of shouts to skip before starting to collect the result set',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              shouts: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutGetProfileShouts: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.getProfileShouts',
+    defs: {
+      main: {
+        type: 'query',
+        description: "Get the shouts of an actor's profile",
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the actor',
+              format: 'at-identifier',
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of shouts to return',
+              minimum: 1,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              shouts: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutGetShoutReplies: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.getShoutReplies',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get replies to a shout',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the shout to retrieve replies for',
+              format: 'at-uri',
+            },
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of shouts to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description:
+                'The number of shouts to skip before starting to collect the result set',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              shouts: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutGetTrackShouts: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.getTrackShouts',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get all shouts for a specific track',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The URI of the track to retrieve shouts for',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              shouts: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutRemoveShout: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.removeShout',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Remove a shout by its ID',
+        parameters: {
+          type: 'params',
+          required: ['id'],
+          properties: {
+            id: {
+              type: 'string',
+              description: 'The ID of the shout to be removed',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.shout.defs#shoutView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutReplyShout: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.replyShout',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Reply to a shout',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['shoutId', 'message'],
+            properties: {
+              shoutId: {
+                type: 'string',
+                description: 'The unique identifier of the shout to reply to',
+              },
+              message: {
+                type: 'string',
+                description: 'The content of the reply',
+                minLength: 1,
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.shout.defs#shoutView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShoutReportShout: {
+    lexicon: 1,
+    id: 'app.rocksky.shout.reportShout',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Report a shout for moderation',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['shoutId'],
+            properties: {
+              shoutId: {
+                type: 'string',
+                description: 'The unique identifier of the shout to report',
+              },
+              reason: {
+                type: 'string',
+                description: 'The reason for reporting the shout',
+                minLength: 1,
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.shout.defs#shoutView',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyShout: {
+    lexicon: 1,
+    id: 'app.rocksky.shout',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a shout.',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['message', 'createdAt', 'subject'],
+          properties: {
+            message: {
+              type: 'string',
+              description: 'The message of the shout.',
+              minLength: 1,
+              maxLength: 1000,
+            },
+            createdAt: {
+              type: 'string',
+              description: 'The date when the shout was created.',
+              format: 'datetime',
+            },
+            parent: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+            subject: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskySongCreateSong: {
+    lexicon: 1,
+    id: 'app.rocksky.song.createSong',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new song',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['title', 'artist', 'album', 'albumArtist'],
+            properties: {
+              title: {
+                type: 'string',
+                description: 'The title of the song',
+              },
+              artist: {
+                type: 'string',
+                description: 'The artist of the song',
+              },
+              albumArtist: {
+                type: 'string',
+                description:
+                  'The album artist of the song, if different from the main artist',
+              },
+              album: {
+                type: 'string',
+                description: 'The album of the song, if applicable',
+              },
+              duration: {
+                type: 'integer',
+                description: 'The duration of the song in seconds',
+              },
+              mbId: {
+                type: 'string',
+                description: 'The MusicBrainz ID of the song, if available',
+              },
+              albumArt: {
+                type: 'string',
+                description: 'The URL of the album art for the song',
+                format: 'uri',
+              },
+              trackNumber: {
+                type: 'integer',
+                description:
+                  'The track number of the song in the album, if applicable',
+              },
+              releaseDate: {
+                type: 'string',
+                description:
+                  'The release date of the song, formatted as YYYY-MM-DD',
+              },
+              year: {
+                type: 'integer',
+                description: 'The year the song was released',
+              },
+              discNumber: {
+                type: 'integer',
+                description:
+                  'The disc number of the song in the album, if applicable',
+              },
+              lyrics: {
+                type: 'string',
+                description: 'The lyrics of the song, if available',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.song.defs#songViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskySongDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.song.defs',
+    defs: {
+      songViewBasic: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the song.',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the song.',
+          },
+          artist: {
+            type: 'string',
+            description: 'The artist of the song.',
+          },
+          albumArtist: {
+            type: 'string',
+            description: 'The artist of the album the song belongs to.',
+          },
+          albumArt: {
+            type: 'string',
+            description: 'The URL of the album art image.',
+            format: 'uri',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the song.',
+            format: 'at-uri',
+          },
+          album: {
+            type: 'string',
+            description: 'The album of the song.',
+          },
+          duration: {
+            type: 'integer',
+            description: 'The duration of the song in milliseconds.',
+          },
+          trackNumber: {
+            type: 'integer',
+            description: 'The track number of the song in the album.',
+          },
+          discNumber: {
+            type: 'integer',
+            description: 'The disc number of the song in the album.',
+          },
+          playCount: {
+            type: 'integer',
+            description: 'The number of times the song has been played.',
+            minimum: 0,
+          },
+          uniqueListeners: {
+            type: 'integer',
+            description:
+              'The number of unique listeners who have played the song.',
+            minimum: 0,
+          },
+          albumUri: {
+            type: 'string',
+            description: 'The URI of the album the song belongs to.',
+            format: 'at-uri',
+          },
+          artistUri: {
+            type: 'string',
+            description: 'The URI of the artist of the song.',
+            format: 'at-uri',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the song.',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The timestamp when the song was created.',
+            format: 'datetime',
+          },
+        },
+      },
+      songViewDetailed: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the song.',
+          },
+          title: {
+            type: 'string',
+            description: 'The title of the song.',
+          },
+          artist: {
+            type: 'string',
+            description: 'The artist of the song.',
+          },
+          albumArtist: {
+            type: 'string',
+            description: 'The artist of the album the song belongs to.',
+          },
+          albumArt: {
+            type: 'string',
+            description: 'The URL of the album art image.',
+            format: 'uri',
+          },
+          uri: {
+            type: 'string',
+            description: 'The URI of the song.',
+            format: 'at-uri',
+          },
+          album: {
+            type: 'string',
+            description: 'The album of the song.',
+          },
+          duration: {
+            type: 'integer',
+            description: 'The duration of the song in milliseconds.',
+          },
+          trackNumber: {
+            type: 'integer',
+            description: 'The track number of the song in the album.',
+          },
+          discNumber: {
+            type: 'integer',
+            description: 'The disc number of the song in the album.',
+          },
+          playCount: {
+            type: 'integer',
+            description: 'The number of times the song has been played.',
+            minimum: 0,
+          },
+          uniqueListeners: {
+            type: 'integer',
+            description:
+              'The number of unique listeners who have played the song.',
+            minimum: 0,
+          },
+          albumUri: {
+            type: 'string',
+            description: 'The URI of the album the song belongs to.',
+            format: 'at-uri',
+          },
+          artistUri: {
+            type: 'string',
+            description: 'The URI of the artist of the song.',
+            format: 'at-uri',
+          },
+          sha256: {
+            type: 'string',
+            description: 'The SHA256 hash of the song.',
+          },
+          createdAt: {
+            type: 'string',
+            description: 'The timestamp when the song was created.',
+            format: 'datetime',
+          },
+        },
+      },
+    },
+  },
+  AppRockskySongGetSong: {
+    lexicon: 1,
+    id: 'app.rocksky.song.getSong',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a song by its uri',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description: 'The unique identifier of the song to retrieve',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.song.defs#songViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskySongGetSongs: {
+    lexicon: 1,
+    id: 'app.rocksky.song.getSongs',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get songs',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              description: 'The maximum number of songs to return',
+              minimum: 1,
+            },
+            offset: {
+              type: 'integer',
+              description: 'The offset for pagination',
+              minimum: 0,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              songs: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.rocksky.song.defs#songViewBasic',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyLovedSong: {
+    lexicon: 1,
+    id: 'app.rocksky.lovedSong',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a song.',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['title', 'artist', 'album', 'duration', 'createdAt'],
+          properties: {
             title: {
               type: 'string',
               description: 'The title of the song.',
···
             },
             albumArtist: {
               type: 'string',
-              description: 'The artist of the album the song is from.',
+              description: 'The album artist of the song.',
               minLength: 1,
               maxLength: 256,
             },
             album: {
               type: 'string',
-              description: 'The album the song is from.',
+              description: 'The album of the song.',
               minLength: 1,
               maxLength: 256,
             },
···
               description: 'The duration of the song in seconds.',
               minimum: 1,
             },
+            trackNumber: {
+              type: 'integer',
+              description: 'The track number of the song in the album.',
+              minimum: 1,
+            },
+            discNumber: {
+              type: 'integer',
+              description: 'The disc number of the song in the album.',
+              minimum: 1,
+            },
             releaseDate: {
               type: 'string',
               description: 'The release date of the song.',
···
             },
             copyrightMessage: {
               type: 'string',
-              description: 'The copyright message.',
+              description: 'The copyright message of the song.',
+              minLength: 1,
               maxLength: 256,
             },
             wiki: {
···
             },
             createdAt: {
               type: 'string',
-              description: 'The date the song was created.',
+              description: 'The date when the song was created.',
               format: 'datetime',
             },
-            mbid: {
-              type: 'string',
-              description: 'The MusicBrainz ID of the song.',
-            },
-            label: {
-              type: 'string',
-              description: 'The label of the song.',
-              maxLength: 256,
-            },
           },
         },
       },
···
     defs: {
       main: {
         type: 'record',
-        key: 'tid',
         description: 'A declaration of a song.',
+        key: 'tid',
         record: {
           type: 'object',
           required: [
···
             'createdAt',
           ],
           properties: {
-            trackNumber: {
-              type: 'integer',
-              description: 'The track number of the song in the album.',
-              minimum: 1,
-            },
-            discNumber: {
-              type: 'integer',
-              description: 'The disc number of the song in the album.',
-              minimum: 1,
-            },
             title: {
               type: 'string',
               description: 'The title of the song.',
···
             },
             albumArtist: {
               type: 'string',
-              description: 'The artist of the album the song is from.',
+              description: 'The album artist of the song.',
               minLength: 1,
               maxLength: 256,
             },
             album: {
               type: 'string',
-              description: 'The album the song is from.',
+              description: 'The album of the song.',
               minLength: 1,
               maxLength: 256,
             },
             duration: {
               type: 'integer',
               description: 'The duration of the song in seconds.',
+              minimum: 1,
+            },
+            trackNumber: {
+              type: 'integer',
+              description: 'The track number of the song in the album.',
+              minimum: 1,
+            },
+            discNumber: {
+              type: 'integer',
+              description: 'The disc number of the song in the album.',
               minimum: 1,
             },
             releaseDate: {
···
             },
             copyrightMessage: {
               type: 'string',
-              description: 'The copyright message.',
+              description: 'The copyright message of the song.',
               maxLength: 256,
             },
             wiki: {
···
             },
             createdAt: {
               type: 'string',
-              description: 'The date the song was created.',
+              description: 'The date when the song was created.',
               format: 'datetime',
             },
             mbid: {
···
       },
     },
   },
+  AppRockskySpotifyDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.spotify.defs',
+    defs: {
+      spotifyTrackView: {
+        type: 'object',
+        properties: {
+          id: {
+            type: 'string',
+            description: 'The unique identifier of the Spotify track.',
+          },
+          name: {
+            type: 'string',
+            description: 'The name of the track.',
+          },
+          artist: {
+            type: 'string',
+            description: 'The name of the artist.',
+          },
+          album: {
+            type: 'string',
+            description: 'The name of the album.',
+          },
+          duration: {
+            type: 'integer',
+            description: 'The duration of the track in milliseconds.',
+          },
+          previewUrl: {
+            type: 'string',
+            description: 'A URL to a preview of the track.',
+          },
+        },
+      },
+    },
+  },
+  AppRockskySpotifyGetCurrentlyPlaying: {
+    lexicon: 1,
+    id: 'app.rocksky.spotify.getCurrentlyPlaying',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get the currently playing track',
+        parameters: {
+          type: 'params',
+          properties: {
+            actor: {
+              type: 'string',
+              description:
+                'Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.',
+              format: 'at-identifier',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.player.defs#currentlyPlayingViewDetailed',
+          },
+        },
+      },
+    },
+  },
+  AppRockskySpotifyNext: {
+    lexicon: 1,
+    id: 'app.rocksky.spotify.next',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Play the next track in the queue',
+      },
+    },
+  },
+  AppRockskySpotifyPause: {
+    lexicon: 1,
+    id: 'app.rocksky.spotify.pause',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Pause the currently playing track',
+      },
+    },
+  },
+  AppRockskySpotifyPlay: {
+    lexicon: 1,
+    id: 'app.rocksky.spotify.play',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Resume playback of the currently paused track',
+      },
+    },
+  },
+  AppRockskySpotifyPrevious: {
+    lexicon: 1,
+    id: 'app.rocksky.spotify.previous',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Play the previous track in the queue',
+      },
+    },
+  },
+  AppRockskySpotifySeek: {
+    lexicon: 1,
+    id: 'app.rocksky.spotify.seek',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Seek to a specific position in the currently playing track',
+        parameters: {
+          type: 'params',
+          required: ['position'],
+          properties: {
+            position: {
+              type: 'integer',
+              description: 'The position in seconds to seek to',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyStatsDefs: {
+    lexicon: 1,
+    id: 'app.rocksky.stats.defs',
+    defs: {
+      statsView: {
+        type: 'object',
+        properties: {
+          scrobbles: {
+            type: 'integer',
+            description: 'The total number of scrobbles.',
+          },
+          artists: {
+            type: 'integer',
+            description: 'The total number of unique artists scrobbled.',
+          },
+          lovedTracks: {
+            type: 'integer',
+            description: 'The total number of tracks marked as loved.',
+          },
+          albums: {
+            type: 'integer',
+            description: 'The total number of unique albums scrobbled.',
+          },
+          tracks: {
+            type: 'integer',
+            description: 'The total number of unique tracks scrobbled.',
+          },
+        },
+      },
+    },
+  },
+  AppRockskyStatsGetStats: {
+    lexicon: 1,
+    id: 'app.rocksky.stats.getStats',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['did'],
+          properties: {
+            did: {
+              type: 'string',
+              description: 'The DID or handle of the user to get stats for.',
+              format: 'at-identifier',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:app.rocksky.stats.defs#statsView',
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoRepoStrongRef: {
+    lexicon: 1,
+    id: 'com.atproto.repo.strongRef',
+    description: 'A URI with a content-hash fingerprint.',
+    defs: {
+      main: {
+        type: 'object',
+        required: ['uri', 'cid'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+        },
+      },
+    },
+  },
 } as const satisfies Record<string, LexiconDoc>
 export const schemas = Object.values(schemaDict) satisfies LexiconDoc[]
 export const lexicons: Lexicons = new Lexicons(schemas)
···
 }
 
 export const ids = {
+  AppRockskyActorDefs: 'app.rocksky.actor.defs',
+  AppRockskyActorGetActorAlbums: 'app.rocksky.actor.getActorAlbums',
+  AppRockskyActorGetActorArtists: 'app.rocksky.actor.getActorArtists',
+  AppRockskyActorGetActorLovedSongs: 'app.rocksky.actor.getActorLovedSongs',
+  AppRockskyActorGetActorPlaylists: 'app.rocksky.actor.getActorPlaylists',
+  AppRockskyActorGetActorScrobbles: 'app.rocksky.actor.getActorScrobbles',
+  AppRockskyActorGetActorSongs: 'app.rocksky.actor.getActorSongs',
+  AppRockskyActorGetProfile: 'app.rocksky.actor.getProfile',
+  AppBskyActorProfile: 'app.bsky.actor.profile',
   AppRockskyAlbum: 'app.rocksky.album',
+  AppRockskyAlbumDefs: 'app.rocksky.album.defs',
+  AppRockskyAlbumGetAlbum: 'app.rocksky.album.getAlbum',
+  AppRockskyAlbumGetAlbums: 'app.rocksky.album.getAlbums',
+  AppRockskyAlbumGetAlbumTracks: 'app.rocksky.album.getAlbumTracks',
+  AppRockskyApikeyCreateApikey: 'app.rocksky.apikey.createApikey',
+  AppRockskyApikeyDefs: 'app.rocksky.apikey.defs',
+  AppRockskyApikeysDefs: 'app.rocksky.apikeys.defs',
+  AppRockskyApikeyGetApikeys: 'app.rocksky.apikey.getApikeys',
+  AppRockskyApikeyRemoveApikey: 'app.rocksky.apikey.removeApikey',
+  AppRockskyApikeyUpdateApikey: 'app.rocksky.apikey.updateApikey',
   AppRockskyArtist: 'app.rocksky.artist',
+  AppRockskyArtistDefs: 'app.rocksky.artist.defs',
+  AppRockskyArtistGetArtistAlbums: 'app.rocksky.artist.getArtistAlbums',
+  AppRockskyArtistGetArtist: 'app.rocksky.artist.getArtist',
+  AppRockskyArtistGetArtists: 'app.rocksky.artist.getArtists',
+  AppRockskyArtistGetArtistTracks: 'app.rocksky.artist.getArtistTracks',
+  AppRockskyChartsDefs: 'app.rocksky.charts.defs',
+  AppRockskyChartsGetScrobblesChart: 'app.rocksky.charts.getScrobblesChart',
+  AppRockskyDropboxDefs: 'app.rocksky.dropbox.defs',
+  AppRockskyDropboxDownloadFile: 'app.rocksky.dropbox.downloadFile',
+  AppRockskyDropboxGetFiles: 'app.rocksky.dropbox.getFiles',
+  AppRockskyDropboxGetMetadata: 'app.rocksky.dropbox.getMetadata',
+  AppRockskyDropboxGetTemporaryLink: 'app.rocksky.dropbox.getTemporaryLink',
+  AppRockskyFeedDefs: 'app.rocksky.feed.defs',
+  AppRockskyFeedGetNowPlayings: 'app.rocksky.feed.getNowPlayings',
+  AppRockskyFeedSearch: 'app.rocksky.feed.search',
+  AppRockskyGoogledriveDefs: 'app.rocksky.googledrive.defs',
+  AppRockskyGoogledriveDownloadFile: 'app.rocksky.googledrive.downloadFile',
+  AppRockskyGoogledriveGetFile: 'app.rocksky.googledrive.getFile',
+  AppRockskyGoogledriveGetFiles: 'app.rocksky.googledrive.getFiles',
+  AppRockskyLikeDislikeShout: 'app.rocksky.like.dislikeShout',
+  AppRockskyLikeDislikeSong: 'app.rocksky.like.dislikeSong',
+  AppRockskyLike: 'app.rocksky.like',
+  AppRockskyLikeLikeShout: 'app.rocksky.like.likeShout',
+  AppRockskyLikeLikeSong: 'app.rocksky.like.likeSong',
+  AppRockskyPlayerDefs: 'app.rocksky.player.defs',
+  AppRockskyPlayerGetCurrentlyPlaying: 'app.rocksky.player.getCurrentlyPlaying',
+  AppRockskyPlayerNext: 'app.rocksky.player.next',
+  AppRockskyPlayerPause: 'app.rocksky.player.pause',
+  AppRockskyPlayerPlay: 'app.rocksky.player.play',
+  AppRockskyPlayerPrevious: 'app.rocksky.player.previous',
+  AppRockskyPlayerSeek: 'app.rocksky.player.seek',
+  AppRockskyPlaylistDefs: 'app.rocksky.playlist.defs',
+  AppRockskyPlaylistGetPlaylist: 'app.rocksky.playlist.getPlaylist',
+  AppRockskyPlaylistGetPlaylists: 'app.rocksky.playlist.getPlaylists',
+  AppRockskyPlaylist: 'app.rocksky.playlist',
+  AppRockskyRadioDefs: 'app.rocksky.radio.defs',
+  AppRockskyRadio: 'app.rocksky.radio',
+  AppRockskyScrobbleCreateScrobble: 'app.rocksky.scrobble.createScrobble',
+  AppRockskyScrobbleDefs: 'app.rocksky.scrobble.defs',
+  AppRockskyScrobbleGetScrobble: 'app.rocksky.scrobble.getScrobble',
+  AppRockskyScrobbleGetScrobbles: 'app.rocksky.scrobble.getScrobbles',
   AppRockskyScrobble: 'app.rocksky.scrobble',
+  AppRockskyShoutCreateShout: 'app.rocksky.shout.createShout',
+  AppRockskyShoutDefs: 'app.rocksky.shout.defs',
+  AppRockskyShoutGetAlbumShouts: 'app.rocksky.shout.getAlbumShouts',
+  AppRockskyShoutGetArtistShouts: 'app.rocksky.shout.getArtistShouts',
+  AppRockskyShoutGetProfileShouts: 'app.rocksky.shout.getProfileShouts',
+  AppRockskyShoutGetShoutReplies: 'app.rocksky.shout.getShoutReplies',
+  AppRockskyShoutGetTrackShouts: 'app.rocksky.shout.getTrackShouts',
+  AppRockskyShoutRemoveShout: 'app.rocksky.shout.removeShout',
+  AppRockskyShoutReplyShout: 'app.rocksky.shout.replyShout',
+  AppRockskyShoutReportShout: 'app.rocksky.shout.reportShout',
+  AppRockskyShout: 'app.rocksky.shout',
+  AppRockskySongCreateSong: 'app.rocksky.song.createSong',
+  AppRockskySongDefs: 'app.rocksky.song.defs',
+  AppRockskySongGetSong: 'app.rocksky.song.getSong',
+  AppRockskySongGetSongs: 'app.rocksky.song.getSongs',
+  AppRockskyLovedSong: 'app.rocksky.lovedSong',
   AppRockskySong: 'app.rocksky.song',
+  AppRockskySpotifyDefs: 'app.rocksky.spotify.defs',
+  AppRockskySpotifyGetCurrentlyPlaying:
+    'app.rocksky.spotify.getCurrentlyPlaying',
+  AppRockskySpotifyNext: 'app.rocksky.spotify.next',
+  AppRockskySpotifyPause: 'app.rocksky.spotify.pause',
+  AppRockskySpotifyPlay: 'app.rocksky.spotify.play',
+  AppRockskySpotifyPrevious: 'app.rocksky.spotify.previous',
+  AppRockskySpotifySeek: 'app.rocksky.spotify.seek',
+  AppRockskyStatsDefs: 'app.rocksky.stats.defs',
+  AppRockskyStatsGetStats: 'app.rocksky.stats.getStats',
+  ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
 } as const

src/lexicon/types/app/bsky/actor/profile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs.js'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.actor.profile'
+
+export interface Record {
+  $type: 'app.bsky.actor.profile'
+  displayName?: string
+  /** Free-form profile description text. */
+  description?: string
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef
+  /** Larger horizontal image to display behind profile view. */
+  banner?: BlobRef
+  labels?: $Typed<ComAtprotoLabelDefs.SelfLabels> | { $type: string }
+  joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main
+  createdAt?: string
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

src/lexicon/types/app/rocksky/actor/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.defs'
+
+export interface ProfileViewDetailed {
+  $type?: 'app.rocksky.actor.defs#profileViewDetailed'
+  /** The unique identifier of the actor. */
+  id?: string
+  /** The DID of the actor. */
+  did?: string
+  /** The handle of the actor. */
+  handle?: string
+  /** The display name of the actor. */
+  displayName?: string
+  /** The URL of the actor's avatar image. */
+  avatar?: string
+  /** The date and time when the actor was created. */
+  createdAt?: string
+  /** The date and time when the actor was last updated. */
+  updatedAt?: string
+}
+
+const hashProfileViewDetailed = 'profileViewDetailed'
+
+export function isProfileViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashProfileViewDetailed)
+}
+
+export function validateProfileViewDetailed<V>(v: V) {
+  return validate<ProfileViewDetailed & V>(v, id, hashProfileViewDetailed)
+}
+
+export interface ProfileViewBasic {
+  $type?: 'app.rocksky.actor.defs#profileViewBasic'
+  /** The unique identifier of the actor. */
+  id?: string
+  /** The DID of the actor. */
+  did?: string
+  /** The handle of the actor. */
+  handle?: string
+  /** The display name of the actor. */
+  displayName?: string
+  /** The URL of the actor's avatar image. */
+  avatar?: string
+  /** The date and time when the actor was created. */
+  createdAt?: string
+  /** The date and time when the actor was last updated. */
+  updatedAt?: string
+}
+
+const hashProfileViewBasic = 'profileViewBasic'
+
+export function isProfileViewBasic<V>(v: V) {
+  return is$typed(v, id, hashProfileViewBasic)
+}
+
+export function validateProfileViewBasic<V>(v: V) {
+  return validate<ProfileViewBasic & V>(v, id, hashProfileViewBasic)
+}

src/lexicon/types/app/rocksky/actor/getActorAlbums.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyAlbumDefs from '../album/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.getActorAlbums'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did: string
+  /** The maximum number of albums to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  albums?: AppRockskyAlbumDefs.AlbumViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/actor/getActorArtists.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyArtistDefs from '../artist/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.getActorArtists'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did: string
+  /** The maximum number of albums to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  artists?: AppRockskyArtistDefs.ArtistViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/actor/getActorLovedSongs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from '../song/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.getActorLovedSongs'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did: string
+  /** The maximum number of albums to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  tracks?: AppRockskySongDefs.SongViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/actor/getActorPlaylists.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyPlaylistDefs from '../playlist/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.getActorPlaylists'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did: string
+  /** The maximum number of albums to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/actor/getActorScrobbles.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyScrobbleDefs from '../scrobble/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.getActorScrobbles'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did: string
+  /** The maximum number of albums to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/actor/getActorSongs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from '../song/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.getActorSongs'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did: string
+  /** The maximum number of albums to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  songs?: AppRockskySongDefs.SongViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/actor/getProfile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyActorDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.actor.getProfile'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did?: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyActorDefs.ProfileViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/album.ts

···
   youtubeLink?: string
   /** The Spotify link of the album. */
   spotifyLink?: string
-  /** The Tidal link of the album. */
+  /** The tidal link of the album. */
   tidalLink?: string
   /** The Apple Music link of the album. */
   appleMusicLink?: string
-  /** The date the song was created. */
+  /** The date and time when the album was created. */
   createdAt: string
   [k: string]: unknown
 }

src/lexicon/types/app/rocksky/album/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as AppRockskySongDefsSongViewBasic from '../song/defs/songViewBasic.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.album.defs'
+
+export interface AlbumViewBasic {
+  $type?: 'app.rocksky.album.defs#albumViewBasic'
+  /** The unique identifier of the album. */
+  id?: string
+  /** The URI of the album. */
+  uri?: string
+  /** The title of the album. */
+  title?: string
+  /** The artist of the album. */
+  artist?: string
+  /** The URI of the album's artist. */
+  artistUri?: string
+  /** The year the album was released. */
+  year?: number
+  /** The URL of the album art image. */
+  albumArt?: string
+  /** The release date of the album. */
+  releaseDate?: string
+  /** The SHA256 hash of the album. */
+  sha256?: string
+  /** The number of times the album has been played. */
+  playCount?: number
+  /** The number of unique listeners who have played the album. */
+  uniqueListeners?: number
+}
+
+const hashAlbumViewBasic = 'albumViewBasic'
+
+export function isAlbumViewBasic<V>(v: V) {
+  return is$typed(v, id, hashAlbumViewBasic)
+}
+
+export function validateAlbumViewBasic<V>(v: V) {
+  return validate<AlbumViewBasic & V>(v, id, hashAlbumViewBasic)
+}
+
+export interface AlbumViewDetailed {
+  $type?: 'app.rocksky.album.defs#albumViewDetailed'
+  /** The unique identifier of the album. */
+  id?: string
+  /** The URI of the album. */
+  uri?: string
+  /** The title of the album. */
+  title?: string
+  /** The artist of the album. */
+  artist?: string
+  /** The URI of the album's artist. */
+  artistUri?: string
+  /** The year the album was released. */
+  year?: number
+  /** The URL of the album art image. */
+  albumArt?: string
+  /** The release date of the album. */
+  releaseDate?: string
+  /** The SHA256 hash of the album. */
+  sha256?: string
+  /** The number of times the album has been played. */
+  playCount?: number
+  /** The number of unique listeners who have played the album. */
+  uniqueListeners?: number
+  tracks?: AppRockskySongDefsSongViewBasic.Main[]
+}
+
+const hashAlbumViewDetailed = 'albumViewDetailed'
+
+export function isAlbumViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashAlbumViewDetailed)
+}
+
+export function validateAlbumViewDetailed<V>(v: V) {
+  return validate<AlbumViewDetailed & V>(v, id, hashAlbumViewDetailed)
+}

src/lexicon/types/app/rocksky/album/getAlbum.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyAlbumDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.album.getAlbum'
+
+export interface QueryParams {
+  /** The URI of the album to retrieve. */
+  uri: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyAlbumDefs.AlbumViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/album/getAlbumTracks.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from '../song/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.album.getAlbumTracks'
+
+export interface QueryParams {
+  /** The URI of the album to retrieve tracks from */
+  uri: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  tracks?: AppRockskySongDefs.SongViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/album/getAlbums.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyAlbumDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.album.getAlbums'
+
+export interface QueryParams {
+  /** The maximum number of albums to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  albums?: AppRockskyAlbumDefs.AlbumViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/apikey/createApikey.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyApikeyDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.apikey.createApikey'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The name of the API key. */
+  name: string
+  /** A description for the API key. */
+  description?: string
+}
+
+export type OutputSchema = AppRockskyApikeyDefs.ApiKey
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/apikey/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.apikey.defs'
+
+export interface ApiKeyView {
+  $type?: 'app.rocksky.apikey.defs#apiKeyView'
+  /** The unique identifier of the API key. */
+  id?: string
+  /** The name of the API key. */
+  name?: string
+  /** A description for the API key. */
+  description?: string
+  /** The date and time when the API key was created. */
+  createdAt?: string
+}
+
+const hashApiKeyView = 'apiKeyView'
+
+export function isApiKeyView<V>(v: V) {
+  return is$typed(v, id, hashApiKeyView)
+}
+
+export function validateApiKeyView<V>(v: V) {
+  return validate<ApiKeyView & V>(v, id, hashApiKeyView)
+}

src/lexicon/types/app/rocksky/apikey/getApikeys.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyApikeyDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.apikey.getApikeys'
+
+export interface QueryParams {
+  /** The number of API keys to skip before starting to collect the result set. */
+  offset?: number
+  /** The number of API keys to return per page. */
+  limit?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  apiKeys?: AppRockskyApikeyDefs.ApikeyView[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/apikey/removeApikey.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyApikeyDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.apikey.removeApikey'
+
+export interface QueryParams {
+  /** The ID of the API key to remove. */
+  id: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyApikeyDefs.ApiKey
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/apikey/updateApikey.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyApikeyDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.apikey.updateApikey'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The ID of the API key to update. */
+  id: string
+  /** The new name of the API key. */
+  name: string
+  /** A new description for the API key. */
+  description?: string
+}
+
+export type OutputSchema = AppRockskyApikeyDefs.ApiKey
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/apikeys/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.apikeys.defs'

src/lexicon/types/app/rocksky/artist.ts

···
   died?: string
   /** The birth place of the artist. */
   bornIn?: string
-  /** The date the song was created. */
+  /** The date when the artist was created. */
   createdAt: string
   [k: string]: unknown
 }

src/lexicon/types/app/rocksky/artist/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.artist.defs'
+
+export interface ArtistViewBasic {
+  $type?: 'app.rocksky.artist.defs#artistViewBasic'
+  /** The unique identifier of the artist. */
+  id?: string
+  /** The URI of the artist. */
+  uri?: string
+  /** The name of the artist. */
+  name?: string
+  /** The picture of the artist. */
+  picture?: string
+  /** The SHA256 hash of the artist. */
+  sha256?: string
+  /** The number of times the artist has been played. */
+  playCount?: number
+  /** The number of unique listeners who have played the artist. */
+  uniqueListeners?: number
+}
+
+const hashArtistViewBasic = 'artistViewBasic'
+
+export function isArtistViewBasic<V>(v: V) {
+  return is$typed(v, id, hashArtistViewBasic)
+}
+
+export function validateArtistViewBasic<V>(v: V) {
+  return validate<ArtistViewBasic & V>(v, id, hashArtistViewBasic)
+}
+
+export interface ArtistViewDetailed {
+  $type?: 'app.rocksky.artist.defs#artistViewDetailed'
+  /** The unique identifier of the artist. */
+  id?: string
+  /** The URI of the artist. */
+  uri?: string
+  /** The name of the artist. */
+  name?: string
+  /** The picture of the artist. */
+  picture?: string
+  /** The SHA256 hash of the artist. */
+  sha256?: string
+  /** The number of times the artist has been played. */
+  playCount?: number
+  /** The number of unique listeners who have played the artist. */
+  uniqueListeners?: number
+}
+
+const hashArtistViewDetailed = 'artistViewDetailed'
+
+export function isArtistViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashArtistViewDetailed)
+}
+
+export function validateArtistViewDetailed<V>(v: V) {
+  return validate<ArtistViewDetailed & V>(v, id, hashArtistViewDetailed)
+}

src/lexicon/types/app/rocksky/artist/getArtist.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyArtistDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.artist.getArtist'
+
+export interface QueryParams {
+  /** The URI of the artist to retrieve details from */
+  uri: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyArtistDefs.ArtistViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/artist/getArtistAlbums.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyAlbumDefs from '../album/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.artist.getArtistAlbums'
+
+export interface QueryParams {
+  /** The URI of the artist to retrieve albums from */
+  uri: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  albums?: AppRockskyAlbumDefs.AlbumViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/artist/getArtistTracks.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from '../song/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.artist.getArtistTracks'
+
+export interface QueryParams {
+  /** The URI of the artist to retrieve albums from */
+  uri?: string
+  /** The maximum number of tracks to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  tracks?: AppRockskySongDefs.SongViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/artist/getArtists.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyArtistDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.artist.getArtists'
+
+export interface QueryParams {
+  /** The maximum number of artists to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  artists?: AppRockskyArtistDefs.ArtistViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/charts/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.charts.defs'
+
+export interface ChartsView {
+  $type?: 'app.rocksky.charts.defs#chartsView'
+  scrobbles?: ScrobbleViewBasic[]
+}
+
+const hashChartsView = 'chartsView'
+
+export function isChartsView<V>(v: V) {
+  return is$typed(v, id, hashChartsView)
+}
+
+export function validateChartsView<V>(v: V) {
+  return validate<ChartsView & V>(v, id, hashChartsView)
+}
+
+export interface ScrobbleViewBasic {
+  $type?: 'app.rocksky.charts.defs#scrobbleViewBasic'
+  /** The date of the scrobble. */
+  date?: string
+  /** The number of scrobbles on this date. */
+  count?: number
+}
+
+const hashScrobbleViewBasic = 'scrobbleViewBasic'
+
+export function isScrobbleViewBasic<V>(v: V) {
+  return is$typed(v, id, hashScrobbleViewBasic)
+}
+
+export function validateScrobbleViewBasic<V>(v: V) {
+  return validate<ScrobbleViewBasic & V>(v, id, hashScrobbleViewBasic)
+}

src/lexicon/types/app/rocksky/charts/getScrobblesChart.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyChartsDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.charts.getScrobblesChart'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did?: string
+  /** The URI of the artist to filter by */
+  artisturi?: string
+  /** The URI of the album to filter by */
+  albumuri?: string
+  /** The URI of the track to filter by */
+  songuri?: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyChartsDefs.ChartsView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/dropbox/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.dropbox.defs'
+
+export interface FileView {
+  $type?: 'app.rocksky.dropbox.defs#fileView'
+  /** The unique identifier of the file. */
+  id?: string
+  /** The name of the file. */
+  name?: string
+  /** The lowercased path of the file. */
+  pathLower?: string
+  /** The display path of the file. */
+  pathDisplay?: string
+  /** The last modified date and time of the file on the client. */
+  clientModified?: string
+  /** The last modified date and time of the file on the server. */
+  serverModified?: string
+}
+
+const hashFileView = 'fileView'
+
+export function isFileView<V>(v: V) {
+  return is$typed(v, id, hashFileView)
+}
+
+export function validateFileView<V>(v: V) {
+  return validate<FileView & V>(v, id, hashFileView)
+}
+
+export interface FileListView {
+  $type?: 'app.rocksky.dropbox.defs#fileListView'
+  /** A list of files in the Dropbox. */
+  files?: FileView[]
+}
+
+const hashFileListView = 'fileListView'
+
+export function isFileListView<V>(v: V) {
+  return is$typed(v, id, hashFileListView)
+}
+
+export function validateFileListView<V>(v: V) {
+  return validate<FileListView & V>(v, id, hashFileListView)
+}
+
+export interface TemporaryLinkView {
+  $type?: 'app.rocksky.dropbox.defs#temporaryLinkView'
+  /** The temporary link to access the file. */
+  link?: string
+}
+
+const hashTemporaryLinkView = 'temporaryLinkView'
+
+export function isTemporaryLinkView<V>(v: V) {
+  return is$typed(v, id, hashTemporaryLinkView)
+}
+
+export function validateTemporaryLinkView<V>(v: V) {
+  return validate<TemporaryLinkView & V>(v, id, hashTemporaryLinkView)
+}

src/lexicon/types/app/rocksky/dropbox/downloadFile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import stream from 'node:stream'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.dropbox.downloadFile'
+
+export interface QueryParams {
+  /** The unique identifier of the file to download */
+  fileId: string
+}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/octet-stream'
+  body: Uint8Array | stream.Readable
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/dropbox/getFiles.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyDropboxDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.dropbox.getFiles'
+
+export interface QueryParams {
+  /** Path to the Dropbox folder or root directory */
+  at?: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyDropboxDefs.FileListView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/dropbox/getMetadata.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyDropboxDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.dropbox.getMetadata'
+
+export interface QueryParams {
+  /** Path to the file or folder in Dropbox */
+  path: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyDropboxDefs.FileView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/dropbox/getTemporaryLink.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyDropboxDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.dropbox.getTemporaryLink'
+
+export interface QueryParams {
+  /** Path to the file in Dropbox */
+  path: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyDropboxDefs.TemporaryLinkView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/feed/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as AppRockskySongDefs from '../song/defs.js'
+import type * as AppRockskyAlbumDefs from '../album/defs.js'
+import type * as AppRockskyArtistDefs from '../artist/defs.js'
+import type * as AppRockskyPlaylistDefs from '../playlist/defs.js'
+import type * as AppRockskyActorDefs from '../actor/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.feed.defs'
+
+export interface SearchResultsView {
+  $type?: 'app.rocksky.feed.defs#searchResultsView'
+  hits?: (
+    | $Typed<AppRockskySongDefs.SongViewBasic>
+    | $Typed<AppRockskyAlbumDefs.AlbumViewBasic>
+    | $Typed<AppRockskyArtistDefs.ArtistViewBasic>
+    | $Typed<AppRockskyPlaylistDefs.PlaylistViewBasic>
+    | $Typed<AppRockskyActorDefs.ProfileViewBasic>
+    | { $type: string }
+  )[]
+  processingTimeMs?: number
+  limit?: number
+  offset?: number
+  estimatedTotalHits?: number
+}
+
+const hashSearchResultsView = 'searchResultsView'
+
+export function isSearchResultsView<V>(v: V) {
+  return is$typed(v, id, hashSearchResultsView)
+}
+
+export function validateSearchResultsView<V>(v: V) {
+  return validate<SearchResultsView & V>(v, id, hashSearchResultsView)
+}
+
+export interface NowPlayingView {
+  $type?: 'app.rocksky.feed.defs#nowPlayingView'
+  album?: string
+  albumArt?: string
+  albumArtist?: string
+  albumUri?: string
+  artist?: string
+  artistUri?: string
+  avatar?: string
+  createdAt?: string
+  did?: string
+  handle?: string
+  id?: string
+  title?: string
+  trackId?: string
+  trackUri?: string
+  uri?: string
+}
+
+const hashNowPlayingView = 'nowPlayingView'
+
+export function isNowPlayingView<V>(v: V) {
+  return is$typed(v, id, hashNowPlayingView)
+}
+
+export function validateNowPlayingView<V>(v: V) {
+  return validate<NowPlayingView & V>(v, id, hashNowPlayingView)
+}
+
+export interface NowPlayingsView {
+  $type?: 'app.rocksky.feed.defs#nowPlayingsView'
+  nowPlayings?: NowPlayingView[]
+}
+
+const hashNowPlayingsView = 'nowPlayingsView'
+
+export function isNowPlayingsView<V>(v: V) {
+  return is$typed(v, id, hashNowPlayingsView)
+}
+
+export function validateNowPlayingsView<V>(v: V) {
+  return validate<NowPlayingsView & V>(v, id, hashNowPlayingsView)
+}

src/lexicon/types/app/rocksky/feed/getNowPlayings.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyFeedDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.feed.getNowPlayings'
+
+export interface QueryParams {
+  /** The maximum number of now playing tracks to return. */
+  size?: number
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyFeedDefs.NowPlayingsView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/feed/search.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyFeedDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.feed.search'
+
+export interface QueryParams {
+  /** The search query string */
+  query: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyFeedDefs.SearchResultsView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/googledrive/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.googledrive.defs'
+
+export interface FileView {
+  $type?: 'app.rocksky.googledrive.defs#fileView'
+  /** The unique identifier of the file. */
+  id?: string
+}
+
+const hashFileView = 'fileView'
+
+export function isFileView<V>(v: V) {
+  return is$typed(v, id, hashFileView)
+}
+
+export function validateFileView<V>(v: V) {
+  return validate<FileView & V>(v, id, hashFileView)
+}
+
+export interface FileListView {
+  $type?: 'app.rocksky.googledrive.defs#fileListView'
+  files?: FileView[]
+}
+
+const hashFileListView = 'fileListView'
+
+export function isFileListView<V>(v: V) {
+  return is$typed(v, id, hashFileListView)
+}
+
+export function validateFileListView<V>(v: V) {
+  return validate<FileListView & V>(v, id, hashFileListView)
+}

src/lexicon/types/app/rocksky/googledrive/downloadFile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import stream from 'node:stream'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.googledrive.downloadFile'
+
+export interface QueryParams {
+  /** The unique identifier of the file to download */
+  fileId: string
+}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/octet-stream'
+  body: Uint8Array | stream.Readable
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/googledrive/getFile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyGoogledriveDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.googledrive.getFile'
+
+export interface QueryParams {
+  /** The unique identifier of the file to retrieve */
+  fileId: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyGoogledriveDefs.FileView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/googledrive/getFiles.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyGoogledriveDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.googledrive.getFiles'
+
+export interface QueryParams {
+  /** Path to the Google Drive folder or root directory */
+  at?: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyGoogledriveDefs.FileListView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/like.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.like'
+
+export interface Record {
+  $type: 'app.rocksky.like'
+  /** The date when the like was created. */
+  createdAt: string
+  subject: ComAtprotoRepoStrongRef.Main
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

src/lexicon/types/app/rocksky/like/dislikeShout.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from '../shout/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.like.dislikeShout'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The unique identifier of the shout to dislike */
+  uri?: string
+}
+
+export type OutputSchema = AppRockskyShoutDefs.ShoutView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/like/dislikeSong.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from '../song/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.like.dislikeSong'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The unique identifier of the song to dislike */
+  uri?: string
+}
+
+export type OutputSchema = AppRockskySongDefs.SongViewDetailed
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/like/likeShout.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from '../shout/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.like.likeShout'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The unique identifier of the shout to like */
+  uri?: string
+}
+
+export type OutputSchema = AppRockskyShoutDefs.ShoutView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/like/likeSong.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from '../song/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.like.likeSong'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The unique identifier of the song to like */
+  uri?: string
+}
+
+export type OutputSchema = AppRockskySongDefs.SongViewDetailed
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/lovedSong.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.lovedSong'
+
+export interface Record {
+  $type: 'app.rocksky.lovedSong'
+  /** The title of the song. */
+  title: string
+  /** The artist of the song. */
+  artist: string
+  /** The album artist of the song. */
+  albumArtist?: string
+  /** The album of the song. */
+  album: string
+  /** The duration of the song in seconds. */
+  duration: number
+  /** The track number of the song in the album. */
+  trackNumber?: number
+  /** The disc number of the song in the album. */
+  discNumber?: number
+  /** The release date of the song. */
+  releaseDate?: string
+  /** The year the song was released. */
+  year?: number
+  /** The genre of the song. */
+  genre?: string
+  /** The tags of the song. */
+  tags?: string[]
+  /** The composer of the song. */
+  composer?: string
+  /** The lyrics of the song. */
+  lyrics?: string
+  /** The copyright message of the song. */
+  copyrightMessage?: string
+  /** Informations about the song */
+  wiki?: string
+  /** The album art of the song. */
+  albumArt?: BlobRef
+  /** The YouTube link of the song. */
+  youtubeLink?: string
+  /** The Spotify link of the song. */
+  spotifyLink?: string
+  /** The Tidal link of the song. */
+  tidalLink?: string
+  /** The Apple Music link of the song. */
+  appleMusicLink?: string
+  /** The date when the song was created. */
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

src/lexicon/types/app/rocksky/player/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.player.defs'
+
+export interface CurrentlyPlayingViewDetailed {
+  $type?: 'app.rocksky.player.defs#currentlyPlayingViewDetailed'
+  /** The title of the currently playing track */
+  title?: string
+}
+
+const hashCurrentlyPlayingViewDetailed = 'currentlyPlayingViewDetailed'
+
+export function isCurrentlyPlayingViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashCurrentlyPlayingViewDetailed)
+}
+
+export function validateCurrentlyPlayingViewDetailed<V>(v: V) {
+  return validate<CurrentlyPlayingViewDetailed & V>(
+    v,
+    id,
+    hashCurrentlyPlayingViewDetailed,
+  )
+}

src/lexicon/types/app/rocksky/player/getCurrentlyPlaying.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyPlayerDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.player.getCurrentlyPlaying'
+
+export interface QueryParams {
+  /** Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user. */
+  actor?: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/player/next.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.player.next'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/player/pause.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.player.pause'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/player/play.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.player.play'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/player/previous.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.player.previous'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/player/seek.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.player.seek'
+
+export interface QueryParams {
+  /** The position in seconds to seek to */
+  position: number
+}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/playlist.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+import type * as AppRockskySong from './song.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.playlist'
+
+export interface Record {
+  $type: 'app.rocksky.playlist'
+  /** The name of the playlist. */
+  name: string
+  /** The playlist description. */
+  description?: string
+  /** The picture of the playlist. */
+  picture?: BlobRef
+  /** The tracks in the playlist. */
+  tracks?: AppRockskySong.Record[]
+  /** The date the playlist was created. */
+  createdAt: string
+  /** The Spotify link of the playlist. */
+  spotifyLink?: string
+  /** The Tidal link of the playlist. */
+  tidalLink?: string
+  /** The YouTube link of the playlist. */
+  youtubeLink?: string
+  /** The Apple Music link of the playlist. */
+  appleMusicLink?: string
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

src/lexicon/types/app/rocksky/playlist/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as AppRockskySongDefs from '../song/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.playlist.defs'
+
+/** Detailed view of a playlist, including its tracks and metadata */
+export interface PlaylistViewDetailed {
+  $type?: 'app.rocksky.playlist.defs#playlistViewDetailed'
+  /** The unique identifier of the playlist. */
+  id?: string
+  /** The title of the playlist. */
+  title?: string
+  /** The URI of the playlist. */
+  uri?: string
+  /** The DID of the curator of the playlist. */
+  curatorDid?: string
+  /** The handle of the curator of the playlist. */
+  curatorHandle?: string
+  /** The name of the curator of the playlist. */
+  curatorName?: string
+  /** The URL of the avatar image of the curator. */
+  curatorAvatarUrl?: string
+  /** A description of the playlist. */
+  description?: string
+  /** The URL of the cover image for the playlist. */
+  coverImageUrl?: string
+  /** The date and time when the playlist was created. */
+  createdAt?: string
+  /** A list of tracks in the playlist. */
+  tracks?: AppRockskySongDefs.SongViewBasic[]
+}
+
+const hashPlaylistViewDetailed = 'playlistViewDetailed'
+
+export function isPlaylistViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashPlaylistViewDetailed)
+}
+
+export function validatePlaylistViewDetailed<V>(v: V) {
+  return validate<PlaylistViewDetailed & V>(v, id, hashPlaylistViewDetailed)
+}
+
+/** Basic view of a playlist, including its metadata */
+export interface PlaylistViewBasic {
+  $type?: 'app.rocksky.playlist.defs#playlistViewBasic'
+  /** The unique identifier of the playlist. */
+  id?: string
+  /** The title of the playlist. */
+  title?: string
+  /** The URI of the playlist. */
+  uri?: string
+  /** The DID of the curator of the playlist. */
+  curatorDid?: string
+  /** The handle of the curator of the playlist. */
+  curatorHandle?: string
+  /** The name of the curator of the playlist. */
+  curatorName?: string
+  /** The URL of the avatar image of the curator. */
+  curatorAvatarUrl?: string
+  /** A description of the playlist. */
+  description?: string
+  /** The URL of the cover image for the playlist. */
+  coverImageUrl?: string
+  /** The date and time when the playlist was created. */
+  createdAt?: string
+  /** The number of tracks in the playlist. */
+  trackCount?: number
+}
+
+const hashPlaylistViewBasic = 'playlistViewBasic'
+
+export function isPlaylistViewBasic<V>(v: V) {
+  return is$typed(v, id, hashPlaylistViewBasic)
+}
+
+export function validatePlaylistViewBasic<V>(v: V) {
+  return validate<PlaylistViewBasic & V>(v, id, hashPlaylistViewBasic)
+}

src/lexicon/types/app/rocksky/playlist/getPlaylist.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyPlaylistDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.playlist.getPlaylist'
+
+export interface QueryParams {
+  /** The URI of the playlist to retrieve. */
+  uri: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyPlaylistDefs.PlaylistViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/playlist/getPlaylists.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyPlaylistDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.playlist.getPlaylists'
+
+export interface QueryParams {
+  /** The maximum number of playlists to return. */
+  limit?: number
+  /** The offset for pagination, used to skip a number of playlists. */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/radio.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.radio'
+
+export interface Record {
+  $type: 'app.rocksky.radio'
+  /** The name of the radio station. */
+  name: string
+  /** The URL of the radio station. */
+  url: string
+  /** A description of the radio station. */
+  description?: string
+  /** The genre of the radio station. */
+  genre?: string
+  /** The logo of the radio station. */
+  logo?: BlobRef
+  /** The website of the radio station. */
+  website?: string
+  /** The date when the radio station was created. */
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

src/lexicon/types/app/rocksky/radio/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.radio.defs'
+
+export interface RadioViewBasic {
+  $type?: 'app.rocksky.radio.defs#radioViewBasic'
+  /** The unique identifier of the radio. */
+  id?: string
+  /** The name of the radio. */
+  name?: string
+  /** A brief description of the radio. */
+  description?: string
+  /** The date and time when the radio was created. */
+  createdAt?: string
+}
+
+const hashRadioViewBasic = 'radioViewBasic'
+
+export function isRadioViewBasic<V>(v: V) {
+  return is$typed(v, id, hashRadioViewBasic)
+}
+
+export function validateRadioViewBasic<V>(v: V) {
+  return validate<RadioViewBasic & V>(v, id, hashRadioViewBasic)
+}
+
+export interface RadioViewDetailed {
+  $type?: 'app.rocksky.radio.defs#radioViewDetailed'
+  /** The unique identifier of the radio. */
+  id?: string
+  /** The name of the radio. */
+  name?: string
+  /** A brief description of the radio. */
+  description?: string
+  /** The website of the radio. */
+  website?: string
+  /** The streaming URL of the radio. */
+  url?: string
+  /** The genre of the radio. */
+  genre?: string
+  /** The logo of the radio station. */
+  logo?: string
+  /** The date and time when the radio was created. */
+  createdAt?: string
+}
+
+const hashRadioViewDetailed = 'radioViewDetailed'
+
+export function isRadioViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashRadioViewDetailed)
+}
+
+export function validateRadioViewDetailed<V>(v: V) {
+  return validate<RadioViewDetailed & V>(v, id, hashRadioViewDetailed)
+}

src/lexicon/types/app/rocksky/scrobble.ts

···
 
 export interface Record {
   $type: 'app.rocksky.scrobble'
-  /** The track number of the song in the album. */
-  trackNumber?: number
-  /** The disc number of the song in the album. */
-  discNumber?: number
   /** The title of the song. */
   title: string
   /** The artist of the song. */
   artist: string
-  /** The artist of the album the song is from. */
+  /** The album artist of the song. */
   albumArtist: string
-  /** The album the song is from. */
+  /** The album of the song. */
   album: string
   /** The duration of the song in seconds. */
   duration: number
+  /** The track number of the song in the album. */
+  trackNumber?: number
+  /** The disc number of the song in the album. */
+  discNumber?: number
   /** The release date of the song. */
   releaseDate?: string
   /** The year the song was released. */
···
   composer?: string
   /** The lyrics of the song. */
   lyrics?: string
-  /** The copyright message. */
+  /** The copyright message of the song. */
   copyrightMessage?: string
   /** Informations about the song */
   wiki?: string
···
   tidalLink?: string
   /** The Apple Music link of the song. */
   appleMusicLink?: string
-  /** The date the song was created. */
+  /** The date when the song was created. */
   createdAt: string
   /** The MusicBrainz ID of the song. */
   mbid?: string

src/lexicon/types/app/rocksky/scrobble/createScrobble.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyScrobbleDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.scrobble.createScrobble'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The title of the track being scrobbled */
+  title: string
+  /** The artist of the track being scrobbled */
+  artist: string
+  /** The album of the track being scrobbled */
+  album?: string
+  /** The duration of the track in seconds */
+  duration?: number
+  /** The MusicBrainz ID of the track, if available */
+  mbId?: string
+  /** The URL of the album art for the track */
+  albumArt?: string
+  /** The track number of the track in the album */
+  trackNumber?: number
+  /** The release date of the track, formatted as YYYY-MM-DD */
+  releaseDate?: string
+  /** The year the track was released */
+  year?: number
+  /** The disc number of the track in the album, if applicable */
+  discNumber?: number
+  /** The lyrics of the track, if available */
+  lyrics?: string
+  /** The composer of the track, if available */
+  composer?: string
+  /** The copyright message for the track, if available */
+  copyrightMessage?: string
+  /** The record label of the track, if available */
+  label?: string
+  /** The URL of the artist's picture, if available */
+  artistPicture?: string
+  /** The Spotify link for the track, if available */
+  spotifyLink?: string
+  /** The Last.fm link for the track, if available */
+  lastfmLink?: string
+  /** The Tidal link for the track, if available */
+  tidalLink?: string
+  /** The Apple Music link for the track, if available */
+  appleMusicLink?: string
+  /** The Youtube link for the track, if available */
+  youtubeLink?: string
+  /** The Deezer link for the track, if available */
+  deezerLink?: string
+  /** The timestamp of the scrobble in milliseconds since epoch */
+  timestamp?: number
+}
+
+export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewBasic
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/scrobble/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.scrobble.defs'
+
+export interface ScrobbleViewBasic {
+  $type?: 'app.rocksky.scrobble.defs#scrobbleViewBasic'
+  /** The unique identifier of the scrobble. */
+  id?: string
+  /** The handle of the user who created the scrobble. */
+  user?: string
+  /** The title of the scrobble. */
+  title?: string
+  /** The artist of the song. */
+  artist?: string
+  /** The URI of the artist. */
+  artistUri?: string
+  /** The album of the song. */
+  album?: string
+  /** The URI of the album. */
+  albumUri?: string
+  /** The album art URL of the song. */
+  cover?: string
+  /** The timestamp when the scrobble was created. */
+  date?: string
+  /** The URI of the scrobble. */
+  uri?: string
+  /** The SHA256 hash of the scrobble data. */
+  sha256?: string
+}
+
+const hashScrobbleViewBasic = 'scrobbleViewBasic'
+
+export function isScrobbleViewBasic<V>(v: V) {
+  return is$typed(v, id, hashScrobbleViewBasic)
+}
+
+export function validateScrobbleViewBasic<V>(v: V) {
+  return validate<ScrobbleViewBasic & V>(v, id, hashScrobbleViewBasic)
+}
+
+export interface ScrobbleViewDetailed {
+  $type?: 'app.rocksky.scrobble.defs#scrobbleViewDetailed'
+  /** The unique identifier of the scrobble. */
+  id?: string
+  /** The handle of the user who created the scrobble. */
+  user?: string
+  /** The title of the scrobble. */
+  title?: string
+  /** The artist of the song. */
+  artist?: string
+  /** The URI of the artist. */
+  artistUri?: string
+  /** The album of the song. */
+  album?: string
+  /** The URI of the album. */
+  albumUri?: string
+  /** The album art URL of the song. */
+  cover?: string
+  /** The timestamp when the scrobble was created. */
+  date?: string
+  /** The URI of the scrobble. */
+  uri?: string
+  /** The SHA256 hash of the scrobble data. */
+  sha256?: string
+  /** The number of listeners */
+  listeners?: number
+  /** The number of scrobbles for this song */
+  scrobbles?: number
+}
+
+const hashScrobbleViewDetailed = 'scrobbleViewDetailed'
+
+export function isScrobbleViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashScrobbleViewDetailed)
+}
+
+export function validateScrobbleViewDetailed<V>(v: V) {
+  return validate<ScrobbleViewDetailed & V>(v, id, hashScrobbleViewDetailed)
+}

src/lexicon/types/app/rocksky/scrobble/getScrobble.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyScrobbleDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.scrobble.getScrobble'
+
+export interface QueryParams {
+  /** The unique identifier of the scrobble */
+  uri: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/scrobble/getScrobbles.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyScrobbleDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.scrobble.getScrobbles'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did?: string
+  /** The maximum number of scrobbles to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout'
+
+export interface Record {
+  $type: 'app.rocksky.shout'
+  /** The message of the shout. */
+  message: string
+  /** The date when the shout was created. */
+  createdAt: string
+  parent?: ComAtprotoRepoStrongRef.Main
+  subject: ComAtprotoRepoStrongRef.Main
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

src/lexicon/types/app/rocksky/shout/createShout.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.createShout'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The content of the shout */
+  message?: string
+}
+
+export type OutputSchema = AppRockskyShoutDefs.ShoutView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.defs'
+
+export interface Author {
+  $type?: 'app.rocksky.shout.defs#author'
+  /** The unique identifier of the author. */
+  id?: string
+  /** The decentralized identifier (DID) of the author. */
+  did?: string
+  /** The handle of the author. */
+  handle?: string
+  /** The display name of the author. */
+  displayName?: string
+  /** The URL of the author's avatar image. */
+  avatar?: string
+}
+
+const hashAuthor = 'author'
+
+export function isAuthor<V>(v: V) {
+  return is$typed(v, id, hashAuthor)
+}
+
+export function validateAuthor<V>(v: V) {
+  return validate<Author & V>(v, id, hashAuthor)
+}
+
+export interface ShoutView {
+  $type?: 'app.rocksky.shout.defs#shoutView'
+  /** The unique identifier of the shout. */
+  id?: string
+  /** The content of the shout. */
+  message?: string
+  /** The ID of the parent shout if this is a reply, otherwise null. */
+  parent?: string
+  /** The date and time when the shout was created. */
+  createdAt?: string
+  author?: Author
+}
+
+const hashShoutView = 'shoutView'
+
+export function isShoutView<V>(v: V) {
+  return is$typed(v, id, hashShoutView)
+}
+
+export function validateShoutView<V>(v: V) {
+  return validate<ShoutView & V>(v, id, hashShoutView)
+}

src/lexicon/types/app/rocksky/shout/getAlbumShouts.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.getAlbumShouts'
+
+export interface QueryParams {
+  /** The unique identifier of the album to retrieve shouts for */
+  uri: string
+  /** The maximum number of shouts to return */
+  limit?: number
+  /** The number of shouts to skip before starting to collect the result set */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/getArtistShouts.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.getArtistShouts'
+
+export interface QueryParams {
+  /** The URI of the artist to retrieve shouts for */
+  uri: string
+  /** The maximum number of shouts to return */
+  limit?: number
+  /** The number of shouts to skip before starting to collect the result set */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/getProfileShouts.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.getProfileShouts'
+
+export interface QueryParams {
+  /** The DID or handle of the actor */
+  did: string
+  /** The offset for pagination */
+  offset?: number
+  /** The maximum number of shouts to return */
+  limit?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/getShoutReplies.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.getShoutReplies'
+
+export interface QueryParams {
+  /** The URI of the shout to retrieve replies for */
+  uri: string
+  /** The maximum number of shouts to return */
+  limit?: number
+  /** The number of shouts to skip before starting to collect the result set */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/getTrackShouts.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.getTrackShouts'
+
+export interface QueryParams {
+  /** The URI of the track to retrieve shouts for */
+  uri: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/removeShout.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.removeShout'
+
+export interface QueryParams {
+  /** The ID of the shout to be removed */
+  id: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyShoutDefs.ShoutView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/replyShout.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.replyShout'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The unique identifier of the shout to reply to */
+  shoutId: string
+  /** The content of the reply */
+  message: string
+}
+
+export type OutputSchema = AppRockskyShoutDefs.ShoutView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/shout/reportShout.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyShoutDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.shout.reportShout'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The unique identifier of the shout to report */
+  shoutId: string
+  /** The reason for reporting the shout */
+  reason?: string
+}
+
+export type OutputSchema = AppRockskyShoutDefs.ShoutView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/song.ts

···
 
 export interface Record {
   $type: 'app.rocksky.song'
-  /** The track number of the song in the album. */
-  trackNumber?: number
-  /** The disc number of the song in the album. */
-  discNumber?: number
   /** The title of the song. */
   title: string
   /** The artist of the song. */
   artist: string
-  /** The artist of the album the song is from. */
+  /** The album artist of the song. */
   albumArtist: string
-  /** The album the song is from. */
+  /** The album of the song. */
   album: string
   /** The duration of the song in seconds. */
   duration: number
+  /** The track number of the song in the album. */
+  trackNumber?: number
+  /** The disc number of the song in the album. */
+  discNumber?: number
   /** The release date of the song. */
   releaseDate?: string
   /** The year the song was released. */
···
   composer?: string
   /** The lyrics of the song. */
   lyrics?: string
-  /** The copyright message. */
+  /** The copyright message of the song. */
   copyrightMessage?: string
   /** Informations about the song */
   wiki?: string
···
   tidalLink?: string
   /** The Apple Music link of the song. */
   appleMusicLink?: string
-  /** The date the song was created. */
+  /** The date when the song was created. */
   createdAt: string
   /** The MusicBrainz ID of the song. */
   mbid?: string

src/lexicon/types/app/rocksky/song/createSong.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.song.createSong'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The title of the song */
+  title: string
+  /** The artist of the song */
+  artist: string
+  /** The album artist of the song, if different from the main artist */
+  albumArtist: string
+  /** The album of the song, if applicable */
+  album: string
+  /** The duration of the song in seconds */
+  duration?: number
+  /** The MusicBrainz ID of the song, if available */
+  mbId?: string
+  /** The URL of the album art for the song */
+  albumArt?: string
+  /** The track number of the song in the album, if applicable */
+  trackNumber?: number
+  /** The release date of the song, formatted as YYYY-MM-DD */
+  releaseDate?: string
+  /** The year the song was released */
+  year?: number
+  /** The disc number of the song in the album, if applicable */
+  discNumber?: number
+  /** The lyrics of the song, if available */
+  lyrics?: string
+}
+
+export type OutputSchema = AppRockskySongDefs.SongViewDetailed
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/song/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.song.defs'
+
+export interface SongViewBasic {
+  $type?: 'app.rocksky.song.defs#songViewBasic'
+  /** The unique identifier of the song. */
+  id?: string
+  /** The title of the song. */
+  title?: string
+  /** The artist of the song. */
+  artist?: string
+  /** The artist of the album the song belongs to. */
+  albumArtist?: string
+  /** The URL of the album art image. */
+  albumArt?: string
+  /** The URI of the song. */
+  uri?: string
+  /** The album of the song. */
+  album?: string
+  /** The duration of the song in milliseconds. */
+  duration?: number
+  /** The track number of the song in the album. */
+  trackNumber?: number
+  /** The disc number of the song in the album. */
+  discNumber?: number
+  /** The number of times the song has been played. */
+  playCount?: number
+  /** The number of unique listeners who have played the song. */
+  uniqueListeners?: number
+  /** The URI of the album the song belongs to. */
+  albumUri?: string
+  /** The URI of the artist of the song. */
+  artistUri?: string
+  /** The SHA256 hash of the song. */
+  sha256?: string
+  /** The timestamp when the song was created. */
+  createdAt?: string
+}
+
+const hashSongViewBasic = 'songViewBasic'
+
+export function isSongViewBasic<V>(v: V) {
+  return is$typed(v, id, hashSongViewBasic)
+}
+
+export function validateSongViewBasic<V>(v: V) {
+  return validate<SongViewBasic & V>(v, id, hashSongViewBasic)
+}
+
+export interface SongViewDetailed {
+  $type?: 'app.rocksky.song.defs#songViewDetailed'
+  /** The unique identifier of the song. */
+  id?: string
+  /** The title of the song. */
+  title?: string
+  /** The artist of the song. */
+  artist?: string
+  /** The artist of the album the song belongs to. */
+  albumArtist?: string
+  /** The URL of the album art image. */
+  albumArt?: string
+  /** The URI of the song. */
+  uri?: string
+  /** The album of the song. */
+  album?: string
+  /** The duration of the song in milliseconds. */
+  duration?: number
+  /** The track number of the song in the album. */
+  trackNumber?: number
+  /** The disc number of the song in the album. */
+  discNumber?: number
+  /** The number of times the song has been played. */
+  playCount?: number
+  /** The number of unique listeners who have played the song. */
+  uniqueListeners?: number
+  /** The URI of the album the song belongs to. */
+  albumUri?: string
+  /** The URI of the artist of the song. */
+  artistUri?: string
+  /** The SHA256 hash of the song. */
+  sha256?: string
+  /** The timestamp when the song was created. */
+  createdAt?: string
+}
+
+const hashSongViewDetailed = 'songViewDetailed'
+
+export function isSongViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashSongViewDetailed)
+}
+
+export function validateSongViewDetailed<V>(v: V) {
+  return validate<SongViewDetailed & V>(v, id, hashSongViewDetailed)
+}

src/lexicon/types/app/rocksky/song/getSong.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.song.getSong'
+
+export interface QueryParams {
+  /** The unique identifier of the song to retrieve */
+  uri: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskySongDefs.SongViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/song/getSongs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskySongDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.song.getSongs'
+
+export interface QueryParams {
+  /** The maximum number of songs to return */
+  limit?: number
+  /** The offset for pagination */
+  offset?: number
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  songs?: AppRockskySongDefs.SongViewBasic[]
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/spotify/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.spotify.defs'
+
+export interface SpotifyTrackView {
+  $type?: 'app.rocksky.spotify.defs#spotifyTrackView'
+  /** The unique identifier of the Spotify track. */
+  id?: string
+  /** The name of the track. */
+  name?: string
+  /** The name of the artist. */
+  artist?: string
+  /** The name of the album. */
+  album?: string
+  /** The duration of the track in milliseconds. */
+  duration?: number
+  /** A URL to a preview of the track. */
+  previewUrl?: string
+}
+
+const hashSpotifyTrackView = 'spotifyTrackView'
+
+export function isSpotifyTrackView<V>(v: V) {
+  return is$typed(v, id, hashSpotifyTrackView)
+}
+
+export function validateSpotifyTrackView<V>(v: V) {
+  return validate<SpotifyTrackView & V>(v, id, hashSpotifyTrackView)
+}

src/lexicon/types/app/rocksky/spotify/getCurrentlyPlaying.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyPlayerDefs from '../player/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.spotify.getCurrentlyPlaying'
+
+export interface QueryParams {
+  /** Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user. */
+  actor?: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/spotify/next.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.spotify.next'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/spotify/pause.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.spotify.pause'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/spotify/play.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.spotify.play'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/spotify/previous.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.spotify.previous'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/spotify/seek.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.spotify.seek'
+
+export interface QueryParams {
+  /** The position in seconds to seek to */
+  position: number
+}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/app/rocksky/stats/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.stats.defs'
+
+export interface StatsView {
+  $type?: 'app.rocksky.stats.defs#statsView'
+  /** The total number of scrobbles. */
+  scrobbles?: number
+  /** The total number of unique artists scrobbled. */
+  artists?: number
+  /** The total number of tracks marked as loved. */
+  lovedTracks?: number
+  /** The total number of unique albums scrobbled. */
+  albums?: number
+  /** The total number of unique tracks scrobbled. */
+  tracks?: number
+}
+
+const hashStatsView = 'statsView'
+
+export function isStatsView<V>(v: V) {
+  return is$typed(v, id, hashStatsView)
+}
+
+export function validateStatsView<V>(v: V) {
+  return validate<StatsView & V>(v, id, hashStatsView)
+}

src/lexicon/types/app/rocksky/stats/getStats.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as AppRockskyStatsDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.rocksky.stats.getStats'
+
+export interface QueryParams {
+  /** The DID or handle of the user to get stats for. */
+  did: string
+}
+
+export type InputSchema = undefined
+export type OutputSchema = AppRockskyStatsDefs.StatsView
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

src/lexicon/types/com/atproto/repo/strongRef.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.strongRef'
+
+export interface Main {
+  $type?: 'com.atproto.repo.strongRef'
+  uri: string
+  cid: string
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
+}