+3 -8

services/appview/deno.json

reviewed

··· 1 1 { 2 2 "tasks": { 3 3 "dev": "deno run -A --watch main.ts", 4 4 - "codegen": "deno run -A jsr:@sprk/lex-cli@^0.1.7 gen-server --hono-import hono --yes ./lexicon ../../lexicons", 4 4 + "codegen": "deno run -A jsr:@sprk/lex-cli@^0.2.1 gen-server --yes ./lexicon ../../lexicons", 5 5 "start": "deno run --allow-net --allow-env --env-file --allow-sys --allow-read --allow-ffi main.ts", 6 6 "docker-dev": "docker compose -f compose.dev.yaml up --build --watch" 7 7 }, ··· 20 20 "@atproto/identity": "npm:@atproto/identity@^0.4.8", 21 21 "@atproto/lexicon": "npm:@atproto/lexicon@^0.4.12", 22 22 "@atproto/syntax": "npm:@atproto/syntax@^0.3.4", 23 23 - "@sprk/xrpc-server": "jsr:@sprk/xrpc-server@^0.1.5", 24 24 - "express": "npm:express@^4.21.2", 23 23 + "@sprk/xrpc-server": "jsr:@sprk/xrpc-server@^0.2.0", 25 24 "jose": "npm:jose@^6.0.12", 26 26 - "key-encoder": "npm:key-encoder@^2.0.3", 27 25 "mongoose": "npm:mongoose@^8.17.1", 28 26 "multiformats": "npm:multiformats@^9.9.0", 29 29 - "p-queue": "npm:p-queue@^8.1.0", 30 30 - "pino": "npm:pino@^8.21.0", 31 31 - "pino-pretty": "npm:pino-pretty@^13.1.1", 32 32 - "ws": "npm:ws@^8.18.3" 27 27 + "p-queue": "npm:p-queue@^8.1.0" 33 28 }, 34 29 "compilerOptions": { 35 30 "jsx": "precompile",

+60 -185

services/appview/deno.lock

reviewed

··· 6 6 "jsr:@logtape/logtape@^1.0.4": "1.0.4", 7 7 "jsr:@logtape/logtape@^1.1.0-dev.333+b25e634b": "1.1.0-dev.333+b25e634b", 8 8 "jsr:@logtape/pretty@^1.1.0-dev.333+b25e634b": "1.1.0-dev.333+b25e634b", 9 9 - "jsr:@sprk/xrpc-server@~0.1.5": "0.1.5", 9 9 + "jsr:@sprk/xrpc-server@0.2": "0.2.0", 10 10 + "jsr:@std/assert@*": "1.0.14", 11 11 + "jsr:@std/assert@^1.0.14": "1.0.14", 10 12 "jsr:@std/encoding@*": "1.0.10", 11 13 "jsr:@std/encoding@^1.0.10": "1.0.10", 14 14 + "jsr:@std/internal@^1.0.10": "1.0.10", 12 15 "jsr:@std/text@*": "1.0.16", 16 16 + "jsr:@zod/zod@^4.0.17": "4.0.17", 13 17 "npm:@atproto/api@~0.14.22": "0.14.22", 14 18 "npm:@atproto/common@~0.4.11": "0.4.11", 15 19 "npm:@atproto/crypto@~0.4.4": "0.4.4", ··· 17 21 "npm:@atproto/lexicon@~0.4.11": "0.4.12", 18 22 "npm:@atproto/lexicon@~0.4.12": "0.4.12", 19 23 "npm:@atproto/repo@~0.8.5": "0.8.5", 20 20 - "npm:@atproto/sync@*": "0.1.30", 21 24 "npm:@atproto/sync@~0.1.30": "0.1.30", 22 25 "npm:@atproto/syntax@~0.3.4": "0.3.4", 23 26 "npm:@atproto/xrpc@0.7": "0.7.1", 24 27 "npm:@atproto/xrpc@~0.7.1": "0.7.1", 25 28 "npm:@bufbuild/protobuf@1.5.0": "1.5.0", 26 26 - "npm:@types/node@*": "24.0.7", 29 29 + "npm:@types/node@*": "24.2.0", 27 30 "npm:@types/node@24.0.7": "24.0.7", 28 31 "npm:dotenv@*": "17.2.1", 29 32 "npm:dotenv@^17.2.1": "17.2.1", 30 30 - "npm:express@^4.21.2": "4.21.2", 31 33 "npm:http-errors@2": "2.0.0", 32 34 "npm:jose@*": "6.0.12", 33 35 "npm:jose@^6.0.12": "6.0.12", 34 34 - "npm:key-encoder@^2.0.3": "2.0.3", 35 36 "npm:lodash@*": "4.17.21", 36 37 "npm:mongoose@^8.17.1": "8.17.1", 37 38 "npm:multiformats@^9.9.0": "9.9.0", 38 39 "npm:p-queue@^8.1.0": "8.1.0", 39 39 - "npm:pino-pretty@^13.1.1": "13.1.1", 40 40 - "npm:pino@^8.21.0": "8.21.0", 41 40 "npm:rate-limiter-flexible@^2.4.1": "2.4.2", 42 42 - "npm:uint8arrays@*": "3.0.0", 41 41 + "npm:uint8arrays@*": "5.1.0", 43 42 "npm:uint8arrays@3.0.0": "3.0.0", 44 44 - "npm:ws@^8.12.0": "8.18.3", 45 45 - "npm:ws@^8.18.3": "8.18.3", 46 46 - "npm:zod@^3.23.8": "3.25.76" 43 43 + "npm:ws@^8.12.0": "8.18.3" 47 44 }, 48 45 "jsr": { 49 46 "@hono/hono@4.9.1": { ··· 62 59 "npm:@types/node@24.0.7" 63 60 ] 64 61 }, 65 65 - "@sprk/xrpc-server@0.1.5": { 66 66 - "integrity": "2ad3f3a8b8de8ef576280d522a33b65b1c444f692ffce2e5c9c1aefb39e62d90", 62 62 + "@sprk/xrpc-server@0.2.0": { 63 63 + "integrity": "40bf683520379349caa968fa55bdcd62801097224ef4692e465281227c31177b", 67 64 "dependencies": [ 68 65 "jsr:@hono/hono@^4.7.10", 66 66 + "jsr:@sprk/xrpc-server", 67 67 + "jsr:@std/assert@^1.0.14", 68 68 + "jsr:@zod/zod", 69 69 "npm:@atproto/common", 70 70 "npm:@atproto/crypto", 71 71 "npm:@atproto/lexicon@~0.4.11", ··· 73 73 "npm:http-errors", 74 74 "npm:rate-limiter-flexible", 75 75 "npm:uint8arrays@3.0.0", 76 76 - "npm:ws@^8.12.0", 77 77 - "npm:zod" 76 76 + "npm:ws" 77 77 + ] 78 78 + }, 79 79 + "@std/assert@1.0.14": { 80 80 + "integrity": "68d0d4a43b365abc927f45a9b85c639ea18a9fab96ad92281e493e4ed84abaa4", 81 81 + "dependencies": [ 82 82 + "jsr:@std/internal" 78 83 ] 79 84 }, 80 85 "@std/encoding@1.0.10": { 81 86 "integrity": "8783c6384a2d13abd5e9e87a7ae0520a30e9f56aeeaa3bdf910a3eaaf5c811a1" 82 87 }, 88 88 + "@std/internal@1.0.10": { 89 89 + "integrity": "e3be62ce42cab0e177c27698e5d9800122f67b766a0bea6ca4867886cbde8cf7" 90 90 + }, 83 91 "@std/text@1.0.16": { 84 92 "integrity": "ddb9853b75119a2473857d691cf1ec02ad90793a2e8b4a4ac49d7354281a0cf8" 93 93 + }, 94 94 + "@zod/zod@4.0.17": { 95 95 + "integrity": "4d9be90a1a3c16e09dad7ce25986379d7ab8ed5f5f843288509af6bf8def525f" 85 96 } 86 97 }, 87 98 "npm": { ··· 93 104 "@atproto/syntax@0.4.0", 94 105 "@atproto/xrpc@0.6.12", 95 106 "await-lock", 96 96 - "multiformats", 107 107 + "multiformats@9.9.0", 97 108 "tlds", 98 109 "zod" 99 110 ] ··· 102 113 "integrity": "sha512-vrXwGNoFGogodjQvJDxAeP3QbGtawgZute2ed1XdRO0wMixLk3qewtikZm06H259QDJVu6voKC5mubml+WgQUw==", 103 114 "dependencies": [ 104 115 "graphemer", 105 105 - "multiformats", 106 106 - "uint8arrays", 116 116 + "multiformats@9.9.0", 117 117 + "uint8arrays@3.0.0", 107 118 "zod" 108 119 ] 109 120 }, ··· 114 125 "@ipld/dag-cbor", 115 126 "cbor-x", 116 127 "iso-datestring-validator", 117 117 - "multiformats", 128 128 + "multiformats@9.9.0", 118 129 "pino" 119 130 ] 120 131 }, ··· 123 134 "dependencies": [ 124 135 "@noble/curves", 125 136 "@noble/hashes", 126 126 - "uint8arrays" 137 137 + "uint8arrays@3.0.0" 127 138 ] 128 139 }, 129 140 "@atproto/identity@0.4.8": { ··· 139 150 "@atproto/common-web", 140 151 "@atproto/syntax@0.4.0", 141 152 "iso-datestring-validator", 142 142 - "multiformats", 153 153 + "multiformats@9.9.0", 143 154 "zod" 144 155 ] 145 156 }, ··· 151 162 "@atproto/crypto", 152 163 "@atproto/lexicon", 153 164 "@ipld/dag-cbor", 154 154 - "multiformats", 155 155 - "uint8arrays", 165 165 + "multiformats@9.9.0", 166 166 + "uint8arrays@3.0.0", 156 167 "varint", 157 168 "zod" 158 169 ] ··· 166 177 "@atproto/repo", 167 178 "@atproto/syntax@0.4.0", 168 179 "@atproto/xrpc-server", 169 169 - "multiformats", 180 180 + "multiformats@9.9.0", 170 181 "p-queue@6.6.2", 171 182 "ws" 172 183 ] ··· 189 200 "http-errors", 190 201 "mime-types", 191 202 "rate-limiter-flexible", 192 192 - "uint8arrays", 203 203 + "uint8arrays@3.0.0", 193 204 "ws", 194 205 "zod" 195 206 ] ··· 245 256 "integrity": "sha512-1VVh2huHsuohdXC1bGJNE8WR72slZ9XE2T3wbBBq31dm7ZBatmKLLxrB+XAqafxfRFjv08RZmj/W/ZqaM13AuA==", 246 257 "dependencies": [ 247 258 "cborg", 248 248 - "multiformats" 259 259 + "multiformats@9.9.0" 249 260 ] 250 261 }, 251 262 "@mongodb-js/saslprep@1.3.0": { ··· 263 274 "@noble/hashes@1.8.0": { 264 275 "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==" 265 276 }, 266 266 - "@types/bn.js@5.2.0": { 267 267 - "integrity": "sha512-DLbJ1BPqxvQhIGbeu8VbUC1DiAiahHtAYvA0ZEAa4P31F7IaArc8z3C3BRQdWX4mtLQuABG4yzp76ZrS02Ui1Q==", 277 277 + "@types/node@24.0.7": { 278 278 + "integrity": "sha512-YIEUUr4yf8q8oQoXPpSlnvKNVKDQlPMWrmOcgzoduo7kvA2UF0/BwJ/eMKFTiTtkNL17I0M6Xe2tvwFU7be6iw==", 268 279 "dependencies": [ 269 269 - "@types/node" 280 280 + "undici-types@7.8.0" 270 281 ] 271 282 }, 272 272 - "@types/elliptic@6.4.18": { 273 273 - "integrity": "sha512-UseG6H5vjRiNpQvrhy4VF/JXdA3V/Fp5amvveaL+fs28BZ6xIKJBPnUPRlEaZpysD9MbpfaLi8lbl7PGUAkpWw==", 283 283 + "@types/node@24.2.0": { 284 284 + "integrity": "sha512-3xyG3pMCq3oYCNg7/ZP+E1ooTaGB4cG8JWRsqqOYQdbWNY4zbaV0Ennrd7stjiJEFZCaybcIgpTjJWHRfBSIDw==", 274 285 "dependencies": [ 275 275 - "@types/bn.js" 276 276 - ] 277 277 - }, 278 278 - "@types/node@24.0.7": { 279 279 - "integrity": "sha512-YIEUUr4yf8q8oQoXPpSlnvKNVKDQlPMWrmOcgzoduo7kvA2UF0/BwJ/eMKFTiTtkNL17I0M6Xe2tvwFU7be6iw==", 280 280 - "dependencies": [ 281 281 - "undici-types" 286 286 + "undici-types@7.10.0" 282 287 ] 283 288 }, 284 289 "@types/webidl-conversions@7.0.3": { ··· 306 311 "array-flatten@1.1.1": { 307 312 "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==" 308 313 }, 309 309 - "asn1.js@5.4.1": { 310 310 - "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==", 311 311 - "dependencies": [ 312 312 - "bn.js", 313 313 - "inherits", 314 314 - "minimalistic-assert", 315 315 - "safer-buffer" 316 316 - ] 317 317 - }, 318 314 "atomic-sleep@1.0.0": { 319 315 "integrity": "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==" 320 316 }, ··· 323 319 }, 324 320 "base64-js@1.5.1": { 325 321 "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==" 326 326 - }, 327 327 - "bn.js@4.12.2": { 328 328 - "integrity": "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==" 329 322 }, 330 323 "body-parser@1.20.3": { 331 324 "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", ··· 344 337 "unpipe" 345 338 ] 346 339 }, 347 347 - "brorand@1.1.0": { 348 348 - "integrity": "sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==" 349 349 - }, 350 340 "bson@6.10.4": { 351 341 "integrity": "sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==" 352 342 }, ··· 400 390 "integrity": "sha512-b3tFPA9pUr2zCUiCfRd2+wok2/LBSNUMKOuRRok+WlvvAgEt/PlbgPTsZUcwCOs53IJvLgTp0eotwtosE6njug==", 401 391 "bin": true 402 392 }, 403 403 - "colorette@2.0.20": { 404 404 - "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==" 405 405 - }, 406 393 "content-disposition@0.5.4": { 407 394 "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", 408 395 "dependencies": [ ··· 418 405 "cookie@0.7.1": { 419 406 "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==" 420 407 }, 421 421 - "dateformat@4.6.3": { 422 422 - "integrity": "sha512-2P0p0pFGzHS5EMnhdxQi7aJN+iMheud0UhG4dlE1DLAlvL8JHjJJTX/CSm4JXwV0Ka5nGk3zC5mcb5bUQUxxMA==" 423 423 - }, 424 408 "debug@2.6.9": { 425 409 "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", 426 410 "dependencies": [ ··· 456 440 "ee-first@1.1.1": { 457 441 "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" 458 442 }, 459 459 - "elliptic@6.6.1": { 460 460 - "integrity": "sha512-RaddvvMatK2LJHqFJ+YA4WysVN5Ita9E35botqIYspQ4TkRAlCicdzKOjlyv/1Za5RyTNn7di//eEV0uTAfe3g==", 461 461 - "dependencies": [ 462 462 - "bn.js", 463 463 - "brorand", 464 464 - "hash.js", 465 465 - "hmac-drbg", 466 466 - "inherits", 467 467 - "minimalistic-assert", 468 468 - "minimalistic-crypto-utils" 469 469 - ] 470 470 - }, 471 443 "encodeurl@1.0.2": { 472 444 "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==" 473 445 }, 474 446 "encodeurl@2.0.0": { 475 447 "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==" 476 476 - }, 477 477 - "end-of-stream@1.4.5": { 478 478 - "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", 479 479 - "dependencies": [ 480 480 - "once" 481 481 - ] 482 448 }, 483 449 "es-define-property@1.0.1": { 484 450 "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==" ··· 545 511 "utils-merge", 546 512 "vary" 547 513 ] 548 548 - }, 549 549 - "fast-copy@3.0.2": { 550 550 - "integrity": "sha512-dl0O9Vhju8IrcLndv2eU4ldt1ftXMqqfgN4H1cpmGV7P6jeB9FwpN9a2c8DPGE1Ys88rNUJVYDHq73CGAGOPfQ==" 551 514 }, 552 515 "fast-redact@3.5.0": { 553 516 "integrity": "sha512-dwsoQlS7h9hMeYUq1W++23NDcBLV4KqONnITDV9DjfS3q1SgDGVrBdvvTLUotWtPSD7asWDV9/CmsZPy8Hf70A==" 554 517 }, 555 555 - "fast-safe-stringify@2.1.1": { 556 556 - "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==" 557 557 - }, 558 518 "finalhandler@1.3.1": { 559 519 "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", 560 520 "dependencies": [ ··· 607 567 "has-symbols@1.1.0": { 608 568 "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==" 609 569 }, 610 610 - "hash.js@1.1.7": { 611 611 - "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", 612 612 - "dependencies": [ 613 613 - "inherits", 614 614 - "minimalistic-assert" 615 615 - ] 616 616 - }, 617 570 "hasown@2.0.2": { 618 571 "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", 619 572 "dependencies": [ 620 573 "function-bind" 621 574 ] 622 575 }, 623 623 - "help-me@5.0.0": { 624 624 - "integrity": "sha512-7xgomUX6ADmcYzFik0HzAxh/73YlKR9bmFzf51CZwR+b6YtzU2m0u49hQCqV6SvlqIqsaxovfwdvbnsw3b/zpg==" 625 625 - }, 626 626 - "hmac-drbg@1.0.1": { 627 627 - "integrity": "sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==", 628 628 - "dependencies": [ 629 629 - "hash.js", 630 630 - "minimalistic-assert", 631 631 - "minimalistic-crypto-utils" 632 632 - ] 633 633 - }, 634 576 "http-errors@2.0.0": { 635 577 "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", 636 578 "dependencies": [ ··· 662 604 "jose@6.0.12": { 663 605 "integrity": "sha512-T8xypXs8CpmiIi78k0E+Lk7T2zlK4zDyg+o1CZ4AkOHgDg98ogdP2BeZ61lTFKFyoEwJ9RgAgN+SdM3iPgNonQ==" 664 606 }, 665 665 - "joycon@3.1.1": { 666 666 - "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==" 667 667 - }, 668 607 "kareem@2.6.3": { 669 608 "integrity": "sha512-C3iHfuGUXK2u8/ipq9LfjFfXFxAZMQJJq7vLS45r3D9Y2xQ/m4S8zaR4zMLFWh9AsNPXmcFfUDhTEO8UIC/V6Q==" 670 609 }, 671 671 - "key-encoder@2.0.3": { 672 672 - "integrity": "sha512-fgBtpAGIr/Fy5/+ZLQZIPPhsZEcbSlYu/Wu96tNDFNSjSACw5lEIOFeaVdQ/iwrb8oxjlWi6wmWdH76hV6GZjg==", 673 673 - "dependencies": [ 674 674 - "@types/elliptic", 675 675 - "asn1.js", 676 676 - "bn.js", 677 677 - "elliptic" 678 678 - ] 679 679 - }, 680 610 "lodash@4.17.21": { 681 611 "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==" 682 612 }, ··· 708 638 "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", 709 639 "bin": true 710 640 }, 711 711 - "minimalistic-assert@1.0.1": { 712 712 - "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==" 713 713 - }, 714 714 - "minimalistic-crypto-utils@1.0.1": { 715 715 - "integrity": "sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==" 716 716 - }, 717 717 - "minimist@1.2.8": { 718 718 - "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==" 719 719 - }, 720 641 "mongodb-connection-string-url@3.0.2": { 721 642 "integrity": "sha512-rMO7CGo/9BFwyZABcKAWL8UJwH/Kc2x0g72uhDWzG48URRax5TCIcJ7Rc3RZqffZzO/Gwff/jyKwCU9TN8gehA==", 722 643 "dependencies": [ ··· 759 680 "ms@2.1.3": { 760 681 "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" 761 682 }, 683 683 + "multiformats@13.4.0": { 684 684 + "integrity": "sha512-Mkb/QcclrJxKC+vrcIFl297h52QcKh2Az/9A5vbWytbQt4225UWWWmIuSsKksdww9NkIeYcA7DkfftyLuC/JSg==" 685 685 + }, 762 686 "multiformats@9.9.0": { 763 687 "integrity": "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==" 764 688 }, ··· 784 708 "ee-first" 785 709 ] 786 710 }, 787 787 - "once@1.4.0": { 788 788 - "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", 789 789 - "dependencies": [ 790 790 - "wrappy" 791 791 - ] 792 792 - }, 793 711 "p-finally@1.0.0": { 794 712 "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==" 795 713 }, ··· 829 747 "split2" 830 748 ] 831 749 }, 832 832 - "pino-abstract-transport@2.0.0": { 833 833 - "integrity": "sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==", 834 834 - "dependencies": [ 835 835 - "split2" 836 836 - ] 837 837 - }, 838 838 - "pino-pretty@13.1.1": { 839 839 - "integrity": "sha512-TNNEOg0eA0u+/WuqH0MH0Xui7uqVk9D74ESOpjtebSQYbNWJk/dIxCXIxFsNfeN53JmtWqYHP2OrIZjT/CBEnA==", 840 840 - "dependencies": [ 841 841 - "colorette", 842 842 - "dateformat", 843 843 - "fast-copy", 844 844 - "fast-safe-stringify", 845 845 - "help-me", 846 846 - "joycon", 847 847 - "minimist", 848 848 - "on-exit-leak-free", 849 849 - "pino-abstract-transport@2.0.0", 850 850 - "pump", 851 851 - "secure-json-parse", 852 852 - "sonic-boom@4.2.0", 853 853 - "strip-json-comments" 854 854 - ], 855 855 - "bin": true 856 856 - }, 857 750 "pino-std-serializers@6.2.2": { 858 751 "integrity": "sha512-cHjPPsE+vhj/tnhCy/wiMh3M3z3h/j15zHQX+S9GkTBgqJuTuJzYJ4gUyACLhDaJ7kk9ba9iRDmbH2tJU03OiA==" 859 752 }, ··· 863 756 "atomic-sleep", 864 757 "fast-redact", 865 758 "on-exit-leak-free", 866 866 - "pino-abstract-transport@1.2.0", 759 759 + "pino-abstract-transport", 867 760 "pino-std-serializers", 868 761 "process-warning", 869 762 "quick-format-unescaped", 870 763 "real-require", 871 764 "safe-stable-stringify", 872 872 - "sonic-boom@3.8.1", 765 765 + "sonic-boom", 873 766 "thread-stream" 874 767 ], 875 768 "bin": true ··· 887 780 "ipaddr.js" 888 781 ] 889 782 }, 890 890 - "pump@3.0.3": { 891 891 - "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==", 892 892 - "dependencies": [ 893 893 - "end-of-stream", 894 894 - "once" 895 895 - ] 896 896 - }, 897 783 "punycode@2.3.1": { 898 784 "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==" 899 785 }, ··· 942 828 }, 943 829 "safer-buffer@2.1.2": { 944 830 "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" 945 945 - }, 946 946 - "secure-json-parse@4.0.0": { 947 947 - "integrity": "sha512-dxtLJO6sc35jWidmLxo7ij+Eg48PM/kleBsxpC8QJE0qJICe+KawkDQmvCMZUr9u7WKVHgMW6vy3fQ7zMiFZMA==" 948 831 }, 949 832 "send@0.19.0": { 950 833 "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", ··· 1021 904 "atomic-sleep" 1022 905 ] 1023 906 }, 1024 1024 - "sonic-boom@4.2.0": { 1025 1025 - "integrity": "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==", 1026 1026 - "dependencies": [ 1027 1027 - "atomic-sleep" 1028 1028 - ] 1029 1029 - }, 1030 907 "sparse-bitfield@3.0.3": { 1031 908 "integrity": "sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ==", 1032 909 "dependencies": [ ··· 1044 921 "dependencies": [ 1045 922 "safe-buffer" 1046 923 ] 1047 1047 - }, 1048 1048 - "strip-json-comments@5.0.3": { 1049 1049 - "integrity": "sha512-1tB5mhVo7U+ETBKNf92xT4hrQa3pm0MZ0PQvuDnWgAAGHDsfp4lPSpiS6psrSiet87wyGPh9ft6wmhOMQ0hDiw==" 1050 924 }, 1051 925 "thread-stream@2.7.0": { 1052 926 "integrity": "sha512-qQiRWsU/wvNolI6tbbCKd9iKaTnCXsTwVxhhKM6nctPdujTyztjlbUkUTUymidWcMnZ5pWR0ej4a0tjsW021vw==", ··· 1077 951 "uint8arrays@3.0.0": { 1078 952 "integrity": "sha512-HRCx0q6O9Bfbp+HHSfQQKD7wU70+lydKVt4EghkdOvlK/NlrF90z+eXV34mUd48rNvVJXwkrMSPpCATkct8fJA==", 1079 953 "dependencies": [ 1080 1080 - "multiformats" 954 954 + "multiformats@9.9.0" 955 955 + ] 956 956 + }, 957 957 + "uint8arrays@5.1.0": { 958 958 + "integrity": "sha512-vA6nFepEmlSKkMBnLBaUMVvAC4G3CTmO58C12y4sq6WPDOR7mOFYOi7GlrQ4djeSbP6JG9Pv9tJDM97PedRSww==", 959 959 + "dependencies": [ 960 960 + "multiformats@13.4.0" 1081 961 ] 1082 962 }, 963 963 + "undici-types@7.10.0": { 964 964 + "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==" 965 965 + }, 1083 966 "undici-types@7.8.0": { 1084 967 "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==" 1085 968 }, ··· 1105 988 "webidl-conversions" 1106 989 ] 1107 990 }, 1108 1108 - "wrappy@1.0.2": { 1109 1109 - "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" 1110 1110 - }, 1111 991 "ws@8.18.3": { 1112 992 "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==" 1113 993 }, ··· 1120 1000 "jsr:@hono/hono@^4.9.1", 1121 1001 "jsr:@logtape/logtape@^1.0.4", 1122 1002 "jsr:@logtape/pretty@^1.1.0-dev.333+b25e634b", 1123 1123 - "jsr:@sprk/xrpc-server@~0.1.5", 1003 1003 + "jsr:@sprk/xrpc-server@0.2", 1124 1004 "jsr:@std/encoding@^1.0.10", 1125 1005 "npm:@atproto/api@~0.14.22", 1126 1006 "npm:@atproto/common@~0.4.11", ··· 1132 1012 "npm:@atproto/syntax@~0.3.4", 1133 1013 "npm:@atproto/xrpc@~0.7.1", 1134 1014 "npm:dotenv@^17.2.1", 1135 1135 - "npm:express@^4.21.2", 1136 1015 "npm:jose@^6.0.12", 1137 1137 - "npm:key-encoder@^2.0.3", 1138 1016 "npm:mongoose@^8.17.1", 1139 1017 "npm:multiformats@^9.9.0", 1140 1140 - "npm:p-queue@^8.1.0", 1141 1141 - "npm:pino-pretty@^13.1.1", 1142 1142 - "npm:pino@^8.21.0", 1143 1143 - "npm:ws@^8.18.3" 1018 1018 + "npm:p-queue@^8.1.0" 1144 1019 ] 1145 1020 } 1146 1021 }

+1736 -1513

services/appview/lexicon/index.ts

reviewed

··· 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 import { 5 5 - type AuthVerifier, 5 5 + type Auth, 6 6 createServer as createXrpcServer, 7 7 + type MethodConfigOrHandler, 7 8 type Options as XrpcOptions, 8 9 Server as XrpcServer, 9 9 - type StreamAuthVerifier, 10 10 + type StreamConfigOrHandler, 10 11 } from "@sprk/xrpc-server"; 11 11 - import { type Env } from "hono"; 12 12 import { schemas } from "./lexicons.ts"; 13 13 import * as ToolsOzoneSignatureFindCorrelation from "./types/tools/ozone/signature/findCorrelation.ts"; 14 14 import * as ToolsOzoneSignatureSearchAccounts from "./types/tools/ozone/signature/searchAccounts.ts"; ··· 331 331 DefsReasonAppeal: "com.atproto.moderation.defs#reasonAppeal", 332 332 }; 333 333 334 334 - export function createServer<T extends Env = Env>( 335 335 - options?: XrpcOptions, 336 336 - ): Server<T> { 337 337 - return new Server<T>(options); 334 334 + export function createServer(options?: XrpcOptions): Server { 335 335 + return new Server(options); 338 336 } 339 337 340 340 - export class Server<T extends Env = Env> { 341 341 - xrpc: XrpcServer<T>; 342 342 - tools: ToolsNS<T>; 343 343 - app: AppNS<T>; 344 344 - chat: ChatNS<T>; 345 345 - so: SoNS<T>; 346 346 - com: ComNS<T>; 338 338 + export class Server { 339 339 + xrpc: XrpcServer; 340 340 + tools: ToolsNS; 341 341 + app: AppNS; 342 342 + chat: ChatNS; 343 343 + so: SoNS; 344 344 + com: ComNS; 347 345 348 346 constructor(options?: XrpcOptions) { 349 349 - this.xrpc = createXrpcServer<T>(schemas, options); 347 347 + this.xrpc = createXrpcServer(schemas, options); 350 348 this.tools = new ToolsNS(this); 351 349 this.app = new AppNS(this); 352 350 this.chat = new ChatNS(this); ··· 355 353 } 356 354 } 357 355 358 358 - export class ToolsNS<T extends Env> { 359 359 - _server: Server<T>; 360 360 - ozone: ToolsOzoneNS<T>; 356 356 + export class ToolsNS { 357 357 + _server: Server; 358 358 + ozone: ToolsOzoneNS; 361 359 362 362 - constructor(server: Server<T>) { 360 360 + constructor(server: Server) { 363 361 this._server = server; 364 362 this.ozone = new ToolsOzoneNS(server); 365 363 } 366 364 } 367 365 368 368 - export class ToolsOzoneNS<T extends Env> { 369 369 - _server: Server<T>; 370 370 - signature: ToolsOzoneSignatureNS<T>; 371 371 - server: ToolsOzoneServerNS<T>; 372 372 - team: ToolsOzoneTeamNS<T>; 373 373 - communication: ToolsOzoneCommunicationNS<T>; 374 374 - set: ToolsOzoneSetNS<T>; 375 375 - setting: ToolsOzoneSettingNS<T>; 376 376 - moderation: ToolsOzoneModerationNS<T>; 366 366 + export class ToolsOzoneNS { 367 367 + _server: Server; 368 368 + signature: ToolsOzoneSignatureNS; 369 369 + server: ToolsOzoneServerNS; 370 370 + team: ToolsOzoneTeamNS; 371 371 + communication: ToolsOzoneCommunicationNS; 372 372 + set: ToolsOzoneSetNS; 373 373 + setting: ToolsOzoneSettingNS; 374 374 + moderation: ToolsOzoneModerationNS; 377 375 378 378 - constructor(server: Server<T>) { 376 376 + constructor(server: Server) { 379 377 this._server = server; 380 378 this.signature = new ToolsOzoneSignatureNS(server); 381 379 this.server = new ToolsOzoneServerNS(server); ··· 387 385 } 388 386 } 389 387 390 390 - export class ToolsOzoneSignatureNS<T extends Env> { 391 391 - _server: Server<T>; 388 388 + export class ToolsOzoneSignatureNS { 389 389 + _server: Server; 392 390 393 393 - constructor(server: Server<T>) { 391 391 + constructor(server: Server) { 394 392 this._server = server; 395 393 } 396 394 397 397 - findCorrelation<AV extends AuthVerifier>( 398 398 - cfg: ConfigOf< 399 399 - AV, 400 400 - ToolsOzoneSignatureFindCorrelation.Handler<ExtractAuth<AV>>, 401 401 - ToolsOzoneSignatureFindCorrelation.HandlerReqCtx<ExtractAuth<AV>> 395 395 + findCorrelation<A extends Auth = void>( 396 396 + cfg: MethodConfigOrHandler< 397 397 + A, 398 398 + ToolsOzoneSignatureFindCorrelation.QueryParams, 399 399 + ToolsOzoneSignatureFindCorrelation.HandlerInput, 400 400 + ToolsOzoneSignatureFindCorrelation.HandlerOutput 402 401 >, 403 402 ) { 404 403 const nsid = "tools.ozone.signature.findCorrelation"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 405 404 return this._server.xrpc.method(nsid, cfg); 406 405 } 407 406 408 408 - searchAccounts<AV extends AuthVerifier>( 409 409 - cfg: ConfigOf< 410 410 - AV, 411 411 - ToolsOzoneSignatureSearchAccounts.Handler<ExtractAuth<AV>>, 412 412 - ToolsOzoneSignatureSearchAccounts.HandlerReqCtx<ExtractAuth<AV>> 407 407 + searchAccounts<A extends Auth = void>( 408 408 + cfg: MethodConfigOrHandler< 409 409 + A, 410 410 + ToolsOzoneSignatureSearchAccounts.QueryParams, 411 411 + ToolsOzoneSignatureSearchAccounts.HandlerInput, 412 412 + ToolsOzoneSignatureSearchAccounts.HandlerOutput 413 413 >, 414 414 ) { 415 415 const nsid = "tools.ozone.signature.searchAccounts"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 416 416 return this._server.xrpc.method(nsid, cfg); 417 417 } 418 418 419 419 - findRelatedAccounts<AV extends AuthVerifier>( 420 420 - cfg: ConfigOf< 421 421 - AV, 422 422 - ToolsOzoneSignatureFindRelatedAccounts.Handler<ExtractAuth<AV>>, 423 423 - ToolsOzoneSignatureFindRelatedAccounts.HandlerReqCtx<ExtractAuth<AV>> 419 419 + findRelatedAccounts<A extends Auth = void>( 420 420 + cfg: MethodConfigOrHandler< 421 421 + A, 422 422 + ToolsOzoneSignatureFindRelatedAccounts.QueryParams, 423 423 + ToolsOzoneSignatureFindRelatedAccounts.HandlerInput, 424 424 + ToolsOzoneSignatureFindRelatedAccounts.HandlerOutput 424 425 >, 425 426 ) { 426 427 const nsid = "tools.ozone.signature.findRelatedAccounts"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 428 429 } 429 430 } 430 431 431 431 - export class ToolsOzoneServerNS<T extends Env> { 432 432 - _server: Server<T>; 432 432 + export class ToolsOzoneServerNS { 433 433 + _server: Server; 433 434 434 434 - constructor(server: Server<T>) { 435 435 + constructor(server: Server) { 435 436 this._server = server; 436 437 } 437 438 438 438 - getConfig<AV extends AuthVerifier>( 439 439 - cfg: ConfigOf< 440 440 - AV, 441 441 - ToolsOzoneServerGetConfig.Handler<ExtractAuth<AV>>, 442 442 - ToolsOzoneServerGetConfig.HandlerReqCtx<ExtractAuth<AV>> 439 439 + getConfig<A extends Auth = void>( 440 440 + cfg: MethodConfigOrHandler< 441 441 + A, 442 442 + ToolsOzoneServerGetConfig.QueryParams, 443 443 + ToolsOzoneServerGetConfig.HandlerInput, 444 444 + ToolsOzoneServerGetConfig.HandlerOutput 443 445 >, 444 446 ) { 445 447 const nsid = "tools.ozone.server.getConfig"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 447 449 } 448 450 } 449 451 450 450 - export class ToolsOzoneTeamNS<T extends Env> { 451 451 - _server: Server<T>; 452 452 + export class ToolsOzoneTeamNS { 453 453 + _server: Server; 452 454 453 453 - constructor(server: Server<T>) { 455 455 + constructor(server: Server) { 454 456 this._server = server; 455 457 } 456 458 457 457 - listMembers<AV extends AuthVerifier>( 458 458 - cfg: ConfigOf< 459 459 - AV, 460 460 - ToolsOzoneTeamListMembers.Handler<ExtractAuth<AV>>, 461 461 - ToolsOzoneTeamListMembers.HandlerReqCtx<ExtractAuth<AV>> 459 459 + listMembers<A extends Auth = void>( 460 460 + cfg: MethodConfigOrHandler< 461 461 + A, 462 462 + ToolsOzoneTeamListMembers.QueryParams, 463 463 + ToolsOzoneTeamListMembers.HandlerInput, 464 464 + ToolsOzoneTeamListMembers.HandlerOutput 462 465 >, 463 466 ) { 464 467 const nsid = "tools.ozone.team.listMembers"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 465 468 return this._server.xrpc.method(nsid, cfg); 466 469 } 467 470 468 468 - deleteMember<AV extends AuthVerifier>( 469 469 - cfg: ConfigOf< 470 470 - AV, 471 471 - ToolsOzoneTeamDeleteMember.Handler<ExtractAuth<AV>>, 472 472 - ToolsOzoneTeamDeleteMember.HandlerReqCtx<ExtractAuth<AV>> 471 471 + deleteMember<A extends Auth = void>( 472 472 + cfg: MethodConfigOrHandler< 473 473 + A, 474 474 + ToolsOzoneTeamDeleteMember.QueryParams, 475 475 + ToolsOzoneTeamDeleteMember.HandlerInput, 476 476 + ToolsOzoneTeamDeleteMember.HandlerOutput 473 477 >, 474 478 ) { 475 479 const nsid = "tools.ozone.team.deleteMember"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 476 480 return this._server.xrpc.method(nsid, cfg); 477 481 } 478 482 479 479 - updateMember<AV extends AuthVerifier>( 480 480 - cfg: ConfigOf< 481 481 - AV, 482 482 - ToolsOzoneTeamUpdateMember.Handler<ExtractAuth<AV>>, 483 483 - ToolsOzoneTeamUpdateMember.HandlerReqCtx<ExtractAuth<AV>> 483 483 + updateMember<A extends Auth = void>( 484 484 + cfg: MethodConfigOrHandler< 485 485 + A, 486 486 + ToolsOzoneTeamUpdateMember.QueryParams, 487 487 + ToolsOzoneTeamUpdateMember.HandlerInput, 488 488 + ToolsOzoneTeamUpdateMember.HandlerOutput 484 489 >, 485 490 ) { 486 491 const nsid = "tools.ozone.team.updateMember"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 487 492 return this._server.xrpc.method(nsid, cfg); 488 493 } 489 494 490 490 - addMember<AV extends AuthVerifier>( 491 491 - cfg: ConfigOf< 492 492 - AV, 493 493 - ToolsOzoneTeamAddMember.Handler<ExtractAuth<AV>>, 494 494 - ToolsOzoneTeamAddMember.HandlerReqCtx<ExtractAuth<AV>> 495 495 + addMember<A extends Auth = void>( 496 496 + cfg: MethodConfigOrHandler< 497 497 + A, 498 498 + ToolsOzoneTeamAddMember.QueryParams, 499 499 + ToolsOzoneTeamAddMember.HandlerInput, 500 500 + ToolsOzoneTeamAddMember.HandlerOutput 495 501 >, 496 502 ) { 497 503 const nsid = "tools.ozone.team.addMember"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 499 505 } 500 506 } 501 507 502 502 - export class ToolsOzoneCommunicationNS<T extends Env> { 503 503 - _server: Server<T>; 508 508 + export class ToolsOzoneCommunicationNS { 509 509 + _server: Server; 504 510 505 505 - constructor(server: Server<T>) { 511 511 + constructor(server: Server) { 506 512 this._server = server; 507 513 } 508 514 509 509 - updateTemplate<AV extends AuthVerifier>( 510 510 - cfg: ConfigOf< 511 511 - AV, 512 512 - ToolsOzoneCommunicationUpdateTemplate.Handler<ExtractAuth<AV>>, 513 513 - ToolsOzoneCommunicationUpdateTemplate.HandlerReqCtx<ExtractAuth<AV>> 515 515 + updateTemplate<A extends Auth = void>( 516 516 + cfg: MethodConfigOrHandler< 517 517 + A, 518 518 + ToolsOzoneCommunicationUpdateTemplate.QueryParams, 519 519 + ToolsOzoneCommunicationUpdateTemplate.HandlerInput, 520 520 + ToolsOzoneCommunicationUpdateTemplate.HandlerOutput 514 521 >, 515 522 ) { 516 523 const nsid = "tools.ozone.communication.updateTemplate"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 517 524 return this._server.xrpc.method(nsid, cfg); 518 525 } 519 526 520 520 - createTemplate<AV extends AuthVerifier>( 521 521 - cfg: ConfigOf< 522 522 - AV, 523 523 - ToolsOzoneCommunicationCreateTemplate.Handler<ExtractAuth<AV>>, 524 524 - ToolsOzoneCommunicationCreateTemplate.HandlerReqCtx<ExtractAuth<AV>> 527 527 + createTemplate<A extends Auth = void>( 528 528 + cfg: MethodConfigOrHandler< 529 529 + A, 530 530 + ToolsOzoneCommunicationCreateTemplate.QueryParams, 531 531 + ToolsOzoneCommunicationCreateTemplate.HandlerInput, 532 532 + ToolsOzoneCommunicationCreateTemplate.HandlerOutput 525 533 >, 526 534 ) { 527 535 const nsid = "tools.ozone.communication.createTemplate"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 528 536 return this._server.xrpc.method(nsid, cfg); 529 537 } 530 538 531 531 - listTemplates<AV extends AuthVerifier>( 532 532 - cfg: ConfigOf< 533 533 - AV, 534 534 - ToolsOzoneCommunicationListTemplates.Handler<ExtractAuth<AV>>, 535 535 - ToolsOzoneCommunicationListTemplates.HandlerReqCtx<ExtractAuth<AV>> 539 539 + listTemplates<A extends Auth = void>( 540 540 + cfg: MethodConfigOrHandler< 541 541 + A, 542 542 + ToolsOzoneCommunicationListTemplates.QueryParams, 543 543 + ToolsOzoneCommunicationListTemplates.HandlerInput, 544 544 + ToolsOzoneCommunicationListTemplates.HandlerOutput 536 545 >, 537 546 ) { 538 547 const nsid = "tools.ozone.communication.listTemplates"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 539 548 return this._server.xrpc.method(nsid, cfg); 540 549 } 541 550 542 542 - deleteTemplate<AV extends AuthVerifier>( 543 543 - cfg: ConfigOf< 544 544 - AV, 545 545 - ToolsOzoneCommunicationDeleteTemplate.Handler<ExtractAuth<AV>>, 546 546 - ToolsOzoneCommunicationDeleteTemplate.HandlerReqCtx<ExtractAuth<AV>> 551 551 + deleteTemplate<A extends Auth = void>( 552 552 + cfg: MethodConfigOrHandler< 553 553 + A, 554 554 + ToolsOzoneCommunicationDeleteTemplate.QueryParams, 555 555 + ToolsOzoneCommunicationDeleteTemplate.HandlerInput, 556 556 + ToolsOzoneCommunicationDeleteTemplate.HandlerOutput 547 557 >, 548 558 ) { 549 559 const nsid = "tools.ozone.communication.deleteTemplate"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 551 561 } 552 562 } 553 563 554 554 - export class ToolsOzoneSetNS<T extends Env> { 555 555 - _server: Server<T>; 564 564 + export class ToolsOzoneSetNS { 565 565 + _server: Server; 556 566 557 557 - constructor(server: Server<T>) { 567 567 + constructor(server: Server) { 558 568 this._server = server; 559 569 } 560 570 561 561 - addValues<AV extends AuthVerifier>( 562 562 - cfg: ConfigOf< 563 563 - AV, 564 564 - ToolsOzoneSetAddValues.Handler<ExtractAuth<AV>>, 565 565 - ToolsOzoneSetAddValues.HandlerReqCtx<ExtractAuth<AV>> 571 571 + addValues<A extends Auth = void>( 572 572 + cfg: MethodConfigOrHandler< 573 573 + A, 574 574 + ToolsOzoneSetAddValues.QueryParams, 575 575 + ToolsOzoneSetAddValues.HandlerInput, 576 576 + ToolsOzoneSetAddValues.HandlerOutput 566 577 >, 567 578 ) { 568 579 const nsid = "tools.ozone.set.addValues"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 569 580 return this._server.xrpc.method(nsid, cfg); 570 581 } 571 582 572 572 - getValues<AV extends AuthVerifier>( 573 573 - cfg: ConfigOf< 574 574 - AV, 575 575 - ToolsOzoneSetGetValues.Handler<ExtractAuth<AV>>, 576 576 - ToolsOzoneSetGetValues.HandlerReqCtx<ExtractAuth<AV>> 583 583 + getValues<A extends Auth = void>( 584 584 + cfg: MethodConfigOrHandler< 585 585 + A, 586 586 + ToolsOzoneSetGetValues.QueryParams, 587 587 + ToolsOzoneSetGetValues.HandlerInput, 588 588 + ToolsOzoneSetGetValues.HandlerOutput 577 589 >, 578 590 ) { 579 591 const nsid = "tools.ozone.set.getValues"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 580 592 return this._server.xrpc.method(nsid, cfg); 581 593 } 582 594 583 583 - deleteSet<AV extends AuthVerifier>( 584 584 - cfg: ConfigOf< 585 585 - AV, 586 586 - ToolsOzoneSetDeleteSet.Handler<ExtractAuth<AV>>, 587 587 - ToolsOzoneSetDeleteSet.HandlerReqCtx<ExtractAuth<AV>> 595 595 + deleteSet<A extends Auth = void>( 596 596 + cfg: MethodConfigOrHandler< 597 597 + A, 598 598 + ToolsOzoneSetDeleteSet.QueryParams, 599 599 + ToolsOzoneSetDeleteSet.HandlerInput, 600 600 + ToolsOzoneSetDeleteSet.HandlerOutput 588 601 >, 589 602 ) { 590 603 const nsid = "tools.ozone.set.deleteSet"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 591 604 return this._server.xrpc.method(nsid, cfg); 592 605 } 593 606 594 594 - upsertSet<AV extends AuthVerifier>( 595 595 - cfg: ConfigOf< 596 596 - AV, 597 597 - ToolsOzoneSetUpsertSet.Handler<ExtractAuth<AV>>, 598 598 - ToolsOzoneSetUpsertSet.HandlerReqCtx<ExtractAuth<AV>> 607 607 + upsertSet<A extends Auth = void>( 608 608 + cfg: MethodConfigOrHandler< 609 609 + A, 610 610 + ToolsOzoneSetUpsertSet.QueryParams, 611 611 + ToolsOzoneSetUpsertSet.HandlerInput, 612 612 + ToolsOzoneSetUpsertSet.HandlerOutput 599 613 >, 600 614 ) { 601 615 const nsid = "tools.ozone.set.upsertSet"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 602 616 return this._server.xrpc.method(nsid, cfg); 603 617 } 604 618 605 605 - deleteValues<AV extends AuthVerifier>( 606 606 - cfg: ConfigOf< 607 607 - AV, 608 608 - ToolsOzoneSetDeleteValues.Handler<ExtractAuth<AV>>, 609 609 - ToolsOzoneSetDeleteValues.HandlerReqCtx<ExtractAuth<AV>> 619 619 + deleteValues<A extends Auth = void>( 620 620 + cfg: MethodConfigOrHandler< 621 621 + A, 622 622 + ToolsOzoneSetDeleteValues.QueryParams, 623 623 + ToolsOzoneSetDeleteValues.HandlerInput, 624 624 + ToolsOzoneSetDeleteValues.HandlerOutput 610 625 >, 611 626 ) { 612 627 const nsid = "tools.ozone.set.deleteValues"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 613 628 return this._server.xrpc.method(nsid, cfg); 614 629 } 615 630 616 616 - querySets<AV extends AuthVerifier>( 617 617 - cfg: ConfigOf< 618 618 - AV, 619 619 - ToolsOzoneSetQuerySets.Handler<ExtractAuth<AV>>, 620 620 - ToolsOzoneSetQuerySets.HandlerReqCtx<ExtractAuth<AV>> 631 631 + querySets<A extends Auth = void>( 632 632 + cfg: MethodConfigOrHandler< 633 633 + A, 634 634 + ToolsOzoneSetQuerySets.QueryParams, 635 635 + ToolsOzoneSetQuerySets.HandlerInput, 636 636 + ToolsOzoneSetQuerySets.HandlerOutput 621 637 >, 622 638 ) { 623 639 const nsid = "tools.ozone.set.querySets"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 625 641 } 626 642 } 627 643 628 628 - export class ToolsOzoneSettingNS<T extends Env> { 629 629 - _server: Server<T>; 644 644 + export class ToolsOzoneSettingNS { 645 645 + _server: Server; 630 646 631 631 - constructor(server: Server<T>) { 647 647 + constructor(server: Server) { 632 648 this._server = server; 633 649 } 634 650 635 635 - listOptions<AV extends AuthVerifier>( 636 636 - cfg: ConfigOf< 637 637 - AV, 638 638 - ToolsOzoneSettingListOptions.Handler<ExtractAuth<AV>>, 639 639 - ToolsOzoneSettingListOptions.HandlerReqCtx<ExtractAuth<AV>> 651 651 + listOptions<A extends Auth = void>( 652 652 + cfg: MethodConfigOrHandler< 653 653 + A, 654 654 + ToolsOzoneSettingListOptions.QueryParams, 655 655 + ToolsOzoneSettingListOptions.HandlerInput, 656 656 + ToolsOzoneSettingListOptions.HandlerOutput 640 657 >, 641 658 ) { 642 659 const nsid = "tools.ozone.setting.listOptions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 643 660 return this._server.xrpc.method(nsid, cfg); 644 661 } 645 662 646 646 - removeOptions<AV extends AuthVerifier>( 647 647 - cfg: ConfigOf< 648 648 - AV, 649 649 - ToolsOzoneSettingRemoveOptions.Handler<ExtractAuth<AV>>, 650 650 - ToolsOzoneSettingRemoveOptions.HandlerReqCtx<ExtractAuth<AV>> 663 663 + removeOptions<A extends Auth = void>( 664 664 + cfg: MethodConfigOrHandler< 665 665 + A, 666 666 + ToolsOzoneSettingRemoveOptions.QueryParams, 667 667 + ToolsOzoneSettingRemoveOptions.HandlerInput, 668 668 + ToolsOzoneSettingRemoveOptions.HandlerOutput 651 669 >, 652 670 ) { 653 671 const nsid = "tools.ozone.setting.removeOptions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 654 672 return this._server.xrpc.method(nsid, cfg); 655 673 } 656 674 657 657 - upsertOption<AV extends AuthVerifier>( 658 658 - cfg: ConfigOf< 659 659 - AV, 660 660 - ToolsOzoneSettingUpsertOption.Handler<ExtractAuth<AV>>, 661 661 - ToolsOzoneSettingUpsertOption.HandlerReqCtx<ExtractAuth<AV>> 675 675 + upsertOption<A extends Auth = void>( 676 676 + cfg: MethodConfigOrHandler< 677 677 + A, 678 678 + ToolsOzoneSettingUpsertOption.QueryParams, 679 679 + ToolsOzoneSettingUpsertOption.HandlerInput, 680 680 + ToolsOzoneSettingUpsertOption.HandlerOutput 662 681 >, 663 682 ) { 664 683 const nsid = "tools.ozone.setting.upsertOption"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 666 685 } 667 686 } 668 687 669 669 - export class ToolsOzoneModerationNS<T extends Env> { 670 670 - _server: Server<T>; 688 688 + export class ToolsOzoneModerationNS { 689 689 + _server: Server; 671 690 672 672 - constructor(server: Server<T>) { 691 691 + constructor(server: Server) { 673 692 this._server = server; 674 693 } 675 694 676 676 - getReporterStats<AV extends AuthVerifier>( 677 677 - cfg: ConfigOf< 678 678 - AV, 679 679 - ToolsOzoneModerationGetReporterStats.Handler<ExtractAuth<AV>>, 680 680 - ToolsOzoneModerationGetReporterStats.HandlerReqCtx<ExtractAuth<AV>> 695 695 + getReporterStats<A extends Auth = void>( 696 696 + cfg: MethodConfigOrHandler< 697 697 + A, 698 698 + ToolsOzoneModerationGetReporterStats.QueryParams, 699 699 + ToolsOzoneModerationGetReporterStats.HandlerInput, 700 700 + ToolsOzoneModerationGetReporterStats.HandlerOutput 681 701 >, 682 702 ) { 683 703 const nsid = "tools.ozone.moderation.getReporterStats"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 684 704 return this._server.xrpc.method(nsid, cfg); 685 705 } 686 706 687 687 - queryStatuses<AV extends AuthVerifier>( 688 688 - cfg: ConfigOf< 689 689 - AV, 690 690 - ToolsOzoneModerationQueryStatuses.Handler<ExtractAuth<AV>>, 691 691 - ToolsOzoneModerationQueryStatuses.HandlerReqCtx<ExtractAuth<AV>> 707 707 + queryStatuses<A extends Auth = void>( 708 708 + cfg: MethodConfigOrHandler< 709 709 + A, 710 710 + ToolsOzoneModerationQueryStatuses.QueryParams, 711 711 + ToolsOzoneModerationQueryStatuses.HandlerInput, 712 712 + ToolsOzoneModerationQueryStatuses.HandlerOutput 692 713 >, 693 714 ) { 694 715 const nsid = "tools.ozone.moderation.queryStatuses"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 695 716 return this._server.xrpc.method(nsid, cfg); 696 717 } 697 718 698 698 - getRepo<AV extends AuthVerifier>( 699 699 - cfg: ConfigOf< 700 700 - AV, 701 701 - ToolsOzoneModerationGetRepo.Handler<ExtractAuth<AV>>, 702 702 - ToolsOzoneModerationGetRepo.HandlerReqCtx<ExtractAuth<AV>> 719 719 + getRepo<A extends Auth = void>( 720 720 + cfg: MethodConfigOrHandler< 721 721 + A, 722 722 + ToolsOzoneModerationGetRepo.QueryParams, 723 723 + ToolsOzoneModerationGetRepo.HandlerInput, 724 724 + ToolsOzoneModerationGetRepo.HandlerOutput 703 725 >, 704 726 ) { 705 727 const nsid = "tools.ozone.moderation.getRepo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 706 728 return this._server.xrpc.method(nsid, cfg); 707 729 } 708 730 709 709 - getRecords<AV extends AuthVerifier>( 710 710 - cfg: ConfigOf< 711 711 - AV, 712 712 - ToolsOzoneModerationGetRecords.Handler<ExtractAuth<AV>>, 713 713 - ToolsOzoneModerationGetRecords.HandlerReqCtx<ExtractAuth<AV>> 731 731 + getRecords<A extends Auth = void>( 732 732 + cfg: MethodConfigOrHandler< 733 733 + A, 734 734 + ToolsOzoneModerationGetRecords.QueryParams, 735 735 + ToolsOzoneModerationGetRecords.HandlerInput, 736 736 + ToolsOzoneModerationGetRecords.HandlerOutput 714 737 >, 715 738 ) { 716 739 const nsid = "tools.ozone.moderation.getRecords"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 717 740 return this._server.xrpc.method(nsid, cfg); 718 741 } 719 742 720 720 - getEvent<AV extends AuthVerifier>( 721 721 - cfg: ConfigOf< 722 722 - AV, 723 723 - ToolsOzoneModerationGetEvent.Handler<ExtractAuth<AV>>, 724 724 - ToolsOzoneModerationGetEvent.HandlerReqCtx<ExtractAuth<AV>> 743 743 + getEvent<A extends Auth = void>( 744 744 + cfg: MethodConfigOrHandler< 745 745 + A, 746 746 + ToolsOzoneModerationGetEvent.QueryParams, 747 747 + ToolsOzoneModerationGetEvent.HandlerInput, 748 748 + ToolsOzoneModerationGetEvent.HandlerOutput 725 749 >, 726 750 ) { 727 751 const nsid = "tools.ozone.moderation.getEvent"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 728 752 return this._server.xrpc.method(nsid, cfg); 729 753 } 730 754 731 731 - queryEvents<AV extends AuthVerifier>( 732 732 - cfg: ConfigOf< 733 733 - AV, 734 734 - ToolsOzoneModerationQueryEvents.Handler<ExtractAuth<AV>>, 735 735 - ToolsOzoneModerationQueryEvents.HandlerReqCtx<ExtractAuth<AV>> 755 755 + queryEvents<A extends Auth = void>( 756 756 + cfg: MethodConfigOrHandler< 757 757 + A, 758 758 + ToolsOzoneModerationQueryEvents.QueryParams, 759 759 + ToolsOzoneModerationQueryEvents.HandlerInput, 760 760 + ToolsOzoneModerationQueryEvents.HandlerOutput 736 761 >, 737 762 ) { 738 763 const nsid = "tools.ozone.moderation.queryEvents"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 739 764 return this._server.xrpc.method(nsid, cfg); 740 765 } 741 766 742 742 - getRecord<AV extends AuthVerifier>( 743 743 - cfg: ConfigOf< 744 744 - AV, 745 745 - ToolsOzoneModerationGetRecord.Handler<ExtractAuth<AV>>, 746 746 - ToolsOzoneModerationGetRecord.HandlerReqCtx<ExtractAuth<AV>> 767 767 + getRecord<A extends Auth = void>( 768 768 + cfg: MethodConfigOrHandler< 769 769 + A, 770 770 + ToolsOzoneModerationGetRecord.QueryParams, 771 771 + ToolsOzoneModerationGetRecord.HandlerInput, 772 772 + ToolsOzoneModerationGetRecord.HandlerOutput 747 773 >, 748 774 ) { 749 775 const nsid = "tools.ozone.moderation.getRecord"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 750 776 return this._server.xrpc.method(nsid, cfg); 751 777 } 752 778 753 753 - emitEvent<AV extends AuthVerifier>( 754 754 - cfg: ConfigOf< 755 755 - AV, 756 756 - ToolsOzoneModerationEmitEvent.Handler<ExtractAuth<AV>>, 757 757 - ToolsOzoneModerationEmitEvent.HandlerReqCtx<ExtractAuth<AV>> 779 779 + emitEvent<A extends Auth = void>( 780 780 + cfg: MethodConfigOrHandler< 781 781 + A, 782 782 + ToolsOzoneModerationEmitEvent.QueryParams, 783 783 + ToolsOzoneModerationEmitEvent.HandlerInput, 784 784 + ToolsOzoneModerationEmitEvent.HandlerOutput 758 785 >, 759 786 ) { 760 787 const nsid = "tools.ozone.moderation.emitEvent"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 761 788 return this._server.xrpc.method(nsid, cfg); 762 789 } 763 790 764 764 - searchRepos<AV extends AuthVerifier>( 765 765 - cfg: ConfigOf< 766 766 - AV, 767 767 - ToolsOzoneModerationSearchRepos.Handler<ExtractAuth<AV>>, 768 768 - ToolsOzoneModerationSearchRepos.HandlerReqCtx<ExtractAuth<AV>> 791 791 + searchRepos<A extends Auth = void>( 792 792 + cfg: MethodConfigOrHandler< 793 793 + A, 794 794 + ToolsOzoneModerationSearchRepos.QueryParams, 795 795 + ToolsOzoneModerationSearchRepos.HandlerInput, 796 796 + ToolsOzoneModerationSearchRepos.HandlerOutput 769 797 >, 770 798 ) { 771 799 const nsid = "tools.ozone.moderation.searchRepos"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 772 800 return this._server.xrpc.method(nsid, cfg); 773 801 } 774 802 775 775 - getRepos<AV extends AuthVerifier>( 776 776 - cfg: ConfigOf< 777 777 - AV, 778 778 - ToolsOzoneModerationGetRepos.Handler<ExtractAuth<AV>>, 779 779 - ToolsOzoneModerationGetRepos.HandlerReqCtx<ExtractAuth<AV>> 803 803 + getRepos<A extends Auth = void>( 804 804 + cfg: MethodConfigOrHandler< 805 805 + A, 806 806 + ToolsOzoneModerationGetRepos.QueryParams, 807 807 + ToolsOzoneModerationGetRepos.HandlerInput, 808 808 + ToolsOzoneModerationGetRepos.HandlerOutput 780 809 >, 781 810 ) { 782 811 const nsid = "tools.ozone.moderation.getRepos"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 784 813 } 785 814 } 786 815 787 787 - export class AppNS<T extends Env> { 788 788 - _server: Server<T>; 789 789 - bsky: AppBskyNS<T>; 816 816 + export class AppNS { 817 817 + _server: Server; 818 818 + bsky: AppBskyNS; 790 819 791 791 - constructor(server: Server<T>) { 820 820 + constructor(server: Server) { 792 821 this._server = server; 793 822 this.bsky = new AppBskyNS(server); 794 823 } 795 824 } 796 825 797 797 - export class AppBskyNS<T extends Env> { 798 798 - _server: Server<T>; 799 799 - video: AppBskyVideoNS<T>; 800 800 - embed: AppBskyEmbedNS<T>; 801 801 - notification: AppBskyNotificationNS<T>; 802 802 - unspecced: AppBskyUnspeccedNS<T>; 803 803 - graph: AppBskyGraphNS<T>; 804 804 - feed: AppBskyFeedNS<T>; 805 805 - richtext: AppBskyRichtextNS<T>; 806 806 - actor: AppBskyActorNS<T>; 807 807 - labeler: AppBskyLabelerNS<T>; 826 826 + export class AppBskyNS { 827 827 + _server: Server; 828 828 + video: AppBskyVideoNS; 829 829 + embed: AppBskyEmbedNS; 830 830 + notification: AppBskyNotificationNS; 831 831 + unspecced: AppBskyUnspeccedNS; 832 832 + graph: AppBskyGraphNS; 833 833 + feed: AppBskyFeedNS; 834 834 + richtext: AppBskyRichtextNS; 835 835 + actor: AppBskyActorNS; 836 836 + labeler: AppBskyLabelerNS; 808 837 809 809 - constructor(server: Server<T>) { 838 838 + constructor(server: Server) { 810 839 this._server = server; 811 840 this.video = new AppBskyVideoNS(server); 812 841 this.embed = new AppBskyEmbedNS(server); ··· 820 849 } 821 850 } 822 851 823 823 - export class AppBskyVideoNS<T extends Env> { 824 824 - _server: Server<T>; 852 852 + export class AppBskyVideoNS { 853 853 + _server: Server; 825 854 826 826 - constructor(server: Server<T>) { 855 855 + constructor(server: Server) { 827 856 this._server = server; 828 857 } 829 858 830 830 - uploadVideo<AV extends AuthVerifier>( 831 831 - cfg: ConfigOf< 832 832 - AV, 833 833 - AppBskyVideoUploadVideo.Handler<ExtractAuth<AV>>, 834 834 - AppBskyVideoUploadVideo.HandlerReqCtx<ExtractAuth<AV>> 859 859 + uploadVideo<A extends Auth = void>( 860 860 + cfg: MethodConfigOrHandler< 861 861 + A, 862 862 + AppBskyVideoUploadVideo.QueryParams, 863 863 + AppBskyVideoUploadVideo.HandlerInput, 864 864 + AppBskyVideoUploadVideo.HandlerOutput 835 865 >, 836 866 ) { 837 867 const nsid = "app.bsky.video.uploadVideo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 838 868 return this._server.xrpc.method(nsid, cfg); 839 869 } 840 870 841 841 - getJobStatus<AV extends AuthVerifier>( 842 842 - cfg: ConfigOf< 843 843 - AV, 844 844 - AppBskyVideoGetJobStatus.Handler<ExtractAuth<AV>>, 845 845 - AppBskyVideoGetJobStatus.HandlerReqCtx<ExtractAuth<AV>> 871 871 + getJobStatus<A extends Auth = void>( 872 872 + cfg: MethodConfigOrHandler< 873 873 + A, 874 874 + AppBskyVideoGetJobStatus.QueryParams, 875 875 + AppBskyVideoGetJobStatus.HandlerInput, 876 876 + AppBskyVideoGetJobStatus.HandlerOutput 846 877 >, 847 878 ) { 848 879 const nsid = "app.bsky.video.getJobStatus"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 849 880 return this._server.xrpc.method(nsid, cfg); 850 881 } 851 882 852 852 - getUploadLimits<AV extends AuthVerifier>( 853 853 - cfg: ConfigOf< 854 854 - AV, 855 855 - AppBskyVideoGetUploadLimits.Handler<ExtractAuth<AV>>, 856 856 - AppBskyVideoGetUploadLimits.HandlerReqCtx<ExtractAuth<AV>> 883 883 + getUploadLimits<A extends Auth = void>( 884 884 + cfg: MethodConfigOrHandler< 885 885 + A, 886 886 + AppBskyVideoGetUploadLimits.QueryParams, 887 887 + AppBskyVideoGetUploadLimits.HandlerInput, 888 888 + AppBskyVideoGetUploadLimits.HandlerOutput 857 889 >, 858 890 ) { 859 891 const nsid = "app.bsky.video.getUploadLimits"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 861 893 } 862 894 } 863 895 864 864 - export class AppBskyEmbedNS<T extends Env> { 865 865 - _server: Server<T>; 896 896 + export class AppBskyEmbedNS { 897 897 + _server: Server; 866 898 867 867 - constructor(server: Server<T>) { 899 899 + constructor(server: Server) { 868 900 this._server = server; 869 901 } 870 902 } 871 903 872 872 - export class AppBskyNotificationNS<T extends Env> { 873 873 - _server: Server<T>; 904 904 + export class AppBskyNotificationNS { 905 905 + _server: Server; 874 906 875 875 - constructor(server: Server<T>) { 907 907 + constructor(server: Server) { 876 908 this._server = server; 877 909 } 878 910 879 879 - registerPush<AV extends AuthVerifier>( 880 880 - cfg: ConfigOf< 881 881 - AV, 882 882 - AppBskyNotificationRegisterPush.Handler<ExtractAuth<AV>>, 883 883 - AppBskyNotificationRegisterPush.HandlerReqCtx<ExtractAuth<AV>> 911 911 + registerPush<A extends Auth = void>( 912 912 + cfg: MethodConfigOrHandler< 913 913 + A, 914 914 + AppBskyNotificationRegisterPush.QueryParams, 915 915 + AppBskyNotificationRegisterPush.HandlerInput, 916 916 + AppBskyNotificationRegisterPush.HandlerOutput 884 917 >, 885 918 ) { 886 919 const nsid = "app.bsky.notification.registerPush"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 887 920 return this._server.xrpc.method(nsid, cfg); 888 921 } 889 922 890 890 - putPreferences<AV extends AuthVerifier>( 891 891 - cfg: ConfigOf< 892 892 - AV, 893 893 - AppBskyNotificationPutPreferences.Handler<ExtractAuth<AV>>, 894 894 - AppBskyNotificationPutPreferences.HandlerReqCtx<ExtractAuth<AV>> 923 923 + putPreferences<A extends Auth = void>( 924 924 + cfg: MethodConfigOrHandler< 925 925 + A, 926 926 + AppBskyNotificationPutPreferences.QueryParams, 927 927 + AppBskyNotificationPutPreferences.HandlerInput, 928 928 + AppBskyNotificationPutPreferences.HandlerOutput 895 929 >, 896 930 ) { 897 931 const nsid = "app.bsky.notification.putPreferences"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 898 932 return this._server.xrpc.method(nsid, cfg); 899 933 } 900 934 901 901 - updateSeen<AV extends AuthVerifier>( 902 902 - cfg: ConfigOf< 903 903 - AV, 904 904 - AppBskyNotificationUpdateSeen.Handler<ExtractAuth<AV>>, 905 905 - AppBskyNotificationUpdateSeen.HandlerReqCtx<ExtractAuth<AV>> 935 935 + updateSeen<A extends Auth = void>( 936 936 + cfg: MethodConfigOrHandler< 937 937 + A, 938 938 + AppBskyNotificationUpdateSeen.QueryParams, 939 939 + AppBskyNotificationUpdateSeen.HandlerInput, 940 940 + AppBskyNotificationUpdateSeen.HandlerOutput 906 941 >, 907 942 ) { 908 943 const nsid = "app.bsky.notification.updateSeen"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 909 944 return this._server.xrpc.method(nsid, cfg); 910 945 } 911 946 912 912 - listNotifications<AV extends AuthVerifier>( 913 913 - cfg: ConfigOf< 914 914 - AV, 915 915 - AppBskyNotificationListNotifications.Handler<ExtractAuth<AV>>, 916 916 - AppBskyNotificationListNotifications.HandlerReqCtx<ExtractAuth<AV>> 947 947 + listNotifications<A extends Auth = void>( 948 948 + cfg: MethodConfigOrHandler< 949 949 + A, 950 950 + AppBskyNotificationListNotifications.QueryParams, 951 951 + AppBskyNotificationListNotifications.HandlerInput, 952 952 + AppBskyNotificationListNotifications.HandlerOutput 917 953 >, 918 954 ) { 919 955 const nsid = "app.bsky.notification.listNotifications"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 920 956 return this._server.xrpc.method(nsid, cfg); 921 957 } 922 958 923 923 - getUnreadCount<AV extends AuthVerifier>( 924 924 - cfg: ConfigOf< 925 925 - AV, 926 926 - AppBskyNotificationGetUnreadCount.Handler<ExtractAuth<AV>>, 927 927 - AppBskyNotificationGetUnreadCount.HandlerReqCtx<ExtractAuth<AV>> 959 959 + getUnreadCount<A extends Auth = void>( 960 960 + cfg: MethodConfigOrHandler< 961 961 + A, 962 962 + AppBskyNotificationGetUnreadCount.QueryParams, 963 963 + AppBskyNotificationGetUnreadCount.HandlerInput, 964 964 + AppBskyNotificationGetUnreadCount.HandlerOutput 928 965 >, 929 966 ) { 930 967 const nsid = "app.bsky.notification.getUnreadCount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 932 969 } 933 970 } 934 971 935 935 - export class AppBskyUnspeccedNS<T extends Env> { 936 936 - _server: Server<T>; 972 972 + export class AppBskyUnspeccedNS { 973 973 + _server: Server; 937 974 938 938 - constructor(server: Server<T>) { 975 975 + constructor(server: Server) { 939 976 this._server = server; 940 977 } 941 978 942 942 - searchStarterPacksSkeleton<AV extends AuthVerifier>( 943 943 - cfg: ConfigOf< 944 944 - AV, 945 945 - AppBskyUnspeccedSearchStarterPacksSkeleton.Handler<ExtractAuth<AV>>, 946 946 - AppBskyUnspeccedSearchStarterPacksSkeleton.HandlerReqCtx<ExtractAuth<AV>> 979 979 + searchStarterPacksSkeleton<A extends Auth = void>( 980 980 + cfg: MethodConfigOrHandler< 981 981 + A, 982 982 + AppBskyUnspeccedSearchStarterPacksSkeleton.QueryParams, 983 983 + AppBskyUnspeccedSearchStarterPacksSkeleton.HandlerInput, 984 984 + AppBskyUnspeccedSearchStarterPacksSkeleton.HandlerOutput 947 985 >, 948 986 ) { 949 987 const nsid = "app.bsky.unspecced.searchStarterPacksSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 950 988 return this._server.xrpc.method(nsid, cfg); 951 989 } 952 990 953 953 - searchActorsSkeleton<AV extends AuthVerifier>( 954 954 - cfg: ConfigOf< 955 955 - AV, 956 956 - AppBskyUnspeccedSearchActorsSkeleton.Handler<ExtractAuth<AV>>, 957 957 - AppBskyUnspeccedSearchActorsSkeleton.HandlerReqCtx<ExtractAuth<AV>> 991 991 + searchActorsSkeleton<A extends Auth = void>( 992 992 + cfg: MethodConfigOrHandler< 993 993 + A, 994 994 + AppBskyUnspeccedSearchActorsSkeleton.QueryParams, 995 995 + AppBskyUnspeccedSearchActorsSkeleton.HandlerInput, 996 996 + AppBskyUnspeccedSearchActorsSkeleton.HandlerOutput 958 997 >, 959 998 ) { 960 999 const nsid = "app.bsky.unspecced.searchActorsSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 961 1000 return this._server.xrpc.method(nsid, cfg); 962 1001 } 963 1002 964 964 - getSuggestionsSkeleton<AV extends AuthVerifier>( 965 965 - cfg: ConfigOf< 966 966 - AV, 967 967 - AppBskyUnspeccedGetSuggestionsSkeleton.Handler<ExtractAuth<AV>>, 968 968 - AppBskyUnspeccedGetSuggestionsSkeleton.HandlerReqCtx<ExtractAuth<AV>> 1003 1003 + getSuggestionsSkeleton<A extends Auth = void>( 1004 1004 + cfg: MethodConfigOrHandler< 1005 1005 + A, 1006 1006 + AppBskyUnspeccedGetSuggestionsSkeleton.QueryParams, 1007 1007 + AppBskyUnspeccedGetSuggestionsSkeleton.HandlerInput, 1008 1008 + AppBskyUnspeccedGetSuggestionsSkeleton.HandlerOutput 969 1009 >, 970 1010 ) { 971 1011 const nsid = "app.bsky.unspecced.getSuggestionsSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 972 1012 return this._server.xrpc.method(nsid, cfg); 973 1013 } 974 1014 975 975 - searchPostsSkeleton<AV extends AuthVerifier>( 976 976 - cfg: ConfigOf< 977 977 - AV, 978 978 - AppBskyUnspeccedSearchPostsSkeleton.Handler<ExtractAuth<AV>>, 979 979 - AppBskyUnspeccedSearchPostsSkeleton.HandlerReqCtx<ExtractAuth<AV>> 1015 1015 + searchPostsSkeleton<A extends Auth = void>( 1016 1016 + cfg: MethodConfigOrHandler< 1017 1017 + A, 1018 1018 + AppBskyUnspeccedSearchPostsSkeleton.QueryParams, 1019 1019 + AppBskyUnspeccedSearchPostsSkeleton.HandlerInput, 1020 1020 + AppBskyUnspeccedSearchPostsSkeleton.HandlerOutput 980 1021 >, 981 1022 ) { 982 1023 const nsid = "app.bsky.unspecced.searchPostsSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 983 1024 return this._server.xrpc.method(nsid, cfg); 984 1025 } 985 1026 986 986 - getPopularFeedGenerators<AV extends AuthVerifier>( 987 987 - cfg: ConfigOf< 988 988 - AV, 989 989 - AppBskyUnspeccedGetPopularFeedGenerators.Handler<ExtractAuth<AV>>, 990 990 - AppBskyUnspeccedGetPopularFeedGenerators.HandlerReqCtx<ExtractAuth<AV>> 1027 1027 + getPopularFeedGenerators<A extends Auth = void>( 1028 1028 + cfg: MethodConfigOrHandler< 1029 1029 + A, 1030 1030 + AppBskyUnspeccedGetPopularFeedGenerators.QueryParams, 1031 1031 + AppBskyUnspeccedGetPopularFeedGenerators.HandlerInput, 1032 1032 + AppBskyUnspeccedGetPopularFeedGenerators.HandlerOutput 991 1033 >, 992 1034 ) { 993 1035 const nsid = "app.bsky.unspecced.getPopularFeedGenerators"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 994 1036 return this._server.xrpc.method(nsid, cfg); 995 1037 } 996 1038 997 997 - getTrendingTopics<AV extends AuthVerifier>( 998 998 - cfg: ConfigOf< 999 999 - AV, 1000 1000 - AppBskyUnspeccedGetTrendingTopics.Handler<ExtractAuth<AV>>, 1001 1001 - AppBskyUnspeccedGetTrendingTopics.HandlerReqCtx<ExtractAuth<AV>> 1039 1039 + getTrendingTopics<A extends Auth = void>( 1040 1040 + cfg: MethodConfigOrHandler< 1041 1041 + A, 1042 1042 + AppBskyUnspeccedGetTrendingTopics.QueryParams, 1043 1043 + AppBskyUnspeccedGetTrendingTopics.HandlerInput, 1044 1044 + AppBskyUnspeccedGetTrendingTopics.HandlerOutput 1002 1045 >, 1003 1046 ) { 1004 1047 const nsid = "app.bsky.unspecced.getTrendingTopics"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1005 1048 return this._server.xrpc.method(nsid, cfg); 1006 1049 } 1007 1050 1008 1008 - getTaggedSuggestions<AV extends AuthVerifier>( 1009 1009 - cfg: ConfigOf< 1010 1010 - AV, 1011 1011 - AppBskyUnspeccedGetTaggedSuggestions.Handler<ExtractAuth<AV>>, 1012 1012 - AppBskyUnspeccedGetTaggedSuggestions.HandlerReqCtx<ExtractAuth<AV>> 1051 1051 + getTaggedSuggestions<A extends Auth = void>( 1052 1052 + cfg: MethodConfigOrHandler< 1053 1053 + A, 1054 1054 + AppBskyUnspeccedGetTaggedSuggestions.QueryParams, 1055 1055 + AppBskyUnspeccedGetTaggedSuggestions.HandlerInput, 1056 1056 + AppBskyUnspeccedGetTaggedSuggestions.HandlerOutput 1013 1057 >, 1014 1058 ) { 1015 1059 const nsid = "app.bsky.unspecced.getTaggedSuggestions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1016 1060 return this._server.xrpc.method(nsid, cfg); 1017 1061 } 1018 1062 1019 1019 - getConfig<AV extends AuthVerifier>( 1020 1020 - cfg: ConfigOf< 1021 1021 - AV, 1022 1022 - AppBskyUnspeccedGetConfig.Handler<ExtractAuth<AV>>, 1023 1023 - AppBskyUnspeccedGetConfig.HandlerReqCtx<ExtractAuth<AV>> 1063 1063 + getConfig<A extends Auth = void>( 1064 1064 + cfg: MethodConfigOrHandler< 1065 1065 + A, 1066 1066 + AppBskyUnspeccedGetConfig.QueryParams, 1067 1067 + AppBskyUnspeccedGetConfig.HandlerInput, 1068 1068 + AppBskyUnspeccedGetConfig.HandlerOutput 1024 1069 >, 1025 1070 ) { 1026 1071 const nsid = "app.bsky.unspecced.getConfig"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1028 1073 } 1029 1074 } 1030 1075 1031 1031 - export class AppBskyGraphNS<T extends Env> { 1032 1032 - _server: Server<T>; 1076 1076 + export class AppBskyGraphNS { 1077 1077 + _server: Server; 1033 1078 1034 1034 - constructor(server: Server<T>) { 1079 1079 + constructor(server: Server) { 1035 1080 this._server = server; 1036 1081 } 1037 1082 1038 1038 - getStarterPacks<AV extends AuthVerifier>( 1039 1039 - cfg: ConfigOf< 1040 1040 - AV, 1041 1041 - AppBskyGraphGetStarterPacks.Handler<ExtractAuth<AV>>, 1042 1042 - AppBskyGraphGetStarterPacks.HandlerReqCtx<ExtractAuth<AV>> 1083 1083 + getStarterPacks<A extends Auth = void>( 1084 1084 + cfg: MethodConfigOrHandler< 1085 1085 + A, 1086 1086 + AppBskyGraphGetStarterPacks.QueryParams, 1087 1087 + AppBskyGraphGetStarterPacks.HandlerInput, 1088 1088 + AppBskyGraphGetStarterPacks.HandlerOutput 1043 1089 >, 1044 1090 ) { 1045 1091 const nsid = "app.bsky.graph.getStarterPacks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1046 1092 return this._server.xrpc.method(nsid, cfg); 1047 1093 } 1048 1094 1049 1049 - getSuggestedFollowsByActor<AV extends AuthVerifier>( 1050 1050 - cfg: ConfigOf< 1051 1051 - AV, 1052 1052 - AppBskyGraphGetSuggestedFollowsByActor.Handler<ExtractAuth<AV>>, 1053 1053 - AppBskyGraphGetSuggestedFollowsByActor.HandlerReqCtx<ExtractAuth<AV>> 1095 1095 + getSuggestedFollowsByActor<A extends Auth = void>( 1096 1096 + cfg: MethodConfigOrHandler< 1097 1097 + A, 1098 1098 + AppBskyGraphGetSuggestedFollowsByActor.QueryParams, 1099 1099 + AppBskyGraphGetSuggestedFollowsByActor.HandlerInput, 1100 1100 + AppBskyGraphGetSuggestedFollowsByActor.HandlerOutput 1054 1101 >, 1055 1102 ) { 1056 1103 const nsid = "app.bsky.graph.getSuggestedFollowsByActor"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1057 1104 return this._server.xrpc.method(nsid, cfg); 1058 1105 } 1059 1106 1060 1060 - unmuteActorList<AV extends AuthVerifier>( 1061 1061 - cfg: ConfigOf< 1062 1062 - AV, 1063 1063 - AppBskyGraphUnmuteActorList.Handler<ExtractAuth<AV>>, 1064 1064 - AppBskyGraphUnmuteActorList.HandlerReqCtx<ExtractAuth<AV>> 1107 1107 + unmuteActorList<A extends Auth = void>( 1108 1108 + cfg: MethodConfigOrHandler< 1109 1109 + A, 1110 1110 + AppBskyGraphUnmuteActorList.QueryParams, 1111 1111 + AppBskyGraphUnmuteActorList.HandlerInput, 1112 1112 + AppBskyGraphUnmuteActorList.HandlerOutput 1065 1113 >, 1066 1114 ) { 1067 1115 const nsid = "app.bsky.graph.unmuteActorList"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1068 1116 return this._server.xrpc.method(nsid, cfg); 1069 1117 } 1070 1118 1071 1071 - getListBlocks<AV extends AuthVerifier>( 1072 1072 - cfg: ConfigOf< 1073 1073 - AV, 1074 1074 - AppBskyGraphGetListBlocks.Handler<ExtractAuth<AV>>, 1075 1075 - AppBskyGraphGetListBlocks.HandlerReqCtx<ExtractAuth<AV>> 1119 1119 + getListBlocks<A extends Auth = void>( 1120 1120 + cfg: MethodConfigOrHandler< 1121 1121 + A, 1122 1122 + AppBskyGraphGetListBlocks.QueryParams, 1123 1123 + AppBskyGraphGetListBlocks.HandlerInput, 1124 1124 + AppBskyGraphGetListBlocks.HandlerOutput 1076 1125 >, 1077 1126 ) { 1078 1127 const nsid = "app.bsky.graph.getListBlocks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1079 1128 return this._server.xrpc.method(nsid, cfg); 1080 1129 } 1081 1130 1082 1082 - getStarterPack<AV extends AuthVerifier>( 1083 1083 - cfg: ConfigOf< 1084 1084 - AV, 1085 1085 - AppBskyGraphGetStarterPack.Handler<ExtractAuth<AV>>, 1086 1086 - AppBskyGraphGetStarterPack.HandlerReqCtx<ExtractAuth<AV>> 1131 1131 + getStarterPack<A extends Auth = void>( 1132 1132 + cfg: MethodConfigOrHandler< 1133 1133 + A, 1134 1134 + AppBskyGraphGetStarterPack.QueryParams, 1135 1135 + AppBskyGraphGetStarterPack.HandlerInput, 1136 1136 + AppBskyGraphGetStarterPack.HandlerOutput 1087 1137 >, 1088 1138 ) { 1089 1139 const nsid = "app.bsky.graph.getStarterPack"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1090 1140 return this._server.xrpc.method(nsid, cfg); 1091 1141 } 1092 1142 1093 1093 - muteActorList<AV extends AuthVerifier>( 1094 1094 - cfg: ConfigOf< 1095 1095 - AV, 1096 1096 - AppBskyGraphMuteActorList.Handler<ExtractAuth<AV>>, 1097 1097 - AppBskyGraphMuteActorList.HandlerReqCtx<ExtractAuth<AV>> 1143 1143 + muteActorList<A extends Auth = void>( 1144 1144 + cfg: MethodConfigOrHandler< 1145 1145 + A, 1146 1146 + AppBskyGraphMuteActorList.QueryParams, 1147 1147 + AppBskyGraphMuteActorList.HandlerInput, 1148 1148 + AppBskyGraphMuteActorList.HandlerOutput 1098 1149 >, 1099 1150 ) { 1100 1151 const nsid = "app.bsky.graph.muteActorList"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1101 1152 return this._server.xrpc.method(nsid, cfg); 1102 1153 } 1103 1154 1104 1104 - muteThread<AV extends AuthVerifier>( 1105 1105 - cfg: ConfigOf< 1106 1106 - AV, 1107 1107 - AppBskyGraphMuteThread.Handler<ExtractAuth<AV>>, 1108 1108 - AppBskyGraphMuteThread.HandlerReqCtx<ExtractAuth<AV>> 1155 1155 + muteThread<A extends Auth = void>( 1156 1156 + cfg: MethodConfigOrHandler< 1157 1157 + A, 1158 1158 + AppBskyGraphMuteThread.QueryParams, 1159 1159 + AppBskyGraphMuteThread.HandlerInput, 1160 1160 + AppBskyGraphMuteThread.HandlerOutput 1109 1161 >, 1110 1162 ) { 1111 1163 const nsid = "app.bsky.graph.muteThread"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1112 1164 return this._server.xrpc.method(nsid, cfg); 1113 1165 } 1114 1166 1115 1115 - searchStarterPacks<AV extends AuthVerifier>( 1116 1116 - cfg: ConfigOf< 1117 1117 - AV, 1118 1118 - AppBskyGraphSearchStarterPacks.Handler<ExtractAuth<AV>>, 1119 1119 - AppBskyGraphSearchStarterPacks.HandlerReqCtx<ExtractAuth<AV>> 1167 1167 + searchStarterPacks<A extends Auth = void>( 1168 1168 + cfg: MethodConfigOrHandler< 1169 1169 + A, 1170 1170 + AppBskyGraphSearchStarterPacks.QueryParams, 1171 1171 + AppBskyGraphSearchStarterPacks.HandlerInput, 1172 1172 + AppBskyGraphSearchStarterPacks.HandlerOutput 1120 1173 >, 1121 1174 ) { 1122 1175 const nsid = "app.bsky.graph.searchStarterPacks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1123 1176 return this._server.xrpc.method(nsid, cfg); 1124 1177 } 1125 1178 1126 1126 - getActorStarterPacks<AV extends AuthVerifier>( 1127 1127 - cfg: ConfigOf< 1128 1128 - AV, 1129 1129 - AppBskyGraphGetActorStarterPacks.Handler<ExtractAuth<AV>>, 1130 1130 - AppBskyGraphGetActorStarterPacks.HandlerReqCtx<ExtractAuth<AV>> 1179 1179 + getActorStarterPacks<A extends Auth = void>( 1180 1180 + cfg: MethodConfigOrHandler< 1181 1181 + A, 1182 1182 + AppBskyGraphGetActorStarterPacks.QueryParams, 1183 1183 + AppBskyGraphGetActorStarterPacks.HandlerInput, 1184 1184 + AppBskyGraphGetActorStarterPacks.HandlerOutput 1131 1185 >, 1132 1186 ) { 1133 1187 const nsid = "app.bsky.graph.getActorStarterPacks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1134 1188 return this._server.xrpc.method(nsid, cfg); 1135 1189 } 1136 1190 1137 1137 - getLists<AV extends AuthVerifier>( 1138 1138 - cfg: ConfigOf< 1139 1139 - AV, 1140 1140 - AppBskyGraphGetLists.Handler<ExtractAuth<AV>>, 1141 1141 - AppBskyGraphGetLists.HandlerReqCtx<ExtractAuth<AV>> 1191 1191 + getLists<A extends Auth = void>( 1192 1192 + cfg: MethodConfigOrHandler< 1193 1193 + A, 1194 1194 + AppBskyGraphGetLists.QueryParams, 1195 1195 + AppBskyGraphGetLists.HandlerInput, 1196 1196 + AppBskyGraphGetLists.HandlerOutput 1142 1197 >, 1143 1198 ) { 1144 1199 const nsid = "app.bsky.graph.getLists"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1145 1200 return this._server.xrpc.method(nsid, cfg); 1146 1201 } 1147 1202 1148 1148 - getFollowers<AV extends AuthVerifier>( 1149 1149 - cfg: ConfigOf< 1150 1150 - AV, 1151 1151 - AppBskyGraphGetFollowers.Handler<ExtractAuth<AV>>, 1152 1152 - AppBskyGraphGetFollowers.HandlerReqCtx<ExtractAuth<AV>> 1203 1203 + getFollowers<A extends Auth = void>( 1204 1204 + cfg: MethodConfigOrHandler< 1205 1205 + A, 1206 1206 + AppBskyGraphGetFollowers.QueryParams, 1207 1207 + AppBskyGraphGetFollowers.HandlerInput, 1208 1208 + AppBskyGraphGetFollowers.HandlerOutput 1153 1209 >, 1154 1210 ) { 1155 1211 const nsid = "app.bsky.graph.getFollowers"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1156 1212 return this._server.xrpc.method(nsid, cfg); 1157 1213 } 1158 1214 1159 1159 - unmuteThread<AV extends AuthVerifier>( 1160 1160 - cfg: ConfigOf< 1161 1161 - AV, 1162 1162 - AppBskyGraphUnmuteThread.Handler<ExtractAuth<AV>>, 1163 1163 - AppBskyGraphUnmuteThread.HandlerReqCtx<ExtractAuth<AV>> 1215 1215 + unmuteThread<A extends Auth = void>( 1216 1216 + cfg: MethodConfigOrHandler< 1217 1217 + A, 1218 1218 + AppBskyGraphUnmuteThread.QueryParams, 1219 1219 + AppBskyGraphUnmuteThread.HandlerInput, 1220 1220 + AppBskyGraphUnmuteThread.HandlerOutput 1164 1221 >, 1165 1222 ) { 1166 1223 const nsid = "app.bsky.graph.unmuteThread"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1167 1224 return this._server.xrpc.method(nsid, cfg); 1168 1225 } 1169 1226 1170 1170 - muteActor<AV extends AuthVerifier>( 1171 1171 - cfg: ConfigOf< 1172 1172 - AV, 1173 1173 - AppBskyGraphMuteActor.Handler<ExtractAuth<AV>>, 1174 1174 - AppBskyGraphMuteActor.HandlerReqCtx<ExtractAuth<AV>> 1227 1227 + muteActor<A extends Auth = void>( 1228 1228 + cfg: MethodConfigOrHandler< 1229 1229 + A, 1230 1230 + AppBskyGraphMuteActor.QueryParams, 1231 1231 + AppBskyGraphMuteActor.HandlerInput, 1232 1232 + AppBskyGraphMuteActor.HandlerOutput 1175 1233 >, 1176 1234 ) { 1177 1235 const nsid = "app.bsky.graph.muteActor"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1178 1236 return this._server.xrpc.method(nsid, cfg); 1179 1237 } 1180 1238 1181 1181 - getMutes<AV extends AuthVerifier>( 1182 1182 - cfg: ConfigOf< 1183 1183 - AV, 1184 1184 - AppBskyGraphGetMutes.Handler<ExtractAuth<AV>>, 1185 1185 - AppBskyGraphGetMutes.HandlerReqCtx<ExtractAuth<AV>> 1239 1239 + getMutes<A extends Auth = void>( 1240 1240 + cfg: MethodConfigOrHandler< 1241 1241 + A, 1242 1242 + AppBskyGraphGetMutes.QueryParams, 1243 1243 + AppBskyGraphGetMutes.HandlerInput, 1244 1244 + AppBskyGraphGetMutes.HandlerOutput 1186 1245 >, 1187 1246 ) { 1188 1247 const nsid = "app.bsky.graph.getMutes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1189 1248 return this._server.xrpc.method(nsid, cfg); 1190 1249 } 1191 1250 1192 1192 - getKnownFollowers<AV extends AuthVerifier>( 1193 1193 - cfg: ConfigOf< 1194 1194 - AV, 1195 1195 - AppBskyGraphGetKnownFollowers.Handler<ExtractAuth<AV>>, 1196 1196 - AppBskyGraphGetKnownFollowers.HandlerReqCtx<ExtractAuth<AV>> 1251 1251 + getKnownFollowers<A extends Auth = void>( 1252 1252 + cfg: MethodConfigOrHandler< 1253 1253 + A, 1254 1254 + AppBskyGraphGetKnownFollowers.QueryParams, 1255 1255 + AppBskyGraphGetKnownFollowers.HandlerInput, 1256 1256 + AppBskyGraphGetKnownFollowers.HandlerOutput 1197 1257 >, 1198 1258 ) { 1199 1259 const nsid = "app.bsky.graph.getKnownFollowers"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1200 1260 return this._server.xrpc.method(nsid, cfg); 1201 1261 } 1202 1262 1203 1203 - getListMutes<AV extends AuthVerifier>( 1204 1204 - cfg: ConfigOf< 1205 1205 - AV, 1206 1206 - AppBskyGraphGetListMutes.Handler<ExtractAuth<AV>>, 1207 1207 - AppBskyGraphGetListMutes.HandlerReqCtx<ExtractAuth<AV>> 1263 1263 + getListMutes<A extends Auth = void>( 1264 1264 + cfg: MethodConfigOrHandler< 1265 1265 + A, 1266 1266 + AppBskyGraphGetListMutes.QueryParams, 1267 1267 + AppBskyGraphGetListMutes.HandlerInput, 1268 1268 + AppBskyGraphGetListMutes.HandlerOutput 1208 1269 >, 1209 1270 ) { 1210 1271 const nsid = "app.bsky.graph.getListMutes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1211 1272 return this._server.xrpc.method(nsid, cfg); 1212 1273 } 1213 1274 1214 1214 - getFollows<AV extends AuthVerifier>( 1215 1215 - cfg: ConfigOf< 1216 1216 - AV, 1217 1217 - AppBskyGraphGetFollows.Handler<ExtractAuth<AV>>, 1218 1218 - AppBskyGraphGetFollows.HandlerReqCtx<ExtractAuth<AV>> 1275 1275 + getFollows<A extends Auth = void>( 1276 1276 + cfg: MethodConfigOrHandler< 1277 1277 + A, 1278 1278 + AppBskyGraphGetFollows.QueryParams, 1279 1279 + AppBskyGraphGetFollows.HandlerInput, 1280 1280 + AppBskyGraphGetFollows.HandlerOutput 1219 1281 >, 1220 1282 ) { 1221 1283 const nsid = "app.bsky.graph.getFollows"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1222 1284 return this._server.xrpc.method(nsid, cfg); 1223 1285 } 1224 1286 1225 1225 - getBlocks<AV extends AuthVerifier>( 1226 1226 - cfg: ConfigOf< 1227 1227 - AV, 1228 1228 - AppBskyGraphGetBlocks.Handler<ExtractAuth<AV>>, 1229 1229 - AppBskyGraphGetBlocks.HandlerReqCtx<ExtractAuth<AV>> 1287 1287 + getBlocks<A extends Auth = void>( 1288 1288 + cfg: MethodConfigOrHandler< 1289 1289 + A, 1290 1290 + AppBskyGraphGetBlocks.QueryParams, 1291 1291 + AppBskyGraphGetBlocks.HandlerInput, 1292 1292 + AppBskyGraphGetBlocks.HandlerOutput 1230 1293 >, 1231 1294 ) { 1232 1295 const nsid = "app.bsky.graph.getBlocks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1233 1296 return this._server.xrpc.method(nsid, cfg); 1234 1297 } 1235 1298 1236 1236 - getRelationships<AV extends AuthVerifier>( 1237 1237 - cfg: ConfigOf< 1238 1238 - AV, 1239 1239 - AppBskyGraphGetRelationships.Handler<ExtractAuth<AV>>, 1240 1240 - AppBskyGraphGetRelationships.HandlerReqCtx<ExtractAuth<AV>> 1299 1299 + getRelationships<A extends Auth = void>( 1300 1300 + cfg: MethodConfigOrHandler< 1301 1301 + A, 1302 1302 + AppBskyGraphGetRelationships.QueryParams, 1303 1303 + AppBskyGraphGetRelationships.HandlerInput, 1304 1304 + AppBskyGraphGetRelationships.HandlerOutput 1241 1305 >, 1242 1306 ) { 1243 1307 const nsid = "app.bsky.graph.getRelationships"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1244 1308 return this._server.xrpc.method(nsid, cfg); 1245 1309 } 1246 1310 1247 1247 - unmuteActor<AV extends AuthVerifier>( 1248 1248 - cfg: ConfigOf< 1249 1249 - AV, 1250 1250 - AppBskyGraphUnmuteActor.Handler<ExtractAuth<AV>>, 1251 1251 - AppBskyGraphUnmuteActor.HandlerReqCtx<ExtractAuth<AV>> 1311 1311 + unmuteActor<A extends Auth = void>( 1312 1312 + cfg: MethodConfigOrHandler< 1313 1313 + A, 1314 1314 + AppBskyGraphUnmuteActor.QueryParams, 1315 1315 + AppBskyGraphUnmuteActor.HandlerInput, 1316 1316 + AppBskyGraphUnmuteActor.HandlerOutput 1252 1317 >, 1253 1318 ) { 1254 1319 const nsid = "app.bsky.graph.unmuteActor"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1255 1320 return this._server.xrpc.method(nsid, cfg); 1256 1321 } 1257 1322 1258 1258 - getList<AV extends AuthVerifier>( 1259 1259 - cfg: ConfigOf< 1260 1260 - AV, 1261 1261 - AppBskyGraphGetList.Handler<ExtractAuth<AV>>, 1262 1262 - AppBskyGraphGetList.HandlerReqCtx<ExtractAuth<AV>> 1323 1323 + getList<A extends Auth = void>( 1324 1324 + cfg: MethodConfigOrHandler< 1325 1325 + A, 1326 1326 + AppBskyGraphGetList.QueryParams, 1327 1327 + AppBskyGraphGetList.HandlerInput, 1328 1328 + AppBskyGraphGetList.HandlerOutput 1263 1329 >, 1264 1330 ) { 1265 1331 const nsid = "app.bsky.graph.getList"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1267 1333 } 1268 1334 } 1269 1335 1270 1270 - export class AppBskyFeedNS<T extends Env> { 1271 1271 - _server: Server<T>; 1336 1336 + export class AppBskyFeedNS { 1337 1337 + _server: Server; 1272 1338 1273 1273 - constructor(server: Server<T>) { 1339 1339 + constructor(server: Server) { 1274 1340 this._server = server; 1275 1341 } 1276 1342 1277 1277 - sendInteractions<AV extends AuthVerifier>( 1278 1278 - cfg: ConfigOf< 1279 1279 - AV, 1280 1280 - AppBskyFeedSendInteractions.Handler<ExtractAuth<AV>>, 1281 1281 - AppBskyFeedSendInteractions.HandlerReqCtx<ExtractAuth<AV>> 1343 1343 + sendInteractions<A extends Auth = void>( 1344 1344 + cfg: MethodConfigOrHandler< 1345 1345 + A, 1346 1346 + AppBskyFeedSendInteractions.QueryParams, 1347 1347 + AppBskyFeedSendInteractions.HandlerInput, 1348 1348 + AppBskyFeedSendInteractions.HandlerOutput 1282 1349 >, 1283 1350 ) { 1284 1351 const nsid = "app.bsky.feed.sendInteractions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1285 1352 return this._server.xrpc.method(nsid, cfg); 1286 1353 } 1287 1354 1288 1288 - getFeedGenerators<AV extends AuthVerifier>( 1289 1289 - cfg: ConfigOf< 1290 1290 - AV, 1291 1291 - AppBskyFeedGetFeedGenerators.Handler<ExtractAuth<AV>>, 1292 1292 - AppBskyFeedGetFeedGenerators.HandlerReqCtx<ExtractAuth<AV>> 1355 1355 + getFeedGenerators<A extends Auth = void>( 1356 1356 + cfg: MethodConfigOrHandler< 1357 1357 + A, 1358 1358 + AppBskyFeedGetFeedGenerators.QueryParams, 1359 1359 + AppBskyFeedGetFeedGenerators.HandlerInput, 1360 1360 + AppBskyFeedGetFeedGenerators.HandlerOutput 1293 1361 >, 1294 1362 ) { 1295 1363 const nsid = "app.bsky.feed.getFeedGenerators"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1296 1364 return this._server.xrpc.method(nsid, cfg); 1297 1365 } 1298 1366 1299 1299 - getTimeline<AV extends AuthVerifier>( 1300 1300 - cfg: ConfigOf< 1301 1301 - AV, 1302 1302 - AppBskyFeedGetTimeline.Handler<ExtractAuth<AV>>, 1303 1303 - AppBskyFeedGetTimeline.HandlerReqCtx<ExtractAuth<AV>> 1367 1367 + getTimeline<A extends Auth = void>( 1368 1368 + cfg: MethodConfigOrHandler< 1369 1369 + A, 1370 1370 + AppBskyFeedGetTimeline.QueryParams, 1371 1371 + AppBskyFeedGetTimeline.HandlerInput, 1372 1372 + AppBskyFeedGetTimeline.HandlerOutput 1304 1373 >, 1305 1374 ) { 1306 1375 const nsid = "app.bsky.feed.getTimeline"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1307 1376 return this._server.xrpc.method(nsid, cfg); 1308 1377 } 1309 1378 1310 1310 - getFeedGenerator<AV extends AuthVerifier>( 1311 1311 - cfg: ConfigOf< 1312 1312 - AV, 1313 1313 - AppBskyFeedGetFeedGenerator.Handler<ExtractAuth<AV>>, 1314 1314 - AppBskyFeedGetFeedGenerator.HandlerReqCtx<ExtractAuth<AV>> 1379 1379 + getFeedGenerator<A extends Auth = void>( 1380 1380 + cfg: MethodConfigOrHandler< 1381 1381 + A, 1382 1382 + AppBskyFeedGetFeedGenerator.QueryParams, 1383 1383 + AppBskyFeedGetFeedGenerator.HandlerInput, 1384 1384 + AppBskyFeedGetFeedGenerator.HandlerOutput 1315 1385 >, 1316 1386 ) { 1317 1387 const nsid = "app.bsky.feed.getFeedGenerator"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1318 1388 return this._server.xrpc.method(nsid, cfg); 1319 1389 } 1320 1390 1321 1321 - getAuthorFeed<AV extends AuthVerifier>( 1322 1322 - cfg: ConfigOf< 1323 1323 - AV, 1324 1324 - AppBskyFeedGetAuthorFeed.Handler<ExtractAuth<AV>>, 1325 1325 - AppBskyFeedGetAuthorFeed.HandlerReqCtx<ExtractAuth<AV>> 1391 1391 + getAuthorFeed<A extends Auth = void>( 1392 1392 + cfg: MethodConfigOrHandler< 1393 1393 + A, 1394 1394 + AppBskyFeedGetAuthorFeed.QueryParams, 1395 1395 + AppBskyFeedGetAuthorFeed.HandlerInput, 1396 1396 + AppBskyFeedGetAuthorFeed.HandlerOutput 1326 1397 >, 1327 1398 ) { 1328 1399 const nsid = "app.bsky.feed.getAuthorFeed"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1329 1400 return this._server.xrpc.method(nsid, cfg); 1330 1401 } 1331 1402 1332 1332 - getLikes<AV extends AuthVerifier>( 1333 1333 - cfg: ConfigOf< 1334 1334 - AV, 1335 1335 - AppBskyFeedGetLikes.Handler<ExtractAuth<AV>>, 1336 1336 - AppBskyFeedGetLikes.HandlerReqCtx<ExtractAuth<AV>> 1403 1403 + getLikes<A extends Auth = void>( 1404 1404 + cfg: MethodConfigOrHandler< 1405 1405 + A, 1406 1406 + AppBskyFeedGetLikes.QueryParams, 1407 1407 + AppBskyFeedGetLikes.HandlerInput, 1408 1408 + AppBskyFeedGetLikes.HandlerOutput 1337 1409 >, 1338 1410 ) { 1339 1411 const nsid = "app.bsky.feed.getLikes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1340 1412 return this._server.xrpc.method(nsid, cfg); 1341 1413 } 1342 1414 1343 1343 - getPostThread<AV extends AuthVerifier>( 1344 1344 - cfg: ConfigOf< 1345 1345 - AV, 1346 1346 - AppBskyFeedGetPostThread.Handler<ExtractAuth<AV>>, 1347 1347 - AppBskyFeedGetPostThread.HandlerReqCtx<ExtractAuth<AV>> 1415 1415 + getPostThread<A extends Auth = void>( 1416 1416 + cfg: MethodConfigOrHandler< 1417 1417 + A, 1418 1418 + AppBskyFeedGetPostThread.QueryParams, 1419 1419 + AppBskyFeedGetPostThread.HandlerInput, 1420 1420 + AppBskyFeedGetPostThread.HandlerOutput 1348 1421 >, 1349 1422 ) { 1350 1423 const nsid = "app.bsky.feed.getPostThread"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1351 1424 return this._server.xrpc.method(nsid, cfg); 1352 1425 } 1353 1426 1354 1354 - getActorLikes<AV extends AuthVerifier>( 1355 1355 - cfg: ConfigOf< 1356 1356 - AV, 1357 1357 - AppBskyFeedGetActorLikes.Handler<ExtractAuth<AV>>, 1358 1358 - AppBskyFeedGetActorLikes.HandlerReqCtx<ExtractAuth<AV>> 1427 1427 + getActorLikes<A extends Auth = void>( 1428 1428 + cfg: MethodConfigOrHandler< 1429 1429 + A, 1430 1430 + AppBskyFeedGetActorLikes.QueryParams, 1431 1431 + AppBskyFeedGetActorLikes.HandlerInput, 1432 1432 + AppBskyFeedGetActorLikes.HandlerOutput 1359 1433 >, 1360 1434 ) { 1361 1435 const nsid = "app.bsky.feed.getActorLikes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1362 1436 return this._server.xrpc.method(nsid, cfg); 1363 1437 } 1364 1438 1365 1365 - getRepostedBy<AV extends AuthVerifier>( 1366 1366 - cfg: ConfigOf< 1367 1367 - AV, 1368 1368 - AppBskyFeedGetRepostedBy.Handler<ExtractAuth<AV>>, 1369 1369 - AppBskyFeedGetRepostedBy.HandlerReqCtx<ExtractAuth<AV>> 1439 1439 + getRepostedBy<A extends Auth = void>( 1440 1440 + cfg: MethodConfigOrHandler< 1441 1441 + A, 1442 1442 + AppBskyFeedGetRepostedBy.QueryParams, 1443 1443 + AppBskyFeedGetRepostedBy.HandlerInput, 1444 1444 + AppBskyFeedGetRepostedBy.HandlerOutput 1370 1445 >, 1371 1446 ) { 1372 1447 const nsid = "app.bsky.feed.getRepostedBy"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1373 1448 return this._server.xrpc.method(nsid, cfg); 1374 1449 } 1375 1450 1376 1376 - describeFeedGenerator<AV extends AuthVerifier>( 1377 1377 - cfg: ConfigOf< 1378 1378 - AV, 1379 1379 - AppBskyFeedDescribeFeedGenerator.Handler<ExtractAuth<AV>>, 1380 1380 - AppBskyFeedDescribeFeedGenerator.HandlerReqCtx<ExtractAuth<AV>> 1451 1451 + describeFeedGenerator<A extends Auth = void>( 1452 1452 + cfg: MethodConfigOrHandler< 1453 1453 + A, 1454 1454 + AppBskyFeedDescribeFeedGenerator.QueryParams, 1455 1455 + AppBskyFeedDescribeFeedGenerator.HandlerInput, 1456 1456 + AppBskyFeedDescribeFeedGenerator.HandlerOutput 1381 1457 >, 1382 1458 ) { 1383 1459 const nsid = "app.bsky.feed.describeFeedGenerator"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1384 1460 return this._server.xrpc.method(nsid, cfg); 1385 1461 } 1386 1462 1387 1387 - searchPosts<AV extends AuthVerifier>( 1388 1388 - cfg: ConfigOf< 1389 1389 - AV, 1390 1390 - AppBskyFeedSearchPosts.Handler<ExtractAuth<AV>>, 1391 1391 - AppBskyFeedSearchPosts.HandlerReqCtx<ExtractAuth<AV>> 1463 1463 + searchPosts<A extends Auth = void>( 1464 1464 + cfg: MethodConfigOrHandler< 1465 1465 + A, 1466 1466 + AppBskyFeedSearchPosts.QueryParams, 1467 1467 + AppBskyFeedSearchPosts.HandlerInput, 1468 1468 + AppBskyFeedSearchPosts.HandlerOutput 1392 1469 >, 1393 1470 ) { 1394 1471 const nsid = "app.bsky.feed.searchPosts"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1395 1472 return this._server.xrpc.method(nsid, cfg); 1396 1473 } 1397 1474 1398 1398 - getPosts<AV extends AuthVerifier>( 1399 1399 - cfg: ConfigOf< 1400 1400 - AV, 1401 1401 - AppBskyFeedGetPosts.Handler<ExtractAuth<AV>>, 1402 1402 - AppBskyFeedGetPosts.HandlerReqCtx<ExtractAuth<AV>> 1475 1475 + getPosts<A extends Auth = void>( 1476 1476 + cfg: MethodConfigOrHandler< 1477 1477 + A, 1478 1478 + AppBskyFeedGetPosts.QueryParams, 1479 1479 + AppBskyFeedGetPosts.HandlerInput, 1480 1480 + AppBskyFeedGetPosts.HandlerOutput 1403 1481 >, 1404 1482 ) { 1405 1483 const nsid = "app.bsky.feed.getPosts"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1406 1484 return this._server.xrpc.method(nsid, cfg); 1407 1485 } 1408 1486 1409 1409 - getFeed<AV extends AuthVerifier>( 1410 1410 - cfg: ConfigOf< 1411 1411 - AV, 1412 1412 - AppBskyFeedGetFeed.Handler<ExtractAuth<AV>>, 1413 1413 - AppBskyFeedGetFeed.HandlerReqCtx<ExtractAuth<AV>> 1487 1487 + getFeed<A extends Auth = void>( 1488 1488 + cfg: MethodConfigOrHandler< 1489 1489 + A, 1490 1490 + AppBskyFeedGetFeed.QueryParams, 1491 1491 + AppBskyFeedGetFeed.HandlerInput, 1492 1492 + AppBskyFeedGetFeed.HandlerOutput 1414 1493 >, 1415 1494 ) { 1416 1495 const nsid = "app.bsky.feed.getFeed"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1417 1496 return this._server.xrpc.method(nsid, cfg); 1418 1497 } 1419 1498 1420 1420 - getQuotes<AV extends AuthVerifier>( 1421 1421 - cfg: ConfigOf< 1422 1422 - AV, 1423 1423 - AppBskyFeedGetQuotes.Handler<ExtractAuth<AV>>, 1424 1424 - AppBskyFeedGetQuotes.HandlerReqCtx<ExtractAuth<AV>> 1499 1499 + getQuotes<A extends Auth = void>( 1500 1500 + cfg: MethodConfigOrHandler< 1501 1501 + A, 1502 1502 + AppBskyFeedGetQuotes.QueryParams, 1503 1503 + AppBskyFeedGetQuotes.HandlerInput, 1504 1504 + AppBskyFeedGetQuotes.HandlerOutput 1425 1505 >, 1426 1506 ) { 1427 1507 const nsid = "app.bsky.feed.getQuotes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1428 1508 return this._server.xrpc.method(nsid, cfg); 1429 1509 } 1430 1510 1431 1431 - getFeedSkeleton<AV extends AuthVerifier>( 1432 1432 - cfg: ConfigOf< 1433 1433 - AV, 1434 1434 - AppBskyFeedGetFeedSkeleton.Handler<ExtractAuth<AV>>, 1435 1435 - AppBskyFeedGetFeedSkeleton.HandlerReqCtx<ExtractAuth<AV>> 1511 1511 + getFeedSkeleton<A extends Auth = void>( 1512 1512 + cfg: MethodConfigOrHandler< 1513 1513 + A, 1514 1514 + AppBskyFeedGetFeedSkeleton.QueryParams, 1515 1515 + AppBskyFeedGetFeedSkeleton.HandlerInput, 1516 1516 + AppBskyFeedGetFeedSkeleton.HandlerOutput 1436 1517 >, 1437 1518 ) { 1438 1519 const nsid = "app.bsky.feed.getFeedSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1439 1520 return this._server.xrpc.method(nsid, cfg); 1440 1521 } 1441 1522 1442 1442 - getListFeed<AV extends AuthVerifier>( 1443 1443 - cfg: ConfigOf< 1444 1444 - AV, 1445 1445 - AppBskyFeedGetListFeed.Handler<ExtractAuth<AV>>, 1446 1446 - AppBskyFeedGetListFeed.HandlerReqCtx<ExtractAuth<AV>> 1523 1523 + getListFeed<A extends Auth = void>( 1524 1524 + cfg: MethodConfigOrHandler< 1525 1525 + A, 1526 1526 + AppBskyFeedGetListFeed.QueryParams, 1527 1527 + AppBskyFeedGetListFeed.HandlerInput, 1528 1528 + AppBskyFeedGetListFeed.HandlerOutput 1447 1529 >, 1448 1530 ) { 1449 1531 const nsid = "app.bsky.feed.getListFeed"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1450 1532 return this._server.xrpc.method(nsid, cfg); 1451 1533 } 1452 1534 1453 1453 - getSuggestedFeeds<AV extends AuthVerifier>( 1454 1454 - cfg: ConfigOf< 1455 1455 - AV, 1456 1456 - AppBskyFeedGetSuggestedFeeds.Handler<ExtractAuth<AV>>, 1457 1457 - AppBskyFeedGetSuggestedFeeds.HandlerReqCtx<ExtractAuth<AV>> 1535 1535 + getSuggestedFeeds<A extends Auth = void>( 1536 1536 + cfg: MethodConfigOrHandler< 1537 1537 + A, 1538 1538 + AppBskyFeedGetSuggestedFeeds.QueryParams, 1539 1539 + AppBskyFeedGetSuggestedFeeds.HandlerInput, 1540 1540 + AppBskyFeedGetSuggestedFeeds.HandlerOutput 1458 1541 >, 1459 1542 ) { 1460 1543 const nsid = "app.bsky.feed.getSuggestedFeeds"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1461 1544 return this._server.xrpc.method(nsid, cfg); 1462 1545 } 1463 1546 1464 1464 - getActorFeeds<AV extends AuthVerifier>( 1465 1465 - cfg: ConfigOf< 1466 1466 - AV, 1467 1467 - AppBskyFeedGetActorFeeds.Handler<ExtractAuth<AV>>, 1468 1468 - AppBskyFeedGetActorFeeds.HandlerReqCtx<ExtractAuth<AV>> 1547 1547 + getActorFeeds<A extends Auth = void>( 1548 1548 + cfg: MethodConfigOrHandler< 1549 1549 + A, 1550 1550 + AppBskyFeedGetActorFeeds.QueryParams, 1551 1551 + AppBskyFeedGetActorFeeds.HandlerInput, 1552 1552 + AppBskyFeedGetActorFeeds.HandlerOutput 1469 1553 >, 1470 1554 ) { 1471 1555 const nsid = "app.bsky.feed.getActorFeeds"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1473 1557 } 1474 1558 } 1475 1559 1476 1476 - export class AppBskyRichtextNS<T extends Env> { 1477 1477 - _server: Server<T>; 1560 1560 + export class AppBskyRichtextNS { 1561 1561 + _server: Server; 1478 1562 1479 1479 - constructor(server: Server<T>) { 1563 1563 + constructor(server: Server) { 1480 1564 this._server = server; 1481 1565 } 1482 1566 } 1483 1567 1484 1484 - export class AppBskyActorNS<T extends Env> { 1485 1485 - _server: Server<T>; 1568 1568 + export class AppBskyActorNS { 1569 1569 + _server: Server; 1486 1570 1487 1487 - constructor(server: Server<T>) { 1571 1571 + constructor(server: Server) { 1488 1572 this._server = server; 1489 1573 } 1490 1574 1491 1491 - searchActorsTypeahead<AV extends AuthVerifier>( 1492 1492 - cfg: ConfigOf< 1493 1493 - AV, 1494 1494 - AppBskyActorSearchActorsTypeahead.Handler<ExtractAuth<AV>>, 1495 1495 - AppBskyActorSearchActorsTypeahead.HandlerReqCtx<ExtractAuth<AV>> 1575 1575 + searchActorsTypeahead<A extends Auth = void>( 1576 1576 + cfg: MethodConfigOrHandler< 1577 1577 + A, 1578 1578 + AppBskyActorSearchActorsTypeahead.QueryParams, 1579 1579 + AppBskyActorSearchActorsTypeahead.HandlerInput, 1580 1580 + AppBskyActorSearchActorsTypeahead.HandlerOutput 1496 1581 >, 1497 1582 ) { 1498 1583 const nsid = "app.bsky.actor.searchActorsTypeahead"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1499 1584 return this._server.xrpc.method(nsid, cfg); 1500 1585 } 1501 1586 1502 1502 - putPreferences<AV extends AuthVerifier>( 1503 1503 - cfg: ConfigOf< 1504 1504 - AV, 1505 1505 - AppBskyActorPutPreferences.Handler<ExtractAuth<AV>>, 1506 1506 - AppBskyActorPutPreferences.HandlerReqCtx<ExtractAuth<AV>> 1587 1587 + putPreferences<A extends Auth = void>( 1588 1588 + cfg: MethodConfigOrHandler< 1589 1589 + A, 1590 1590 + AppBskyActorPutPreferences.QueryParams, 1591 1591 + AppBskyActorPutPreferences.HandlerInput, 1592 1592 + AppBskyActorPutPreferences.HandlerOutput 1507 1593 >, 1508 1594 ) { 1509 1595 const nsid = "app.bsky.actor.putPreferences"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1510 1596 return this._server.xrpc.method(nsid, cfg); 1511 1597 } 1512 1598 1513 1513 - getProfile<AV extends AuthVerifier>( 1514 1514 - cfg: ConfigOf< 1515 1515 - AV, 1516 1516 - AppBskyActorGetProfile.Handler<ExtractAuth<AV>>, 1517 1517 - AppBskyActorGetProfile.HandlerReqCtx<ExtractAuth<AV>> 1599 1599 + getProfile<A extends Auth = void>( 1600 1600 + cfg: MethodConfigOrHandler< 1601 1601 + A, 1602 1602 + AppBskyActorGetProfile.QueryParams, 1603 1603 + AppBskyActorGetProfile.HandlerInput, 1604 1604 + AppBskyActorGetProfile.HandlerOutput 1518 1605 >, 1519 1606 ) { 1520 1607 const nsid = "app.bsky.actor.getProfile"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1521 1608 return this._server.xrpc.method(nsid, cfg); 1522 1609 } 1523 1610 1524 1524 - getSuggestions<AV extends AuthVerifier>( 1525 1525 - cfg: ConfigOf< 1526 1526 - AV, 1527 1527 - AppBskyActorGetSuggestions.Handler<ExtractAuth<AV>>, 1528 1528 - AppBskyActorGetSuggestions.HandlerReqCtx<ExtractAuth<AV>> 1611 1611 + getSuggestions<A extends Auth = void>( 1612 1612 + cfg: MethodConfigOrHandler< 1613 1613 + A, 1614 1614 + AppBskyActorGetSuggestions.QueryParams, 1615 1615 + AppBskyActorGetSuggestions.HandlerInput, 1616 1616 + AppBskyActorGetSuggestions.HandlerOutput 1529 1617 >, 1530 1618 ) { 1531 1619 const nsid = "app.bsky.actor.getSuggestions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1532 1620 return this._server.xrpc.method(nsid, cfg); 1533 1621 } 1534 1622 1535 1535 - searchActors<AV extends AuthVerifier>( 1536 1536 - cfg: ConfigOf< 1537 1537 - AV, 1538 1538 - AppBskyActorSearchActors.Handler<ExtractAuth<AV>>, 1539 1539 - AppBskyActorSearchActors.HandlerReqCtx<ExtractAuth<AV>> 1623 1623 + searchActors<A extends Auth = void>( 1624 1624 + cfg: MethodConfigOrHandler< 1625 1625 + A, 1626 1626 + AppBskyActorSearchActors.QueryParams, 1627 1627 + AppBskyActorSearchActors.HandlerInput, 1628 1628 + AppBskyActorSearchActors.HandlerOutput 1540 1629 >, 1541 1630 ) { 1542 1631 const nsid = "app.bsky.actor.searchActors"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1543 1632 return this._server.xrpc.method(nsid, cfg); 1544 1633 } 1545 1634 1546 1546 - getProfiles<AV extends AuthVerifier>( 1547 1547 - cfg: ConfigOf< 1548 1548 - AV, 1549 1549 - AppBskyActorGetProfiles.Handler<ExtractAuth<AV>>, 1550 1550 - AppBskyActorGetProfiles.HandlerReqCtx<ExtractAuth<AV>> 1635 1635 + getProfiles<A extends Auth = void>( 1636 1636 + cfg: MethodConfigOrHandler< 1637 1637 + A, 1638 1638 + AppBskyActorGetProfiles.QueryParams, 1639 1639 + AppBskyActorGetProfiles.HandlerInput, 1640 1640 + AppBskyActorGetProfiles.HandlerOutput 1551 1641 >, 1552 1642 ) { 1553 1643 const nsid = "app.bsky.actor.getProfiles"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1554 1644 return this._server.xrpc.method(nsid, cfg); 1555 1645 } 1556 1646 1557 1557 - getPreferences<AV extends AuthVerifier>( 1558 1558 - cfg: ConfigOf< 1559 1559 - AV, 1560 1560 - AppBskyActorGetPreferences.Handler<ExtractAuth<AV>>, 1561 1561 - AppBskyActorGetPreferences.HandlerReqCtx<ExtractAuth<AV>> 1647 1647 + getPreferences<A extends Auth = void>( 1648 1648 + cfg: MethodConfigOrHandler< 1649 1649 + A, 1650 1650 + AppBskyActorGetPreferences.QueryParams, 1651 1651 + AppBskyActorGetPreferences.HandlerInput, 1652 1652 + AppBskyActorGetPreferences.HandlerOutput 1562 1653 >, 1563 1654 ) { 1564 1655 const nsid = "app.bsky.actor.getPreferences"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1566 1657 } 1567 1658 } 1568 1659 1569 1569 - export class AppBskyLabelerNS<T extends Env> { 1570 1570 - _server: Server<T>; 1660 1660 + export class AppBskyLabelerNS { 1661 1661 + _server: Server; 1571 1662 1572 1572 - constructor(server: Server<T>) { 1663 1663 + constructor(server: Server) { 1573 1664 this._server = server; 1574 1665 } 1575 1666 1576 1576 - getServices<AV extends AuthVerifier>( 1577 1577 - cfg: ConfigOf< 1578 1578 - AV, 1579 1579 - AppBskyLabelerGetServices.Handler<ExtractAuth<AV>>, 1580 1580 - AppBskyLabelerGetServices.HandlerReqCtx<ExtractAuth<AV>> 1667 1667 + getServices<A extends Auth = void>( 1668 1668 + cfg: MethodConfigOrHandler< 1669 1669 + A, 1670 1670 + AppBskyLabelerGetServices.QueryParams, 1671 1671 + AppBskyLabelerGetServices.HandlerInput, 1672 1672 + AppBskyLabelerGetServices.HandlerOutput 1581 1673 >, 1582 1674 ) { 1583 1675 const nsid = "app.bsky.labeler.getServices"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1585 1677 } 1586 1678 } 1587 1679 1588 1588 - export class ChatNS<T extends Env> { 1589 1589 - _server: Server<T>; 1590 1590 - bsky: ChatBskyNS<T>; 1680 1680 + export class ChatNS { 1681 1681 + _server: Server; 1682 1682 + bsky: ChatBskyNS; 1591 1683 1592 1592 - constructor(server: Server<T>) { 1684 1684 + constructor(server: Server) { 1593 1685 this._server = server; 1594 1686 this.bsky = new ChatBskyNS(server); 1595 1687 } 1596 1688 } 1597 1689 1598 1598 - export class ChatBskyNS<T extends Env> { 1599 1599 - _server: Server<T>; 1600 1600 - convo: ChatBskyConvoNS<T>; 1601 1601 - actor: ChatBskyActorNS<T>; 1602 1602 - moderation: ChatBskyModerationNS<T>; 1690 1690 + export class ChatBskyNS { 1691 1691 + _server: Server; 1692 1692 + convo: ChatBskyConvoNS; 1693 1693 + actor: ChatBskyActorNS; 1694 1694 + moderation: ChatBskyModerationNS; 1603 1695 1604 1604 - constructor(server: Server<T>) { 1696 1696 + constructor(server: Server) { 1605 1697 this._server = server; 1606 1698 this.convo = new ChatBskyConvoNS(server); 1607 1699 this.actor = new ChatBskyActorNS(server); ··· 1609 1701 } 1610 1702 } 1611 1703 1612 1612 - export class ChatBskyConvoNS<T extends Env> { 1613 1613 - _server: Server<T>; 1704 1704 + export class ChatBskyConvoNS { 1705 1705 + _server: Server; 1614 1706 1615 1615 - constructor(server: Server<T>) { 1707 1707 + constructor(server: Server) { 1616 1708 this._server = server; 1617 1709 } 1618 1710 1619 1619 - listConvos<AV extends AuthVerifier>( 1620 1620 - cfg: ConfigOf< 1621 1621 - AV, 1622 1622 - ChatBskyConvoListConvos.Handler<ExtractAuth<AV>>, 1623 1623 - ChatBskyConvoListConvos.HandlerReqCtx<ExtractAuth<AV>> 1711 1711 + listConvos<A extends Auth = void>( 1712 1712 + cfg: MethodConfigOrHandler< 1713 1713 + A, 1714 1714 + ChatBskyConvoListConvos.QueryParams, 1715 1715 + ChatBskyConvoListConvos.HandlerInput, 1716 1716 + ChatBskyConvoListConvos.HandlerOutput 1624 1717 >, 1625 1718 ) { 1626 1719 const nsid = "chat.bsky.convo.listConvos"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1627 1720 return this._server.xrpc.method(nsid, cfg); 1628 1721 } 1629 1722 1630 1630 - unmuteConvo<AV extends AuthVerifier>( 1631 1631 - cfg: ConfigOf< 1632 1632 - AV, 1633 1633 - ChatBskyConvoUnmuteConvo.Handler<ExtractAuth<AV>>, 1634 1634 - ChatBskyConvoUnmuteConvo.HandlerReqCtx<ExtractAuth<AV>> 1723 1723 + unmuteConvo<A extends Auth = void>( 1724 1724 + cfg: MethodConfigOrHandler< 1725 1725 + A, 1726 1726 + ChatBskyConvoUnmuteConvo.QueryParams, 1727 1727 + ChatBskyConvoUnmuteConvo.HandlerInput, 1728 1728 + ChatBskyConvoUnmuteConvo.HandlerOutput 1635 1729 >, 1636 1730 ) { 1637 1731 const nsid = "chat.bsky.convo.unmuteConvo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1638 1732 return this._server.xrpc.method(nsid, cfg); 1639 1733 } 1640 1734 1641 1641 - getConvoAvailability<AV extends AuthVerifier>( 1642 1642 - cfg: ConfigOf< 1643 1643 - AV, 1644 1644 - ChatBskyConvoGetConvoAvailability.Handler<ExtractAuth<AV>>, 1645 1645 - ChatBskyConvoGetConvoAvailability.HandlerReqCtx<ExtractAuth<AV>> 1735 1735 + getConvoAvailability<A extends Auth = void>( 1736 1736 + cfg: MethodConfigOrHandler< 1737 1737 + A, 1738 1738 + ChatBskyConvoGetConvoAvailability.QueryParams, 1739 1739 + ChatBskyConvoGetConvoAvailability.HandlerInput, 1740 1740 + ChatBskyConvoGetConvoAvailability.HandlerOutput 1646 1741 >, 1647 1742 ) { 1648 1743 const nsid = "chat.bsky.convo.getConvoAvailability"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1649 1744 return this._server.xrpc.method(nsid, cfg); 1650 1745 } 1651 1746 1652 1652 - getLog<AV extends AuthVerifier>( 1653 1653 - cfg: ConfigOf< 1654 1654 - AV, 1655 1655 - ChatBskyConvoGetLog.Handler<ExtractAuth<AV>>, 1656 1656 - ChatBskyConvoGetLog.HandlerReqCtx<ExtractAuth<AV>> 1747 1747 + getLog<A extends Auth = void>( 1748 1748 + cfg: MethodConfigOrHandler< 1749 1749 + A, 1750 1750 + ChatBskyConvoGetLog.QueryParams, 1751 1751 + ChatBskyConvoGetLog.HandlerInput, 1752 1752 + ChatBskyConvoGetLog.HandlerOutput 1657 1753 >, 1658 1754 ) { 1659 1755 const nsid = "chat.bsky.convo.getLog"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1660 1756 return this._server.xrpc.method(nsid, cfg); 1661 1757 } 1662 1758 1663 1663 - sendMessage<AV extends AuthVerifier>( 1664 1664 - cfg: ConfigOf< 1665 1665 - AV, 1666 1666 - ChatBskyConvoSendMessage.Handler<ExtractAuth<AV>>, 1667 1667 - ChatBskyConvoSendMessage.HandlerReqCtx<ExtractAuth<AV>> 1759 1759 + sendMessage<A extends Auth = void>( 1760 1760 + cfg: MethodConfigOrHandler< 1761 1761 + A, 1762 1762 + ChatBskyConvoSendMessage.QueryParams, 1763 1763 + ChatBskyConvoSendMessage.HandlerInput, 1764 1764 + ChatBskyConvoSendMessage.HandlerOutput 1668 1765 >, 1669 1766 ) { 1670 1767 const nsid = "chat.bsky.convo.sendMessage"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1671 1768 return this._server.xrpc.method(nsid, cfg); 1672 1769 } 1673 1770 1674 1674 - leaveConvo<AV extends AuthVerifier>( 1675 1675 - cfg: ConfigOf< 1676 1676 - AV, 1677 1677 - ChatBskyConvoLeaveConvo.Handler<ExtractAuth<AV>>, 1678 1678 - ChatBskyConvoLeaveConvo.HandlerReqCtx<ExtractAuth<AV>> 1771 1771 + leaveConvo<A extends Auth = void>( 1772 1772 + cfg: MethodConfigOrHandler< 1773 1773 + A, 1774 1774 + ChatBskyConvoLeaveConvo.QueryParams, 1775 1775 + ChatBskyConvoLeaveConvo.HandlerInput, 1776 1776 + ChatBskyConvoLeaveConvo.HandlerOutput 1679 1777 >, 1680 1778 ) { 1681 1779 const nsid = "chat.bsky.convo.leaveConvo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1682 1780 return this._server.xrpc.method(nsid, cfg); 1683 1781 } 1684 1782 1685 1685 - acceptConvo<AV extends AuthVerifier>( 1686 1686 - cfg: ConfigOf< 1687 1687 - AV, 1688 1688 - ChatBskyConvoAcceptConvo.Handler<ExtractAuth<AV>>, 1689 1689 - ChatBskyConvoAcceptConvo.HandlerReqCtx<ExtractAuth<AV>> 1783 1783 + acceptConvo<A extends Auth = void>( 1784 1784 + cfg: MethodConfigOrHandler< 1785 1785 + A, 1786 1786 + ChatBskyConvoAcceptConvo.QueryParams, 1787 1787 + ChatBskyConvoAcceptConvo.HandlerInput, 1788 1788 + ChatBskyConvoAcceptConvo.HandlerOutput 1690 1789 >, 1691 1790 ) { 1692 1791 const nsid = "chat.bsky.convo.acceptConvo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1693 1792 return this._server.xrpc.method(nsid, cfg); 1694 1793 } 1695 1794 1696 1696 - muteConvo<AV extends AuthVerifier>( 1697 1697 - cfg: ConfigOf< 1698 1698 - AV, 1699 1699 - ChatBskyConvoMuteConvo.Handler<ExtractAuth<AV>>, 1700 1700 - ChatBskyConvoMuteConvo.HandlerReqCtx<ExtractAuth<AV>> 1795 1795 + muteConvo<A extends Auth = void>( 1796 1796 + cfg: MethodConfigOrHandler< 1797 1797 + A, 1798 1798 + ChatBskyConvoMuteConvo.QueryParams, 1799 1799 + ChatBskyConvoMuteConvo.HandlerInput, 1800 1800 + ChatBskyConvoMuteConvo.HandlerOutput 1701 1801 >, 1702 1802 ) { 1703 1803 const nsid = "chat.bsky.convo.muteConvo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1704 1804 return this._server.xrpc.method(nsid, cfg); 1705 1805 } 1706 1806 1707 1707 - deleteMessageForSelf<AV extends AuthVerifier>( 1708 1708 - cfg: ConfigOf< 1709 1709 - AV, 1710 1710 - ChatBskyConvoDeleteMessageForSelf.Handler<ExtractAuth<AV>>, 1711 1711 - ChatBskyConvoDeleteMessageForSelf.HandlerReqCtx<ExtractAuth<AV>> 1807 1807 + deleteMessageForSelf<A extends Auth = void>( 1808 1808 + cfg: MethodConfigOrHandler< 1809 1809 + A, 1810 1810 + ChatBskyConvoDeleteMessageForSelf.QueryParams, 1811 1811 + ChatBskyConvoDeleteMessageForSelf.HandlerInput, 1812 1812 + ChatBskyConvoDeleteMessageForSelf.HandlerOutput 1712 1813 >, 1713 1814 ) { 1714 1815 const nsid = "chat.bsky.convo.deleteMessageForSelf"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1715 1816 return this._server.xrpc.method(nsid, cfg); 1716 1817 } 1717 1818 1718 1718 - updateRead<AV extends AuthVerifier>( 1719 1719 - cfg: ConfigOf< 1720 1720 - AV, 1721 1721 - ChatBskyConvoUpdateRead.Handler<ExtractAuth<AV>>, 1722 1722 - ChatBskyConvoUpdateRead.HandlerReqCtx<ExtractAuth<AV>> 1819 1819 + updateRead<A extends Auth = void>( 1820 1820 + cfg: MethodConfigOrHandler< 1821 1821 + A, 1822 1822 + ChatBskyConvoUpdateRead.QueryParams, 1823 1823 + ChatBskyConvoUpdateRead.HandlerInput, 1824 1824 + ChatBskyConvoUpdateRead.HandlerOutput 1723 1825 >, 1724 1826 ) { 1725 1827 const nsid = "chat.bsky.convo.updateRead"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1726 1828 return this._server.xrpc.method(nsid, cfg); 1727 1829 } 1728 1830 1729 1729 - updateAllRead<AV extends AuthVerifier>( 1730 1730 - cfg: ConfigOf< 1731 1731 - AV, 1732 1732 - ChatBskyConvoUpdateAllRead.Handler<ExtractAuth<AV>>, 1733 1733 - ChatBskyConvoUpdateAllRead.HandlerReqCtx<ExtractAuth<AV>> 1831 1831 + updateAllRead<A extends Auth = void>( 1832 1832 + cfg: MethodConfigOrHandler< 1833 1833 + A, 1834 1834 + ChatBskyConvoUpdateAllRead.QueryParams, 1835 1835 + ChatBskyConvoUpdateAllRead.HandlerInput, 1836 1836 + ChatBskyConvoUpdateAllRead.HandlerOutput 1734 1837 >, 1735 1838 ) { 1736 1839 const nsid = "chat.bsky.convo.updateAllRead"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1737 1840 return this._server.xrpc.method(nsid, cfg); 1738 1841 } 1739 1842 1740 1740 - getConvo<AV extends AuthVerifier>( 1741 1741 - cfg: ConfigOf< 1742 1742 - AV, 1743 1743 - ChatBskyConvoGetConvo.Handler<ExtractAuth<AV>>, 1744 1744 - ChatBskyConvoGetConvo.HandlerReqCtx<ExtractAuth<AV>> 1843 1843 + getConvo<A extends Auth = void>( 1844 1844 + cfg: MethodConfigOrHandler< 1845 1845 + A, 1846 1846 + ChatBskyConvoGetConvo.QueryParams, 1847 1847 + ChatBskyConvoGetConvo.HandlerInput, 1848 1848 + ChatBskyConvoGetConvo.HandlerOutput 1745 1849 >, 1746 1850 ) { 1747 1851 const nsid = "chat.bsky.convo.getConvo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1748 1852 return this._server.xrpc.method(nsid, cfg); 1749 1853 } 1750 1854 1751 1751 - getMessages<AV extends AuthVerifier>( 1752 1752 - cfg: ConfigOf< 1753 1753 - AV, 1754 1754 - ChatBskyConvoGetMessages.Handler<ExtractAuth<AV>>, 1755 1755 - ChatBskyConvoGetMessages.HandlerReqCtx<ExtractAuth<AV>> 1855 1855 + getMessages<A extends Auth = void>( 1856 1856 + cfg: MethodConfigOrHandler< 1857 1857 + A, 1858 1858 + ChatBskyConvoGetMessages.QueryParams, 1859 1859 + ChatBskyConvoGetMessages.HandlerInput, 1860 1860 + ChatBskyConvoGetMessages.HandlerOutput 1756 1861 >, 1757 1862 ) { 1758 1863 const nsid = "chat.bsky.convo.getMessages"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1759 1864 return this._server.xrpc.method(nsid, cfg); 1760 1865 } 1761 1866 1762 1762 - getConvoForMembers<AV extends AuthVerifier>( 1763 1763 - cfg: ConfigOf< 1764 1764 - AV, 1765 1765 - ChatBskyConvoGetConvoForMembers.Handler<ExtractAuth<AV>>, 1766 1766 - ChatBskyConvoGetConvoForMembers.HandlerReqCtx<ExtractAuth<AV>> 1867 1867 + getConvoForMembers<A extends Auth = void>( 1868 1868 + cfg: MethodConfigOrHandler< 1869 1869 + A, 1870 1870 + ChatBskyConvoGetConvoForMembers.QueryParams, 1871 1871 + ChatBskyConvoGetConvoForMembers.HandlerInput, 1872 1872 + ChatBskyConvoGetConvoForMembers.HandlerOutput 1767 1873 >, 1768 1874 ) { 1769 1875 const nsid = "chat.bsky.convo.getConvoForMembers"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1770 1876 return this._server.xrpc.method(nsid, cfg); 1771 1877 } 1772 1878 1773 1773 - sendMessageBatch<AV extends AuthVerifier>( 1774 1774 - cfg: ConfigOf< 1775 1775 - AV, 1776 1776 - ChatBskyConvoSendMessageBatch.Handler<ExtractAuth<AV>>, 1777 1777 - ChatBskyConvoSendMessageBatch.HandlerReqCtx<ExtractAuth<AV>> 1879 1879 + sendMessageBatch<A extends Auth = void>( 1880 1880 + cfg: MethodConfigOrHandler< 1881 1881 + A, 1882 1882 + ChatBskyConvoSendMessageBatch.QueryParams, 1883 1883 + ChatBskyConvoSendMessageBatch.HandlerInput, 1884 1884 + ChatBskyConvoSendMessageBatch.HandlerOutput 1778 1885 >, 1779 1886 ) { 1780 1887 const nsid = "chat.bsky.convo.sendMessageBatch"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1782 1889 } 1783 1890 } 1784 1891 1785 1785 - export class ChatBskyActorNS<T extends Env> { 1786 1786 - _server: Server<T>; 1892 1892 + export class ChatBskyActorNS { 1893 1893 + _server: Server; 1787 1894 1788 1788 - constructor(server: Server<T>) { 1895 1895 + constructor(server: Server) { 1789 1896 this._server = server; 1790 1897 } 1791 1898 1792 1792 - exportAccountData<AV extends AuthVerifier>( 1793 1793 - cfg: ConfigOf< 1794 1794 - AV, 1795 1795 - ChatBskyActorExportAccountData.Handler<ExtractAuth<AV>>, 1796 1796 - ChatBskyActorExportAccountData.HandlerReqCtx<ExtractAuth<AV>> 1899 1899 + exportAccountData<A extends Auth = void>( 1900 1900 + cfg: MethodConfigOrHandler< 1901 1901 + A, 1902 1902 + ChatBskyActorExportAccountData.QueryParams, 1903 1903 + ChatBskyActorExportAccountData.HandlerInput, 1904 1904 + ChatBskyActorExportAccountData.HandlerOutput 1797 1905 >, 1798 1906 ) { 1799 1907 const nsid = "chat.bsky.actor.exportAccountData"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1800 1908 return this._server.xrpc.method(nsid, cfg); 1801 1909 } 1802 1910 1803 1803 - deleteAccount<AV extends AuthVerifier>( 1804 1804 - cfg: ConfigOf< 1805 1805 - AV, 1806 1806 - ChatBskyActorDeleteAccount.Handler<ExtractAuth<AV>>, 1807 1807 - ChatBskyActorDeleteAccount.HandlerReqCtx<ExtractAuth<AV>> 1911 1911 + deleteAccount<A extends Auth = void>( 1912 1912 + cfg: MethodConfigOrHandler< 1913 1913 + A, 1914 1914 + ChatBskyActorDeleteAccount.QueryParams, 1915 1915 + ChatBskyActorDeleteAccount.HandlerInput, 1916 1916 + ChatBskyActorDeleteAccount.HandlerOutput 1808 1917 >, 1809 1918 ) { 1810 1919 const nsid = "chat.bsky.actor.deleteAccount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1812 1921 } 1813 1922 } 1814 1923 1815 1815 - export class ChatBskyModerationNS<T extends Env> { 1816 1816 - _server: Server<T>; 1924 1924 + export class ChatBskyModerationNS { 1925 1925 + _server: Server; 1817 1926 1818 1818 - constructor(server: Server<T>) { 1927 1927 + constructor(server: Server) { 1819 1928 this._server = server; 1820 1929 } 1821 1930 1822 1822 - getActorMetadata<AV extends AuthVerifier>( 1823 1823 - cfg: ConfigOf< 1824 1824 - AV, 1825 1825 - ChatBskyModerationGetActorMetadata.Handler<ExtractAuth<AV>>, 1826 1826 - ChatBskyModerationGetActorMetadata.HandlerReqCtx<ExtractAuth<AV>> 1931 1931 + getActorMetadata<A extends Auth = void>( 1932 1932 + cfg: MethodConfigOrHandler< 1933 1933 + A, 1934 1934 + ChatBskyModerationGetActorMetadata.QueryParams, 1935 1935 + ChatBskyModerationGetActorMetadata.HandlerInput, 1936 1936 + ChatBskyModerationGetActorMetadata.HandlerOutput 1827 1937 >, 1828 1938 ) { 1829 1939 const nsid = "chat.bsky.moderation.getActorMetadata"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1830 1940 return this._server.xrpc.method(nsid, cfg); 1831 1941 } 1832 1942 1833 1833 - getMessageContext<AV extends AuthVerifier>( 1834 1834 - cfg: ConfigOf< 1835 1835 - AV, 1836 1836 - ChatBskyModerationGetMessageContext.Handler<ExtractAuth<AV>>, 1837 1837 - ChatBskyModerationGetMessageContext.HandlerReqCtx<ExtractAuth<AV>> 1943 1943 + getMessageContext<A extends Auth = void>( 1944 1944 + cfg: MethodConfigOrHandler< 1945 1945 + A, 1946 1946 + ChatBskyModerationGetMessageContext.QueryParams, 1947 1947 + ChatBskyModerationGetMessageContext.HandlerInput, 1948 1948 + ChatBskyModerationGetMessageContext.HandlerOutput 1838 1949 >, 1839 1950 ) { 1840 1951 const nsid = "chat.bsky.moderation.getMessageContext"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1841 1952 return this._server.xrpc.method(nsid, cfg); 1842 1953 } 1843 1954 1844 1844 - updateActorAccess<AV extends AuthVerifier>( 1845 1845 - cfg: ConfigOf< 1846 1846 - AV, 1847 1847 - ChatBskyModerationUpdateActorAccess.Handler<ExtractAuth<AV>>, 1848 1848 - ChatBskyModerationUpdateActorAccess.HandlerReqCtx<ExtractAuth<AV>> 1955 1955 + updateActorAccess<A extends Auth = void>( 1956 1956 + cfg: MethodConfigOrHandler< 1957 1957 + A, 1958 1958 + ChatBskyModerationUpdateActorAccess.QueryParams, 1959 1959 + ChatBskyModerationUpdateActorAccess.HandlerInput, 1960 1960 + ChatBskyModerationUpdateActorAccess.HandlerOutput 1849 1961 >, 1850 1962 ) { 1851 1963 const nsid = "chat.bsky.moderation.updateActorAccess"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1853 1965 } 1854 1966 } 1855 1967 1856 1856 - export class SoNS<T extends Env> { 1857 1857 - _server: Server<T>; 1858 1858 - sprk: SoSprkNS<T>; 1968 1968 + export class SoNS { 1969 1969 + _server: Server; 1970 1970 + sprk: SoSprkNS; 1859 1971 1860 1860 - constructor(server: Server<T>) { 1972 1972 + constructor(server: Server) { 1861 1973 this._server = server; 1862 1974 this.sprk = new SoSprkNS(server); 1863 1975 } 1864 1976 } 1865 1977 1866 1866 - export class SoSprkNS<T extends Env> { 1867 1867 - _server: Server<T>; 1868 1868 - video: SoSprkVideoNS<T>; 1869 1869 - embed: SoSprkEmbedNS<T>; 1870 1870 - notification: SoSprkNotificationNS<T>; 1871 1871 - unspecced: SoSprkUnspeccedNS<T>; 1872 1872 - graph: SoSprkGraphNS<T>; 1873 1873 - feed: SoSprkFeedNS<T>; 1874 1874 - richtext: SoSprkRichtextNS<T>; 1875 1875 - actor: SoSprkActorNS<T>; 1876 1876 - labeler: SoSprkLabelerNS<T>; 1978 1978 + export class SoSprkNS { 1979 1979 + _server: Server; 1980 1980 + video: SoSprkVideoNS; 1981 1981 + embed: SoSprkEmbedNS; 1982 1982 + notification: SoSprkNotificationNS; 1983 1983 + unspecced: SoSprkUnspeccedNS; 1984 1984 + graph: SoSprkGraphNS; 1985 1985 + feed: SoSprkFeedNS; 1986 1986 + richtext: SoSprkRichtextNS; 1987 1987 + actor: SoSprkActorNS; 1988 1988 + labeler: SoSprkLabelerNS; 1877 1989 1878 1878 - constructor(server: Server<T>) { 1990 1990 + constructor(server: Server) { 1879 1991 this._server = server; 1880 1992 this.video = new SoSprkVideoNS(server); 1881 1993 this.embed = new SoSprkEmbedNS(server); ··· 1889 2001 } 1890 2002 } 1891 2003 1892 1892 - export class SoSprkVideoNS<T extends Env> { 1893 1893 - _server: Server<T>; 2004 2004 + export class SoSprkVideoNS { 2005 2005 + _server: Server; 1894 2006 1895 1895 - constructor(server: Server<T>) { 2007 2007 + constructor(server: Server) { 1896 2008 this._server = server; 1897 2009 } 1898 2010 1899 1899 - uploadVideo<AV extends AuthVerifier>( 1900 1900 - cfg: ConfigOf< 1901 1901 - AV, 1902 1902 - SoSprkVideoUploadVideo.Handler<ExtractAuth<AV>>, 1903 1903 - SoSprkVideoUploadVideo.HandlerReqCtx<ExtractAuth<AV>> 2011 2011 + uploadVideo<A extends Auth = void>( 2012 2012 + cfg: MethodConfigOrHandler< 2013 2013 + A, 2014 2014 + SoSprkVideoUploadVideo.QueryParams, 2015 2015 + SoSprkVideoUploadVideo.HandlerInput, 2016 2016 + SoSprkVideoUploadVideo.HandlerOutput 1904 2017 >, 1905 2018 ) { 1906 2019 const nsid = "so.sprk.video.uploadVideo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1907 2020 return this._server.xrpc.method(nsid, cfg); 1908 2021 } 1909 2022 1910 1910 - getJobStatus<AV extends AuthVerifier>( 1911 1911 - cfg: ConfigOf< 1912 1912 - AV, 1913 1913 - SoSprkVideoGetJobStatus.Handler<ExtractAuth<AV>>, 1914 1914 - SoSprkVideoGetJobStatus.HandlerReqCtx<ExtractAuth<AV>> 2023 2023 + getJobStatus<A extends Auth = void>( 2024 2024 + cfg: MethodConfigOrHandler< 2025 2025 + A, 2026 2026 + SoSprkVideoGetJobStatus.QueryParams, 2027 2027 + SoSprkVideoGetJobStatus.HandlerInput, 2028 2028 + SoSprkVideoGetJobStatus.HandlerOutput 1915 2029 >, 1916 2030 ) { 1917 2031 const nsid = "so.sprk.video.getJobStatus"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1918 2032 return this._server.xrpc.method(nsid, cfg); 1919 2033 } 1920 2034 1921 1921 - getUploadLimits<AV extends AuthVerifier>( 1922 1922 - cfg: ConfigOf< 1923 1923 - AV, 1924 1924 - SoSprkVideoGetUploadLimits.Handler<ExtractAuth<AV>>, 1925 1925 - SoSprkVideoGetUploadLimits.HandlerReqCtx<ExtractAuth<AV>> 2035 2035 + getUploadLimits<A extends Auth = void>( 2036 2036 + cfg: MethodConfigOrHandler< 2037 2037 + A, 2038 2038 + SoSprkVideoGetUploadLimits.QueryParams, 2039 2039 + SoSprkVideoGetUploadLimits.HandlerInput, 2040 2040 + SoSprkVideoGetUploadLimits.HandlerOutput 1926 2041 >, 1927 2042 ) { 1928 2043 const nsid = "so.sprk.video.getUploadLimits"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 1930 2045 } 1931 2046 } 1932 2047 1933 1933 - export class SoSprkEmbedNS<T extends Env> { 1934 1934 - _server: Server<T>; 2048 2048 + export class SoSprkEmbedNS { 2049 2049 + _server: Server; 1935 2050 1936 1936 - constructor(server: Server<T>) { 2051 2051 + constructor(server: Server) { 1937 2052 this._server = server; 1938 2053 } 1939 2054 } 1940 2055 1941 1941 - export class SoSprkNotificationNS<T extends Env> { 1942 1942 - _server: Server<T>; 2056 2056 + export class SoSprkNotificationNS { 2057 2057 + _server: Server; 1943 2058 1944 1944 - constructor(server: Server<T>) { 2059 2059 + constructor(server: Server) { 1945 2060 this._server = server; 1946 2061 } 1947 2062 1948 1948 - registerPush<AV extends AuthVerifier>( 1949 1949 - cfg: ConfigOf< 1950 1950 - AV, 1951 1951 - SoSprkNotificationRegisterPush.Handler<ExtractAuth<AV>>, 1952 1952 - SoSprkNotificationRegisterPush.HandlerReqCtx<ExtractAuth<AV>> 2063 2063 + registerPush<A extends Auth = void>( 2064 2064 + cfg: MethodConfigOrHandler< 2065 2065 + A, 2066 2066 + SoSprkNotificationRegisterPush.QueryParams, 2067 2067 + SoSprkNotificationRegisterPush.HandlerInput, 2068 2068 + SoSprkNotificationRegisterPush.HandlerOutput 1953 2069 >, 1954 2070 ) { 1955 2071 const nsid = "so.sprk.notification.registerPush"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1956 2072 return this._server.xrpc.method(nsid, cfg); 1957 2073 } 1958 2074 1959 1959 - putPreferences<AV extends AuthVerifier>( 1960 1960 - cfg: ConfigOf< 1961 1961 - AV, 1962 1962 - SoSprkNotificationPutPreferences.Handler<ExtractAuth<AV>>, 1963 1963 - SoSprkNotificationPutPreferences.HandlerReqCtx<ExtractAuth<AV>> 2075 2075 + putPreferences<A extends Auth = void>( 2076 2076 + cfg: MethodConfigOrHandler< 2077 2077 + A, 2078 2078 + SoSprkNotificationPutPreferences.QueryParams, 2079 2079 + SoSprkNotificationPutPreferences.HandlerInput, 2080 2080 + SoSprkNotificationPutPreferences.HandlerOutput 1964 2081 >, 1965 2082 ) { 1966 2083 const nsid = "so.sprk.notification.putPreferences"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1967 2084 return this._server.xrpc.method(nsid, cfg); 1968 2085 } 1969 2086 1970 1970 - updateSeen<AV extends AuthVerifier>( 1971 1971 - cfg: ConfigOf< 1972 1972 - AV, 1973 1973 - SoSprkNotificationUpdateSeen.Handler<ExtractAuth<AV>>, 1974 1974 - SoSprkNotificationUpdateSeen.HandlerReqCtx<ExtractAuth<AV>> 2087 2087 + updateSeen<A extends Auth = void>( 2088 2088 + cfg: MethodConfigOrHandler< 2089 2089 + A, 2090 2090 + SoSprkNotificationUpdateSeen.QueryParams, 2091 2091 + SoSprkNotificationUpdateSeen.HandlerInput, 2092 2092 + SoSprkNotificationUpdateSeen.HandlerOutput 1975 2093 >, 1976 2094 ) { 1977 2095 const nsid = "so.sprk.notification.updateSeen"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1978 2096 return this._server.xrpc.method(nsid, cfg); 1979 2097 } 1980 2098 1981 1981 - listNotifications<AV extends AuthVerifier>( 1982 1982 - cfg: ConfigOf< 1983 1983 - AV, 1984 1984 - SoSprkNotificationListNotifications.Handler<ExtractAuth<AV>>, 1985 1985 - SoSprkNotificationListNotifications.HandlerReqCtx<ExtractAuth<AV>> 2099 2099 + listNotifications<A extends Auth = void>( 2100 2100 + cfg: MethodConfigOrHandler< 2101 2101 + A, 2102 2102 + SoSprkNotificationListNotifications.QueryParams, 2103 2103 + SoSprkNotificationListNotifications.HandlerInput, 2104 2104 + SoSprkNotificationListNotifications.HandlerOutput 1986 2105 >, 1987 2106 ) { 1988 2107 const nsid = "so.sprk.notification.listNotifications"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 1989 2108 return this._server.xrpc.method(nsid, cfg); 1990 2109 } 1991 2110 1992 1992 - getUnreadCount<AV extends AuthVerifier>( 1993 1993 - cfg: ConfigOf< 1994 1994 - AV, 1995 1995 - SoSprkNotificationGetUnreadCount.Handler<ExtractAuth<AV>>, 1996 1996 - SoSprkNotificationGetUnreadCount.HandlerReqCtx<ExtractAuth<AV>> 2111 2111 + getUnreadCount<A extends Auth = void>( 2112 2112 + cfg: MethodConfigOrHandler< 2113 2113 + A, 2114 2114 + SoSprkNotificationGetUnreadCount.QueryParams, 2115 2115 + SoSprkNotificationGetUnreadCount.HandlerInput, 2116 2116 + SoSprkNotificationGetUnreadCount.HandlerOutput 1997 2117 >, 1998 2118 ) { 1999 2119 const nsid = "so.sprk.notification.getUnreadCount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2001 2121 } 2002 2122 } 2003 2123 2004 2004 - export class SoSprkUnspeccedNS<T extends Env> { 2005 2005 - _server: Server<T>; 2124 2124 + export class SoSprkUnspeccedNS { 2125 2125 + _server: Server; 2006 2126 2007 2007 - constructor(server: Server<T>) { 2127 2127 + constructor(server: Server) { 2008 2128 this._server = server; 2009 2129 } 2010 2130 2011 2011 - searchStarterPacksSkeleton<AV extends AuthVerifier>( 2012 2012 - cfg: ConfigOf< 2013 2013 - AV, 2014 2014 - SoSprkUnspeccedSearchStarterPacksSkeleton.Handler<ExtractAuth<AV>>, 2015 2015 - SoSprkUnspeccedSearchStarterPacksSkeleton.HandlerReqCtx<ExtractAuth<AV>> 2131 2131 + searchStarterPacksSkeleton<A extends Auth = void>( 2132 2132 + cfg: MethodConfigOrHandler< 2133 2133 + A, 2134 2134 + SoSprkUnspeccedSearchStarterPacksSkeleton.QueryParams, 2135 2135 + SoSprkUnspeccedSearchStarterPacksSkeleton.HandlerInput, 2136 2136 + SoSprkUnspeccedSearchStarterPacksSkeleton.HandlerOutput 2016 2137 >, 2017 2138 ) { 2018 2139 const nsid = "so.sprk.unspecced.searchStarterPacksSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2019 2140 return this._server.xrpc.method(nsid, cfg); 2020 2141 } 2021 2142 2022 2022 - searchActorsSkeleton<AV extends AuthVerifier>( 2023 2023 - cfg: ConfigOf< 2024 2024 - AV, 2025 2025 - SoSprkUnspeccedSearchActorsSkeleton.Handler<ExtractAuth<AV>>, 2026 2026 - SoSprkUnspeccedSearchActorsSkeleton.HandlerReqCtx<ExtractAuth<AV>> 2143 2143 + searchActorsSkeleton<A extends Auth = void>( 2144 2144 + cfg: MethodConfigOrHandler< 2145 2145 + A, 2146 2146 + SoSprkUnspeccedSearchActorsSkeleton.QueryParams, 2147 2147 + SoSprkUnspeccedSearchActorsSkeleton.HandlerInput, 2148 2148 + SoSprkUnspeccedSearchActorsSkeleton.HandlerOutput 2027 2149 >, 2028 2150 ) { 2029 2151 const nsid = "so.sprk.unspecced.searchActorsSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2030 2152 return this._server.xrpc.method(nsid, cfg); 2031 2153 } 2032 2154 2033 2033 - getSuggestionsSkeleton<AV extends AuthVerifier>( 2034 2034 - cfg: ConfigOf< 2035 2035 - AV, 2036 2036 - SoSprkUnspeccedGetSuggestionsSkeleton.Handler<ExtractAuth<AV>>, 2037 2037 - SoSprkUnspeccedGetSuggestionsSkeleton.HandlerReqCtx<ExtractAuth<AV>> 2155 2155 + getSuggestionsSkeleton<A extends Auth = void>( 2156 2156 + cfg: MethodConfigOrHandler< 2157 2157 + A, 2158 2158 + SoSprkUnspeccedGetSuggestionsSkeleton.QueryParams, 2159 2159 + SoSprkUnspeccedGetSuggestionsSkeleton.HandlerInput, 2160 2160 + SoSprkUnspeccedGetSuggestionsSkeleton.HandlerOutput 2038 2161 >, 2039 2162 ) { 2040 2163 const nsid = "so.sprk.unspecced.getSuggestionsSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2041 2164 return this._server.xrpc.method(nsid, cfg); 2042 2165 } 2043 2166 2044 2044 - searchPostsSkeleton<AV extends AuthVerifier>( 2045 2045 - cfg: ConfigOf< 2046 2046 - AV, 2047 2047 - SoSprkUnspeccedSearchPostsSkeleton.Handler<ExtractAuth<AV>>, 2048 2048 - SoSprkUnspeccedSearchPostsSkeleton.HandlerReqCtx<ExtractAuth<AV>> 2167 2167 + searchPostsSkeleton<A extends Auth = void>( 2168 2168 + cfg: MethodConfigOrHandler< 2169 2169 + A, 2170 2170 + SoSprkUnspeccedSearchPostsSkeleton.QueryParams, 2171 2171 + SoSprkUnspeccedSearchPostsSkeleton.HandlerInput, 2172 2172 + SoSprkUnspeccedSearchPostsSkeleton.HandlerOutput 2049 2173 >, 2050 2174 ) { 2051 2175 const nsid = "so.sprk.unspecced.searchPostsSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2052 2176 return this._server.xrpc.method(nsid, cfg); 2053 2177 } 2054 2178 2055 2055 - getPopularFeedGenerators<AV extends AuthVerifier>( 2056 2056 - cfg: ConfigOf< 2057 2057 - AV, 2058 2058 - SoSprkUnspeccedGetPopularFeedGenerators.Handler<ExtractAuth<AV>>, 2059 2059 - SoSprkUnspeccedGetPopularFeedGenerators.HandlerReqCtx<ExtractAuth<AV>> 2179 2179 + getPopularFeedGenerators<A extends Auth = void>( 2180 2180 + cfg: MethodConfigOrHandler< 2181 2181 + A, 2182 2182 + SoSprkUnspeccedGetPopularFeedGenerators.QueryParams, 2183 2183 + SoSprkUnspeccedGetPopularFeedGenerators.HandlerInput, 2184 2184 + SoSprkUnspeccedGetPopularFeedGenerators.HandlerOutput 2060 2185 >, 2061 2186 ) { 2062 2187 const nsid = "so.sprk.unspecced.getPopularFeedGenerators"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2063 2188 return this._server.xrpc.method(nsid, cfg); 2064 2189 } 2065 2190 2066 2066 - getTrendingTopics<AV extends AuthVerifier>( 2067 2067 - cfg: ConfigOf< 2068 2068 - AV, 2069 2069 - SoSprkUnspeccedGetTrendingTopics.Handler<ExtractAuth<AV>>, 2070 2070 - SoSprkUnspeccedGetTrendingTopics.HandlerReqCtx<ExtractAuth<AV>> 2191 2191 + getTrendingTopics<A extends Auth = void>( 2192 2192 + cfg: MethodConfigOrHandler< 2193 2193 + A, 2194 2194 + SoSprkUnspeccedGetTrendingTopics.QueryParams, 2195 2195 + SoSprkUnspeccedGetTrendingTopics.HandlerInput, 2196 2196 + SoSprkUnspeccedGetTrendingTopics.HandlerOutput 2071 2197 >, 2072 2198 ) { 2073 2199 const nsid = "so.sprk.unspecced.getTrendingTopics"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2074 2200 return this._server.xrpc.method(nsid, cfg); 2075 2201 } 2076 2202 2077 2077 - getTaggedSuggestions<AV extends AuthVerifier>( 2078 2078 - cfg: ConfigOf< 2079 2079 - AV, 2080 2080 - SoSprkUnspeccedGetTaggedSuggestions.Handler<ExtractAuth<AV>>, 2081 2081 - SoSprkUnspeccedGetTaggedSuggestions.HandlerReqCtx<ExtractAuth<AV>> 2203 2203 + getTaggedSuggestions<A extends Auth = void>( 2204 2204 + cfg: MethodConfigOrHandler< 2205 2205 + A, 2206 2206 + SoSprkUnspeccedGetTaggedSuggestions.QueryParams, 2207 2207 + SoSprkUnspeccedGetTaggedSuggestions.HandlerInput, 2208 2208 + SoSprkUnspeccedGetTaggedSuggestions.HandlerOutput 2082 2209 >, 2083 2210 ) { 2084 2211 const nsid = "so.sprk.unspecced.getTaggedSuggestions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2085 2212 return this._server.xrpc.method(nsid, cfg); 2086 2213 } 2087 2214 2088 2088 - getConfig<AV extends AuthVerifier>( 2089 2089 - cfg: ConfigOf< 2090 2090 - AV, 2091 2091 - SoSprkUnspeccedGetConfig.Handler<ExtractAuth<AV>>, 2092 2092 - SoSprkUnspeccedGetConfig.HandlerReqCtx<ExtractAuth<AV>> 2215 2215 + getConfig<A extends Auth = void>( 2216 2216 + cfg: MethodConfigOrHandler< 2217 2217 + A, 2218 2218 + SoSprkUnspeccedGetConfig.QueryParams, 2219 2219 + SoSprkUnspeccedGetConfig.HandlerInput, 2220 2220 + SoSprkUnspeccedGetConfig.HandlerOutput 2093 2221 >, 2094 2222 ) { 2095 2223 const nsid = "so.sprk.unspecced.getConfig"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2097 2225 } 2098 2226 } 2099 2227 2100 2100 - export class SoSprkGraphNS<T extends Env> { 2101 2101 - _server: Server<T>; 2228 2228 + export class SoSprkGraphNS { 2229 2229 + _server: Server; 2102 2230 2103 2103 - constructor(server: Server<T>) { 2231 2231 + constructor(server: Server) { 2104 2232 this._server = server; 2105 2233 } 2106 2234 2107 2107 - getStarterPacks<AV extends AuthVerifier>( 2108 2108 - cfg: ConfigOf< 2109 2109 - AV, 2110 2110 - SoSprkGraphGetStarterPacks.Handler<ExtractAuth<AV>>, 2111 2111 - SoSprkGraphGetStarterPacks.HandlerReqCtx<ExtractAuth<AV>> 2235 2235 + getStarterPacks<A extends Auth = void>( 2236 2236 + cfg: MethodConfigOrHandler< 2237 2237 + A, 2238 2238 + SoSprkGraphGetStarterPacks.QueryParams, 2239 2239 + SoSprkGraphGetStarterPacks.HandlerInput, 2240 2240 + SoSprkGraphGetStarterPacks.HandlerOutput 2112 2241 >, 2113 2242 ) { 2114 2243 const nsid = "so.sprk.graph.getStarterPacks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2115 2244 return this._server.xrpc.method(nsid, cfg); 2116 2245 } 2117 2246 2118 2118 - getSuggestedFollowsByActor<AV extends AuthVerifier>( 2119 2119 - cfg: ConfigOf< 2120 2120 - AV, 2121 2121 - SoSprkGraphGetSuggestedFollowsByActor.Handler<ExtractAuth<AV>>, 2122 2122 - SoSprkGraphGetSuggestedFollowsByActor.HandlerReqCtx<ExtractAuth<AV>> 2247 2247 + getSuggestedFollowsByActor<A extends Auth = void>( 2248 2248 + cfg: MethodConfigOrHandler< 2249 2249 + A, 2250 2250 + SoSprkGraphGetSuggestedFollowsByActor.QueryParams, 2251 2251 + SoSprkGraphGetSuggestedFollowsByActor.HandlerInput, 2252 2252 + SoSprkGraphGetSuggestedFollowsByActor.HandlerOutput 2123 2253 >, 2124 2254 ) { 2125 2255 const nsid = "so.sprk.graph.getSuggestedFollowsByActor"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2126 2256 return this._server.xrpc.method(nsid, cfg); 2127 2257 } 2128 2258 2129 2129 - unmuteActorList<AV extends AuthVerifier>( 2130 2130 - cfg: ConfigOf< 2131 2131 - AV, 2132 2132 - SoSprkGraphUnmuteActorList.Handler<ExtractAuth<AV>>, 2133 2133 - SoSprkGraphUnmuteActorList.HandlerReqCtx<ExtractAuth<AV>> 2259 2259 + unmuteActorList<A extends Auth = void>( 2260 2260 + cfg: MethodConfigOrHandler< 2261 2261 + A, 2262 2262 + SoSprkGraphUnmuteActorList.QueryParams, 2263 2263 + SoSprkGraphUnmuteActorList.HandlerInput, 2264 2264 + SoSprkGraphUnmuteActorList.HandlerOutput 2134 2265 >, 2135 2266 ) { 2136 2267 const nsid = "so.sprk.graph.unmuteActorList"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2137 2268 return this._server.xrpc.method(nsid, cfg); 2138 2269 } 2139 2270 2140 2140 - getListBlocks<AV extends AuthVerifier>( 2141 2141 - cfg: ConfigOf< 2142 2142 - AV, 2143 2143 - SoSprkGraphGetListBlocks.Handler<ExtractAuth<AV>>, 2144 2144 - SoSprkGraphGetListBlocks.HandlerReqCtx<ExtractAuth<AV>> 2271 2271 + getListBlocks<A extends Auth = void>( 2272 2272 + cfg: MethodConfigOrHandler< 2273 2273 + A, 2274 2274 + SoSprkGraphGetListBlocks.QueryParams, 2275 2275 + SoSprkGraphGetListBlocks.HandlerInput, 2276 2276 + SoSprkGraphGetListBlocks.HandlerOutput 2145 2277 >, 2146 2278 ) { 2147 2279 const nsid = "so.sprk.graph.getListBlocks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2148 2280 return this._server.xrpc.method(nsid, cfg); 2149 2281 } 2150 2282 2151 2151 - getStarterPack<AV extends AuthVerifier>( 2152 2152 - cfg: ConfigOf< 2153 2153 - AV, 2154 2154 - SoSprkGraphGetStarterPack.Handler<ExtractAuth<AV>>, 2155 2155 - SoSprkGraphGetStarterPack.HandlerReqCtx<ExtractAuth<AV>> 2283 2283 + getStarterPack<A extends Auth = void>( 2284 2284 + cfg: MethodConfigOrHandler< 2285 2285 + A, 2286 2286 + SoSprkGraphGetStarterPack.QueryParams, 2287 2287 + SoSprkGraphGetStarterPack.HandlerInput, 2288 2288 + SoSprkGraphGetStarterPack.HandlerOutput 2156 2289 >, 2157 2290 ) { 2158 2291 const nsid = "so.sprk.graph.getStarterPack"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2159 2292 return this._server.xrpc.method(nsid, cfg); 2160 2293 } 2161 2294 2162 2162 - muteActorList<AV extends AuthVerifier>( 2163 2163 - cfg: ConfigOf< 2164 2164 - AV, 2165 2165 - SoSprkGraphMuteActorList.Handler<ExtractAuth<AV>>, 2166 2166 - SoSprkGraphMuteActorList.HandlerReqCtx<ExtractAuth<AV>> 2295 2295 + muteActorList<A extends Auth = void>( 2296 2296 + cfg: MethodConfigOrHandler< 2297 2297 + A, 2298 2298 + SoSprkGraphMuteActorList.QueryParams, 2299 2299 + SoSprkGraphMuteActorList.HandlerInput, 2300 2300 + SoSprkGraphMuteActorList.HandlerOutput 2167 2301 >, 2168 2302 ) { 2169 2303 const nsid = "so.sprk.graph.muteActorList"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2170 2304 return this._server.xrpc.method(nsid, cfg); 2171 2305 } 2172 2306 2173 2173 - muteThread<AV extends AuthVerifier>( 2174 2174 - cfg: ConfigOf< 2175 2175 - AV, 2176 2176 - SoSprkGraphMuteThread.Handler<ExtractAuth<AV>>, 2177 2177 - SoSprkGraphMuteThread.HandlerReqCtx<ExtractAuth<AV>> 2307 2307 + muteThread<A extends Auth = void>( 2308 2308 + cfg: MethodConfigOrHandler< 2309 2309 + A, 2310 2310 + SoSprkGraphMuteThread.QueryParams, 2311 2311 + SoSprkGraphMuteThread.HandlerInput, 2312 2312 + SoSprkGraphMuteThread.HandlerOutput 2178 2313 >, 2179 2314 ) { 2180 2315 const nsid = "so.sprk.graph.muteThread"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2181 2316 return this._server.xrpc.method(nsid, cfg); 2182 2317 } 2183 2318 2184 2184 - searchStarterPacks<AV extends AuthVerifier>( 2185 2185 - cfg: ConfigOf< 2186 2186 - AV, 2187 2187 - SoSprkGraphSearchStarterPacks.Handler<ExtractAuth<AV>>, 2188 2188 - SoSprkGraphSearchStarterPacks.HandlerReqCtx<ExtractAuth<AV>> 2319 2319 + searchStarterPacks<A extends Auth = void>( 2320 2320 + cfg: MethodConfigOrHandler< 2321 2321 + A, 2322 2322 + SoSprkGraphSearchStarterPacks.QueryParams, 2323 2323 + SoSprkGraphSearchStarterPacks.HandlerInput, 2324 2324 + SoSprkGraphSearchStarterPacks.HandlerOutput 2189 2325 >, 2190 2326 ) { 2191 2327 const nsid = "so.sprk.graph.searchStarterPacks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2192 2328 return this._server.xrpc.method(nsid, cfg); 2193 2329 } 2194 2330 2195 2195 - getActorStarterPacks<AV extends AuthVerifier>( 2196 2196 - cfg: ConfigOf< 2197 2197 - AV, 2198 2198 - SoSprkGraphGetActorStarterPacks.Handler<ExtractAuth<AV>>, 2199 2199 - SoSprkGraphGetActorStarterPacks.HandlerReqCtx<ExtractAuth<AV>> 2331 2331 + getActorStarterPacks<A extends Auth = void>( 2332 2332 + cfg: MethodConfigOrHandler< 2333 2333 + A, 2334 2334 + SoSprkGraphGetActorStarterPacks.QueryParams, 2335 2335 + SoSprkGraphGetActorStarterPacks.HandlerInput, 2336 2336 + SoSprkGraphGetActorStarterPacks.HandlerOutput 2200 2337 >, 2201 2338 ) { 2202 2339 const nsid = "so.sprk.graph.getActorStarterPacks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2203 2340 return this._server.xrpc.method(nsid, cfg); 2204 2341 } 2205 2342 2206 2206 - getLists<AV extends AuthVerifier>( 2207 2207 - cfg: ConfigOf< 2208 2208 - AV, 2209 2209 - SoSprkGraphGetLists.Handler<ExtractAuth<AV>>, 2210 2210 - SoSprkGraphGetLists.HandlerReqCtx<ExtractAuth<AV>> 2343 2343 + getLists<A extends Auth = void>( 2344 2344 + cfg: MethodConfigOrHandler< 2345 2345 + A, 2346 2346 + SoSprkGraphGetLists.QueryParams, 2347 2347 + SoSprkGraphGetLists.HandlerInput, 2348 2348 + SoSprkGraphGetLists.HandlerOutput 2211 2349 >, 2212 2350 ) { 2213 2351 const nsid = "so.sprk.graph.getLists"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2214 2352 return this._server.xrpc.method(nsid, cfg); 2215 2353 } 2216 2354 2217 2217 - getFollowers<AV extends AuthVerifier>( 2218 2218 - cfg: ConfigOf< 2219 2219 - AV, 2220 2220 - SoSprkGraphGetFollowers.Handler<ExtractAuth<AV>>, 2221 2221 - SoSprkGraphGetFollowers.HandlerReqCtx<ExtractAuth<AV>> 2355 2355 + getFollowers<A extends Auth = void>( 2356 2356 + cfg: MethodConfigOrHandler< 2357 2357 + A, 2358 2358 + SoSprkGraphGetFollowers.QueryParams, 2359 2359 + SoSprkGraphGetFollowers.HandlerInput, 2360 2360 + SoSprkGraphGetFollowers.HandlerOutput 2222 2361 >, 2223 2362 ) { 2224 2363 const nsid = "so.sprk.graph.getFollowers"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2225 2364 return this._server.xrpc.method(nsid, cfg); 2226 2365 } 2227 2366 2228 2228 - unmuteThread<AV extends AuthVerifier>( 2229 2229 - cfg: ConfigOf< 2230 2230 - AV, 2231 2231 - SoSprkGraphUnmuteThread.Handler<ExtractAuth<AV>>, 2232 2232 - SoSprkGraphUnmuteThread.HandlerReqCtx<ExtractAuth<AV>> 2367 2367 + unmuteThread<A extends Auth = void>( 2368 2368 + cfg: MethodConfigOrHandler< 2369 2369 + A, 2370 2370 + SoSprkGraphUnmuteThread.QueryParams, 2371 2371 + SoSprkGraphUnmuteThread.HandlerInput, 2372 2372 + SoSprkGraphUnmuteThread.HandlerOutput 2233 2373 >, 2234 2374 ) { 2235 2375 const nsid = "so.sprk.graph.unmuteThread"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2236 2376 return this._server.xrpc.method(nsid, cfg); 2237 2377 } 2238 2378 2239 2239 - muteActor<AV extends AuthVerifier>( 2240 2240 - cfg: ConfigOf< 2241 2241 - AV, 2242 2242 - SoSprkGraphMuteActor.Handler<ExtractAuth<AV>>, 2243 2243 - SoSprkGraphMuteActor.HandlerReqCtx<ExtractAuth<AV>> 2379 2379 + muteActor<A extends Auth = void>( 2380 2380 + cfg: MethodConfigOrHandler< 2381 2381 + A, 2382 2382 + SoSprkGraphMuteActor.QueryParams, 2383 2383 + SoSprkGraphMuteActor.HandlerInput, 2384 2384 + SoSprkGraphMuteActor.HandlerOutput 2244 2385 >, 2245 2386 ) { 2246 2387 const nsid = "so.sprk.graph.muteActor"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2247 2388 return this._server.xrpc.method(nsid, cfg); 2248 2389 } 2249 2390 2250 2250 - getMutes<AV extends AuthVerifier>( 2251 2251 - cfg: ConfigOf< 2252 2252 - AV, 2253 2253 - SoSprkGraphGetMutes.Handler<ExtractAuth<AV>>, 2254 2254 - SoSprkGraphGetMutes.HandlerReqCtx<ExtractAuth<AV>> 2391 2391 + getMutes<A extends Auth = void>( 2392 2392 + cfg: MethodConfigOrHandler< 2393 2393 + A, 2394 2394 + SoSprkGraphGetMutes.QueryParams, 2395 2395 + SoSprkGraphGetMutes.HandlerInput, 2396 2396 + SoSprkGraphGetMutes.HandlerOutput 2255 2397 >, 2256 2398 ) { 2257 2399 const nsid = "so.sprk.graph.getMutes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2258 2400 return this._server.xrpc.method(nsid, cfg); 2259 2401 } 2260 2402 2261 2261 - getKnownFollowers<AV extends AuthVerifier>( 2262 2262 - cfg: ConfigOf< 2263 2263 - AV, 2264 2264 - SoSprkGraphGetKnownFollowers.Handler<ExtractAuth<AV>>, 2265 2265 - SoSprkGraphGetKnownFollowers.HandlerReqCtx<ExtractAuth<AV>> 2403 2403 + getKnownFollowers<A extends Auth = void>( 2404 2404 + cfg: MethodConfigOrHandler< 2405 2405 + A, 2406 2406 + SoSprkGraphGetKnownFollowers.QueryParams, 2407 2407 + SoSprkGraphGetKnownFollowers.HandlerInput, 2408 2408 + SoSprkGraphGetKnownFollowers.HandlerOutput 2266 2409 >, 2267 2410 ) { 2268 2411 const nsid = "so.sprk.graph.getKnownFollowers"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2269 2412 return this._server.xrpc.method(nsid, cfg); 2270 2413 } 2271 2414 2272 2272 - getListMutes<AV extends AuthVerifier>( 2273 2273 - cfg: ConfigOf< 2274 2274 - AV, 2275 2275 - SoSprkGraphGetListMutes.Handler<ExtractAuth<AV>>, 2276 2276 - SoSprkGraphGetListMutes.HandlerReqCtx<ExtractAuth<AV>> 2415 2415 + getListMutes<A extends Auth = void>( 2416 2416 + cfg: MethodConfigOrHandler< 2417 2417 + A, 2418 2418 + SoSprkGraphGetListMutes.QueryParams, 2419 2419 + SoSprkGraphGetListMutes.HandlerInput, 2420 2420 + SoSprkGraphGetListMutes.HandlerOutput 2277 2421 >, 2278 2422 ) { 2279 2423 const nsid = "so.sprk.graph.getListMutes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2280 2424 return this._server.xrpc.method(nsid, cfg); 2281 2425 } 2282 2426 2283 2283 - getFollows<AV extends AuthVerifier>( 2284 2284 - cfg: ConfigOf< 2285 2285 - AV, 2286 2286 - SoSprkGraphGetFollows.Handler<ExtractAuth<AV>>, 2287 2287 - SoSprkGraphGetFollows.HandlerReqCtx<ExtractAuth<AV>> 2427 2427 + getFollows<A extends Auth = void>( 2428 2428 + cfg: MethodConfigOrHandler< 2429 2429 + A, 2430 2430 + SoSprkGraphGetFollows.QueryParams, 2431 2431 + SoSprkGraphGetFollows.HandlerInput, 2432 2432 + SoSprkGraphGetFollows.HandlerOutput 2288 2433 >, 2289 2434 ) { 2290 2435 const nsid = "so.sprk.graph.getFollows"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2291 2436 return this._server.xrpc.method(nsid, cfg); 2292 2437 } 2293 2438 2294 2294 - getBlocks<AV extends AuthVerifier>( 2295 2295 - cfg: ConfigOf< 2296 2296 - AV, 2297 2297 - SoSprkGraphGetBlocks.Handler<ExtractAuth<AV>>, 2298 2298 - SoSprkGraphGetBlocks.HandlerReqCtx<ExtractAuth<AV>> 2439 2439 + getBlocks<A extends Auth = void>( 2440 2440 + cfg: MethodConfigOrHandler< 2441 2441 + A, 2442 2442 + SoSprkGraphGetBlocks.QueryParams, 2443 2443 + SoSprkGraphGetBlocks.HandlerInput, 2444 2444 + SoSprkGraphGetBlocks.HandlerOutput 2299 2445 >, 2300 2446 ) { 2301 2447 const nsid = "so.sprk.graph.getBlocks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2302 2448 return this._server.xrpc.method(nsid, cfg); 2303 2449 } 2304 2450 2305 2305 - getRelationships<AV extends AuthVerifier>( 2306 2306 - cfg: ConfigOf< 2307 2307 - AV, 2308 2308 - SoSprkGraphGetRelationships.Handler<ExtractAuth<AV>>, 2309 2309 - SoSprkGraphGetRelationships.HandlerReqCtx<ExtractAuth<AV>> 2451 2451 + getRelationships<A extends Auth = void>( 2452 2452 + cfg: MethodConfigOrHandler< 2453 2453 + A, 2454 2454 + SoSprkGraphGetRelationships.QueryParams, 2455 2455 + SoSprkGraphGetRelationships.HandlerInput, 2456 2456 + SoSprkGraphGetRelationships.HandlerOutput 2310 2457 >, 2311 2458 ) { 2312 2459 const nsid = "so.sprk.graph.getRelationships"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2313 2460 return this._server.xrpc.method(nsid, cfg); 2314 2461 } 2315 2462 2316 2316 - unmuteActor<AV extends AuthVerifier>( 2317 2317 - cfg: ConfigOf< 2318 2318 - AV, 2319 2319 - SoSprkGraphUnmuteActor.Handler<ExtractAuth<AV>>, 2320 2320 - SoSprkGraphUnmuteActor.HandlerReqCtx<ExtractAuth<AV>> 2463 2463 + unmuteActor<A extends Auth = void>( 2464 2464 + cfg: MethodConfigOrHandler< 2465 2465 + A, 2466 2466 + SoSprkGraphUnmuteActor.QueryParams, 2467 2467 + SoSprkGraphUnmuteActor.HandlerInput, 2468 2468 + SoSprkGraphUnmuteActor.HandlerOutput 2321 2469 >, 2322 2470 ) { 2323 2471 const nsid = "so.sprk.graph.unmuteActor"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2324 2472 return this._server.xrpc.method(nsid, cfg); 2325 2473 } 2326 2474 2327 2327 - getList<AV extends AuthVerifier>( 2328 2328 - cfg: ConfigOf< 2329 2329 - AV, 2330 2330 - SoSprkGraphGetList.Handler<ExtractAuth<AV>>, 2331 2331 - SoSprkGraphGetList.HandlerReqCtx<ExtractAuth<AV>> 2475 2475 + getList<A extends Auth = void>( 2476 2476 + cfg: MethodConfigOrHandler< 2477 2477 + A, 2478 2478 + SoSprkGraphGetList.QueryParams, 2479 2479 + SoSprkGraphGetList.HandlerInput, 2480 2480 + SoSprkGraphGetList.HandlerOutput 2332 2481 >, 2333 2482 ) { 2334 2483 const nsid = "so.sprk.graph.getList"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2336 2485 } 2337 2486 } 2338 2487 2339 2339 - export class SoSprkFeedNS<T extends Env> { 2340 2340 - _server: Server<T>; 2488 2488 + export class SoSprkFeedNS { 2489 2489 + _server: Server; 2341 2490 2342 2342 - constructor(server: Server<T>) { 2491 2491 + constructor(server: Server) { 2343 2492 this._server = server; 2344 2493 } 2345 2494 2346 2346 - sendInteractions<AV extends AuthVerifier>( 2347 2347 - cfg: ConfigOf< 2348 2348 - AV, 2349 2349 - SoSprkFeedSendInteractions.Handler<ExtractAuth<AV>>, 2350 2350 - SoSprkFeedSendInteractions.HandlerReqCtx<ExtractAuth<AV>> 2495 2495 + sendInteractions<A extends Auth = void>( 2496 2496 + cfg: MethodConfigOrHandler< 2497 2497 + A, 2498 2498 + SoSprkFeedSendInteractions.QueryParams, 2499 2499 + SoSprkFeedSendInteractions.HandlerInput, 2500 2500 + SoSprkFeedSendInteractions.HandlerOutput 2351 2501 >, 2352 2502 ) { 2353 2503 const nsid = "so.sprk.feed.sendInteractions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2354 2504 return this._server.xrpc.method(nsid, cfg); 2355 2505 } 2356 2506 2357 2357 - getFeedGenerators<AV extends AuthVerifier>( 2358 2358 - cfg: ConfigOf< 2359 2359 - AV, 2360 2360 - SoSprkFeedGetFeedGenerators.Handler<ExtractAuth<AV>>, 2361 2361 - SoSprkFeedGetFeedGenerators.HandlerReqCtx<ExtractAuth<AV>> 2507 2507 + getFeedGenerators<A extends Auth = void>( 2508 2508 + cfg: MethodConfigOrHandler< 2509 2509 + A, 2510 2510 + SoSprkFeedGetFeedGenerators.QueryParams, 2511 2511 + SoSprkFeedGetFeedGenerators.HandlerInput, 2512 2512 + SoSprkFeedGetFeedGenerators.HandlerOutput 2362 2513 >, 2363 2514 ) { 2364 2515 const nsid = "so.sprk.feed.getFeedGenerators"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2365 2516 return this._server.xrpc.method(nsid, cfg); 2366 2517 } 2367 2518 2368 2368 - getTimeline<AV extends AuthVerifier>( 2369 2369 - cfg: ConfigOf< 2370 2370 - AV, 2371 2371 - SoSprkFeedGetTimeline.Handler<ExtractAuth<AV>>, 2372 2372 - SoSprkFeedGetTimeline.HandlerReqCtx<ExtractAuth<AV>> 2519 2519 + getTimeline<A extends Auth = void>( 2520 2520 + cfg: MethodConfigOrHandler< 2521 2521 + A, 2522 2522 + SoSprkFeedGetTimeline.QueryParams, 2523 2523 + SoSprkFeedGetTimeline.HandlerInput, 2524 2524 + SoSprkFeedGetTimeline.HandlerOutput 2373 2525 >, 2374 2526 ) { 2375 2527 const nsid = "so.sprk.feed.getTimeline"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2376 2528 return this._server.xrpc.method(nsid, cfg); 2377 2529 } 2378 2530 2379 2379 - getFeedGenerator<AV extends AuthVerifier>( 2380 2380 - cfg: ConfigOf< 2381 2381 - AV, 2382 2382 - SoSprkFeedGetFeedGenerator.Handler<ExtractAuth<AV>>, 2383 2383 - SoSprkFeedGetFeedGenerator.HandlerReqCtx<ExtractAuth<AV>> 2531 2531 + getFeedGenerator<A extends Auth = void>( 2532 2532 + cfg: MethodConfigOrHandler< 2533 2533 + A, 2534 2534 + SoSprkFeedGetFeedGenerator.QueryParams, 2535 2535 + SoSprkFeedGetFeedGenerator.HandlerInput, 2536 2536 + SoSprkFeedGetFeedGenerator.HandlerOutput 2384 2537 >, 2385 2538 ) { 2386 2539 const nsid = "so.sprk.feed.getFeedGenerator"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2387 2540 return this._server.xrpc.method(nsid, cfg); 2388 2541 } 2389 2542 2390 2390 - getAuthorFeed<AV extends AuthVerifier>( 2391 2391 - cfg: ConfigOf< 2392 2392 - AV, 2393 2393 - SoSprkFeedGetAuthorFeed.Handler<ExtractAuth<AV>>, 2394 2394 - SoSprkFeedGetAuthorFeed.HandlerReqCtx<ExtractAuth<AV>> 2543 2543 + getAuthorFeed<A extends Auth = void>( 2544 2544 + cfg: MethodConfigOrHandler< 2545 2545 + A, 2546 2546 + SoSprkFeedGetAuthorFeed.QueryParams, 2547 2547 + SoSprkFeedGetAuthorFeed.HandlerInput, 2548 2548 + SoSprkFeedGetAuthorFeed.HandlerOutput 2395 2549 >, 2396 2550 ) { 2397 2551 const nsid = "so.sprk.feed.getAuthorFeed"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2398 2552 return this._server.xrpc.method(nsid, cfg); 2399 2553 } 2400 2554 2401 2401 - getLikes<AV extends AuthVerifier>( 2402 2402 - cfg: ConfigOf< 2403 2403 - AV, 2404 2404 - SoSprkFeedGetLikes.Handler<ExtractAuth<AV>>, 2405 2405 - SoSprkFeedGetLikes.HandlerReqCtx<ExtractAuth<AV>> 2555 2555 + getLikes<A extends Auth = void>( 2556 2556 + cfg: MethodConfigOrHandler< 2557 2557 + A, 2558 2558 + SoSprkFeedGetLikes.QueryParams, 2559 2559 + SoSprkFeedGetLikes.HandlerInput, 2560 2560 + SoSprkFeedGetLikes.HandlerOutput 2406 2561 >, 2407 2562 ) { 2408 2563 const nsid = "so.sprk.feed.getLikes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2409 2564 return this._server.xrpc.method(nsid, cfg); 2410 2565 } 2411 2566 2412 2412 - getActorLooks<AV extends AuthVerifier>( 2413 2413 - cfg: ConfigOf< 2414 2414 - AV, 2415 2415 - SoSprkFeedGetActorLooks.Handler<ExtractAuth<AV>>, 2416 2416 - SoSprkFeedGetActorLooks.HandlerReqCtx<ExtractAuth<AV>> 2567 2567 + getActorLooks<A extends Auth = void>( 2568 2568 + cfg: MethodConfigOrHandler< 2569 2569 + A, 2570 2570 + SoSprkFeedGetActorLooks.QueryParams, 2571 2571 + SoSprkFeedGetActorLooks.HandlerInput, 2572 2572 + SoSprkFeedGetActorLooks.HandlerOutput 2417 2573 >, 2418 2574 ) { 2419 2575 const nsid = "so.sprk.feed.getActorLooks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2420 2576 return this._server.xrpc.method(nsid, cfg); 2421 2577 } 2422 2578 2423 2423 - getPostThread<AV extends AuthVerifier>( 2424 2424 - cfg: ConfigOf< 2425 2425 - AV, 2426 2426 - SoSprkFeedGetPostThread.Handler<ExtractAuth<AV>>, 2427 2427 - SoSprkFeedGetPostThread.HandlerReqCtx<ExtractAuth<AV>> 2579 2579 + getPostThread<A extends Auth = void>( 2580 2580 + cfg: MethodConfigOrHandler< 2581 2581 + A, 2582 2582 + SoSprkFeedGetPostThread.QueryParams, 2583 2583 + SoSprkFeedGetPostThread.HandlerInput, 2584 2584 + SoSprkFeedGetPostThread.HandlerOutput 2428 2585 >, 2429 2586 ) { 2430 2587 const nsid = "so.sprk.feed.getPostThread"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2431 2588 return this._server.xrpc.method(nsid, cfg); 2432 2589 } 2433 2590 2434 2434 - getLooks<AV extends AuthVerifier>( 2435 2435 - cfg: ConfigOf< 2436 2436 - AV, 2437 2437 - SoSprkFeedGetLooks.Handler<ExtractAuth<AV>>, 2438 2438 - SoSprkFeedGetLooks.HandlerReqCtx<ExtractAuth<AV>> 2591 2591 + getLooks<A extends Auth = void>( 2592 2592 + cfg: MethodConfigOrHandler< 2593 2593 + A, 2594 2594 + SoSprkFeedGetLooks.QueryParams, 2595 2595 + SoSprkFeedGetLooks.HandlerInput, 2596 2596 + SoSprkFeedGetLooks.HandlerOutput 2439 2597 >, 2440 2598 ) { 2441 2599 const nsid = "so.sprk.feed.getLooks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2442 2600 return this._server.xrpc.method(nsid, cfg); 2443 2601 } 2444 2602 2445 2445 - getActorLikes<AV extends AuthVerifier>( 2446 2446 - cfg: ConfigOf< 2447 2447 - AV, 2448 2448 - SoSprkFeedGetActorLikes.Handler<ExtractAuth<AV>>, 2449 2449 - SoSprkFeedGetActorLikes.HandlerReqCtx<ExtractAuth<AV>> 2603 2603 + getActorLikes<A extends Auth = void>( 2604 2604 + cfg: MethodConfigOrHandler< 2605 2605 + A, 2606 2606 + SoSprkFeedGetActorLikes.QueryParams, 2607 2607 + SoSprkFeedGetActorLikes.HandlerInput, 2608 2608 + SoSprkFeedGetActorLikes.HandlerOutput 2450 2609 >, 2451 2610 ) { 2452 2611 const nsid = "so.sprk.feed.getActorLikes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2453 2612 return this._server.xrpc.method(nsid, cfg); 2454 2613 } 2455 2614 2456 2456 - getRepostedBy<AV extends AuthVerifier>( 2457 2457 - cfg: ConfigOf< 2458 2458 - AV, 2459 2459 - SoSprkFeedGetRepostedBy.Handler<ExtractAuth<AV>>, 2460 2460 - SoSprkFeedGetRepostedBy.HandlerReqCtx<ExtractAuth<AV>> 2615 2615 + getRepostedBy<A extends Auth = void>( 2616 2616 + cfg: MethodConfigOrHandler< 2617 2617 + A, 2618 2618 + SoSprkFeedGetRepostedBy.QueryParams, 2619 2619 + SoSprkFeedGetRepostedBy.HandlerInput, 2620 2620 + SoSprkFeedGetRepostedBy.HandlerOutput 2461 2621 >, 2462 2622 ) { 2463 2623 const nsid = "so.sprk.feed.getRepostedBy"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2464 2624 return this._server.xrpc.method(nsid, cfg); 2465 2625 } 2466 2626 2467 2467 - describeFeedGenerator<AV extends AuthVerifier>( 2468 2468 - cfg: ConfigOf< 2469 2469 - AV, 2470 2470 - SoSprkFeedDescribeFeedGenerator.Handler<ExtractAuth<AV>>, 2471 2471 - SoSprkFeedDescribeFeedGenerator.HandlerReqCtx<ExtractAuth<AV>> 2627 2627 + describeFeedGenerator<A extends Auth = void>( 2628 2628 + cfg: MethodConfigOrHandler< 2629 2629 + A, 2630 2630 + SoSprkFeedDescribeFeedGenerator.QueryParams, 2631 2631 + SoSprkFeedDescribeFeedGenerator.HandlerInput, 2632 2632 + SoSprkFeedDescribeFeedGenerator.HandlerOutput 2472 2633 >, 2473 2634 ) { 2474 2635 const nsid = "so.sprk.feed.describeFeedGenerator"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2475 2636 return this._server.xrpc.method(nsid, cfg); 2476 2637 } 2477 2638 2478 2478 - searchPosts<AV extends AuthVerifier>( 2479 2479 - cfg: ConfigOf< 2480 2480 - AV, 2481 2481 - SoSprkFeedSearchPosts.Handler<ExtractAuth<AV>>, 2482 2482 - SoSprkFeedSearchPosts.HandlerReqCtx<ExtractAuth<AV>> 2639 2639 + searchPosts<A extends Auth = void>( 2640 2640 + cfg: MethodConfigOrHandler< 2641 2641 + A, 2642 2642 + SoSprkFeedSearchPosts.QueryParams, 2643 2643 + SoSprkFeedSearchPosts.HandlerInput, 2644 2644 + SoSprkFeedSearchPosts.HandlerOutput 2483 2645 >, 2484 2646 ) { 2485 2647 const nsid = "so.sprk.feed.searchPosts"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2486 2648 return this._server.xrpc.method(nsid, cfg); 2487 2649 } 2488 2650 2489 2489 - getPosts<AV extends AuthVerifier>( 2490 2490 - cfg: ConfigOf< 2491 2491 - AV, 2492 2492 - SoSprkFeedGetPosts.Handler<ExtractAuth<AV>>, 2493 2493 - SoSprkFeedGetPosts.HandlerReqCtx<ExtractAuth<AV>> 2651 2651 + getPosts<A extends Auth = void>( 2652 2652 + cfg: MethodConfigOrHandler< 2653 2653 + A, 2654 2654 + SoSprkFeedGetPosts.QueryParams, 2655 2655 + SoSprkFeedGetPosts.HandlerInput, 2656 2656 + SoSprkFeedGetPosts.HandlerOutput 2494 2657 >, 2495 2658 ) { 2496 2659 const nsid = "so.sprk.feed.getPosts"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2497 2660 return this._server.xrpc.method(nsid, cfg); 2498 2661 } 2499 2662 2500 2500 - getFeed<AV extends AuthVerifier>( 2501 2501 - cfg: ConfigOf< 2502 2502 - AV, 2503 2503 - SoSprkFeedGetFeed.Handler<ExtractAuth<AV>>, 2504 2504 - SoSprkFeedGetFeed.HandlerReqCtx<ExtractAuth<AV>> 2663 2663 + getFeed<A extends Auth = void>( 2664 2664 + cfg: MethodConfigOrHandler< 2665 2665 + A, 2666 2666 + SoSprkFeedGetFeed.QueryParams, 2667 2667 + SoSprkFeedGetFeed.HandlerInput, 2668 2668 + SoSprkFeedGetFeed.HandlerOutput 2505 2669 >, 2506 2670 ) { 2507 2671 const nsid = "so.sprk.feed.getFeed"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2508 2672 return this._server.xrpc.method(nsid, cfg); 2509 2673 } 2510 2674 2511 2511 - getStories<AV extends AuthVerifier>( 2512 2512 - cfg: ConfigOf< 2513 2513 - AV, 2514 2514 - SoSprkFeedGetStories.Handler<ExtractAuth<AV>>, 2515 2515 - SoSprkFeedGetStories.HandlerReqCtx<ExtractAuth<AV>> 2675 2675 + getStories<A extends Auth = void>( 2676 2676 + cfg: MethodConfigOrHandler< 2677 2677 + A, 2678 2678 + SoSprkFeedGetStories.QueryParams, 2679 2679 + SoSprkFeedGetStories.HandlerInput, 2680 2680 + SoSprkFeedGetStories.HandlerOutput 2516 2681 >, 2517 2682 ) { 2518 2683 const nsid = "so.sprk.feed.getStories"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2519 2684 return this._server.xrpc.method(nsid, cfg); 2520 2685 } 2521 2686 2522 2522 - getQuotes<AV extends AuthVerifier>( 2523 2523 - cfg: ConfigOf< 2524 2524 - AV, 2525 2525 - SoSprkFeedGetQuotes.Handler<ExtractAuth<AV>>, 2526 2526 - SoSprkFeedGetQuotes.HandlerReqCtx<ExtractAuth<AV>> 2687 2687 + getQuotes<A extends Auth = void>( 2688 2688 + cfg: MethodConfigOrHandler< 2689 2689 + A, 2690 2690 + SoSprkFeedGetQuotes.QueryParams, 2691 2691 + SoSprkFeedGetQuotes.HandlerInput, 2692 2692 + SoSprkFeedGetQuotes.HandlerOutput 2527 2693 >, 2528 2694 ) { 2529 2695 const nsid = "so.sprk.feed.getQuotes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2530 2696 return this._server.xrpc.method(nsid, cfg); 2531 2697 } 2532 2698 2533 2533 - getStoriesTimeline<AV extends AuthVerifier>( 2534 2534 - cfg: ConfigOf< 2535 2535 - AV, 2536 2536 - SoSprkFeedGetStoriesTimeline.Handler<ExtractAuth<AV>>, 2537 2537 - SoSprkFeedGetStoriesTimeline.HandlerReqCtx<ExtractAuth<AV>> 2699 2699 + getStoriesTimeline<A extends Auth = void>( 2700 2700 + cfg: MethodConfigOrHandler< 2701 2701 + A, 2702 2702 + SoSprkFeedGetStoriesTimeline.QueryParams, 2703 2703 + SoSprkFeedGetStoriesTimeline.HandlerInput, 2704 2704 + SoSprkFeedGetStoriesTimeline.HandlerOutput 2538 2705 >, 2539 2706 ) { 2540 2707 const nsid = "so.sprk.feed.getStoriesTimeline"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2541 2708 return this._server.xrpc.method(nsid, cfg); 2542 2709 } 2543 2710 2544 2544 - getFeedSkeleton<AV extends AuthVerifier>( 2545 2545 - cfg: ConfigOf< 2546 2546 - AV, 2547 2547 - SoSprkFeedGetFeedSkeleton.Handler<ExtractAuth<AV>>, 2548 2548 - SoSprkFeedGetFeedSkeleton.HandlerReqCtx<ExtractAuth<AV>> 2711 2711 + getFeedSkeleton<A extends Auth = void>( 2712 2712 + cfg: MethodConfigOrHandler< 2713 2713 + A, 2714 2714 + SoSprkFeedGetFeedSkeleton.QueryParams, 2715 2715 + SoSprkFeedGetFeedSkeleton.HandlerInput, 2716 2716 + SoSprkFeedGetFeedSkeleton.HandlerOutput 2549 2717 >, 2550 2718 ) { 2551 2719 const nsid = "so.sprk.feed.getFeedSkeleton"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2552 2720 return this._server.xrpc.method(nsid, cfg); 2553 2721 } 2554 2722 2555 2555 - getListFeed<AV extends AuthVerifier>( 2556 2556 - cfg: ConfigOf< 2557 2557 - AV, 2558 2558 - SoSprkFeedGetListFeed.Handler<ExtractAuth<AV>>, 2559 2559 - SoSprkFeedGetListFeed.HandlerReqCtx<ExtractAuth<AV>> 2723 2723 + getListFeed<A extends Auth = void>( 2724 2724 + cfg: MethodConfigOrHandler< 2725 2725 + A, 2726 2726 + SoSprkFeedGetListFeed.QueryParams, 2727 2727 + SoSprkFeedGetListFeed.HandlerInput, 2728 2728 + SoSprkFeedGetListFeed.HandlerOutput 2560 2729 >, 2561 2730 ) { 2562 2731 const nsid = "so.sprk.feed.getListFeed"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2563 2732 return this._server.xrpc.method(nsid, cfg); 2564 2733 } 2565 2734 2566 2566 - getSuggestedFeeds<AV extends AuthVerifier>( 2567 2567 - cfg: ConfigOf< 2568 2568 - AV, 2569 2569 - SoSprkFeedGetSuggestedFeeds.Handler<ExtractAuth<AV>>, 2570 2570 - SoSprkFeedGetSuggestedFeeds.HandlerReqCtx<ExtractAuth<AV>> 2735 2735 + getSuggestedFeeds<A extends Auth = void>( 2736 2736 + cfg: MethodConfigOrHandler< 2737 2737 + A, 2738 2738 + SoSprkFeedGetSuggestedFeeds.QueryParams, 2739 2739 + SoSprkFeedGetSuggestedFeeds.HandlerInput, 2740 2740 + SoSprkFeedGetSuggestedFeeds.HandlerOutput 2571 2741 >, 2572 2742 ) { 2573 2743 const nsid = "so.sprk.feed.getSuggestedFeeds"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2574 2744 return this._server.xrpc.method(nsid, cfg); 2575 2745 } 2576 2746 2577 2577 - getActorFeeds<AV extends AuthVerifier>( 2578 2578 - cfg: ConfigOf< 2579 2579 - AV, 2580 2580 - SoSprkFeedGetActorFeeds.Handler<ExtractAuth<AV>>, 2581 2581 - SoSprkFeedGetActorFeeds.HandlerReqCtx<ExtractAuth<AV>> 2747 2747 + getActorFeeds<A extends Auth = void>( 2748 2748 + cfg: MethodConfigOrHandler< 2749 2749 + A, 2750 2750 + SoSprkFeedGetActorFeeds.QueryParams, 2751 2751 + SoSprkFeedGetActorFeeds.HandlerInput, 2752 2752 + SoSprkFeedGetActorFeeds.HandlerOutput 2582 2753 >, 2583 2754 ) { 2584 2755 const nsid = "so.sprk.feed.getActorFeeds"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2586 2757 } 2587 2758 } 2588 2759 2589 2589 - export class SoSprkRichtextNS<T extends Env> { 2590 2590 - _server: Server<T>; 2760 2760 + export class SoSprkRichtextNS { 2761 2761 + _server: Server; 2591 2762 2592 2592 - constructor(server: Server<T>) { 2763 2763 + constructor(server: Server) { 2593 2764 this._server = server; 2594 2765 } 2595 2766 } 2596 2767 2597 2597 - export class SoSprkActorNS<T extends Env> { 2598 2598 - _server: Server<T>; 2768 2768 + export class SoSprkActorNS { 2769 2769 + _server: Server; 2599 2770 2600 2600 - constructor(server: Server<T>) { 2771 2771 + constructor(server: Server) { 2601 2772 this._server = server; 2602 2773 } 2603 2774 2604 2604 - searchActorsTypeahead<AV extends AuthVerifier>( 2605 2605 - cfg: ConfigOf< 2606 2606 - AV, 2607 2607 - SoSprkActorSearchActorsTypeahead.Handler<ExtractAuth<AV>>, 2608 2608 - SoSprkActorSearchActorsTypeahead.HandlerReqCtx<ExtractAuth<AV>> 2775 2775 + searchActorsTypeahead<A extends Auth = void>( 2776 2776 + cfg: MethodConfigOrHandler< 2777 2777 + A, 2778 2778 + SoSprkActorSearchActorsTypeahead.QueryParams, 2779 2779 + SoSprkActorSearchActorsTypeahead.HandlerInput, 2780 2780 + SoSprkActorSearchActorsTypeahead.HandlerOutput 2609 2781 >, 2610 2782 ) { 2611 2783 const nsid = "so.sprk.actor.searchActorsTypeahead"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2612 2784 return this._server.xrpc.method(nsid, cfg); 2613 2785 } 2614 2786 2615 2615 - putPreferences<AV extends AuthVerifier>( 2616 2616 - cfg: ConfigOf< 2617 2617 - AV, 2618 2618 - SoSprkActorPutPreferences.Handler<ExtractAuth<AV>>, 2619 2619 - SoSprkActorPutPreferences.HandlerReqCtx<ExtractAuth<AV>> 2787 2787 + putPreferences<A extends Auth = void>( 2788 2788 + cfg: MethodConfigOrHandler< 2789 2789 + A, 2790 2790 + SoSprkActorPutPreferences.QueryParams, 2791 2791 + SoSprkActorPutPreferences.HandlerInput, 2792 2792 + SoSprkActorPutPreferences.HandlerOutput 2620 2793 >, 2621 2794 ) { 2622 2795 const nsid = "so.sprk.actor.putPreferences"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2623 2796 return this._server.xrpc.method(nsid, cfg); 2624 2797 } 2625 2798 2626 2626 - getProfile<AV extends AuthVerifier>( 2627 2627 - cfg: ConfigOf< 2628 2628 - AV, 2629 2629 - SoSprkActorGetProfile.Handler<ExtractAuth<AV>>, 2630 2630 - SoSprkActorGetProfile.HandlerReqCtx<ExtractAuth<AV>> 2799 2799 + getProfile<A extends Auth = void>( 2800 2800 + cfg: MethodConfigOrHandler< 2801 2801 + A, 2802 2802 + SoSprkActorGetProfile.QueryParams, 2803 2803 + SoSprkActorGetProfile.HandlerInput, 2804 2804 + SoSprkActorGetProfile.HandlerOutput 2631 2805 >, 2632 2806 ) { 2633 2807 const nsid = "so.sprk.actor.getProfile"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2634 2808 return this._server.xrpc.method(nsid, cfg); 2635 2809 } 2636 2810 2637 2637 - getSuggestions<AV extends AuthVerifier>( 2638 2638 - cfg: ConfigOf< 2639 2639 - AV, 2640 2640 - SoSprkActorGetSuggestions.Handler<ExtractAuth<AV>>, 2641 2641 - SoSprkActorGetSuggestions.HandlerReqCtx<ExtractAuth<AV>> 2811 2811 + getSuggestions<A extends Auth = void>( 2812 2812 + cfg: MethodConfigOrHandler< 2813 2813 + A, 2814 2814 + SoSprkActorGetSuggestions.QueryParams, 2815 2815 + SoSprkActorGetSuggestions.HandlerInput, 2816 2816 + SoSprkActorGetSuggestions.HandlerOutput 2642 2817 >, 2643 2818 ) { 2644 2819 const nsid = "so.sprk.actor.getSuggestions"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2645 2820 return this._server.xrpc.method(nsid, cfg); 2646 2821 } 2647 2822 2648 2648 - searchActors<AV extends AuthVerifier>( 2649 2649 - cfg: ConfigOf< 2650 2650 - AV, 2651 2651 - SoSprkActorSearchActors.Handler<ExtractAuth<AV>>, 2652 2652 - SoSprkActorSearchActors.HandlerReqCtx<ExtractAuth<AV>> 2823 2823 + searchActors<A extends Auth = void>( 2824 2824 + cfg: MethodConfigOrHandler< 2825 2825 + A, 2826 2826 + SoSprkActorSearchActors.QueryParams, 2827 2827 + SoSprkActorSearchActors.HandlerInput, 2828 2828 + SoSprkActorSearchActors.HandlerOutput 2653 2829 >, 2654 2830 ) { 2655 2831 const nsid = "so.sprk.actor.searchActors"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2656 2832 return this._server.xrpc.method(nsid, cfg); 2657 2833 } 2658 2834 2659 2659 - getProfiles<AV extends AuthVerifier>( 2660 2660 - cfg: ConfigOf< 2661 2661 - AV, 2662 2662 - SoSprkActorGetProfiles.Handler<ExtractAuth<AV>>, 2663 2663 - SoSprkActorGetProfiles.HandlerReqCtx<ExtractAuth<AV>> 2835 2835 + getProfiles<A extends Auth = void>( 2836 2836 + cfg: MethodConfigOrHandler< 2837 2837 + A, 2838 2838 + SoSprkActorGetProfiles.QueryParams, 2839 2839 + SoSprkActorGetProfiles.HandlerInput, 2840 2840 + SoSprkActorGetProfiles.HandlerOutput 2664 2841 >, 2665 2842 ) { 2666 2843 const nsid = "so.sprk.actor.getProfiles"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2667 2844 return this._server.xrpc.method(nsid, cfg); 2668 2845 } 2669 2846 2670 2670 - getPreferences<AV extends AuthVerifier>( 2671 2671 - cfg: ConfigOf< 2672 2672 - AV, 2673 2673 - SoSprkActorGetPreferences.Handler<ExtractAuth<AV>>, 2674 2674 - SoSprkActorGetPreferences.HandlerReqCtx<ExtractAuth<AV>> 2847 2847 + getPreferences<A extends Auth = void>( 2848 2848 + cfg: MethodConfigOrHandler< 2849 2849 + A, 2850 2850 + SoSprkActorGetPreferences.QueryParams, 2851 2851 + SoSprkActorGetPreferences.HandlerInput, 2852 2852 + SoSprkActorGetPreferences.HandlerOutput 2675 2853 >, 2676 2854 ) { 2677 2855 const nsid = "so.sprk.actor.getPreferences"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2679 2857 } 2680 2858 } 2681 2859 2682 2682 - export class SoSprkLabelerNS<T extends Env> { 2683 2683 - _server: Server<T>; 2860 2860 + export class SoSprkLabelerNS { 2861 2861 + _server: Server; 2684 2862 2685 2685 - constructor(server: Server<T>) { 2863 2863 + constructor(server: Server) { 2686 2864 this._server = server; 2687 2865 } 2688 2866 2689 2689 - getServices<AV extends AuthVerifier>( 2690 2690 - cfg: ConfigOf< 2691 2691 - AV, 2692 2692 - SoSprkLabelerGetServices.Handler<ExtractAuth<AV>>, 2693 2693 - SoSprkLabelerGetServices.HandlerReqCtx<ExtractAuth<AV>> 2867 2867 + getServices<A extends Auth = void>( 2868 2868 + cfg: MethodConfigOrHandler< 2869 2869 + A, 2870 2870 + SoSprkLabelerGetServices.QueryParams, 2871 2871 + SoSprkLabelerGetServices.HandlerInput, 2872 2872 + SoSprkLabelerGetServices.HandlerOutput 2694 2873 >, 2695 2874 ) { 2696 2875 const nsid = "so.sprk.labeler.getServices"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2698 2877 } 2699 2878 } 2700 2879 2701 2701 - export class ComNS<T extends Env> { 2702 2702 - _server: Server<T>; 2703 2703 - atproto: ComAtprotoNS<T>; 2880 2880 + export class ComNS { 2881 2881 + _server: Server; 2882 2882 + atproto: ComAtprotoNS; 2704 2883 2705 2705 - constructor(server: Server<T>) { 2884 2884 + constructor(server: Server) { 2706 2885 this._server = server; 2707 2886 this.atproto = new ComAtprotoNS(server); 2708 2887 } 2709 2888 } 2710 2889 2711 2711 - export class ComAtprotoNS<T extends Env> { 2712 2712 - _server: Server<T>; 2713 2713 - temp: ComAtprotoTempNS<T>; 2714 2714 - identity: ComAtprotoIdentityNS<T>; 2715 2715 - admin: ComAtprotoAdminNS<T>; 2716 2716 - label: ComAtprotoLabelNS<T>; 2717 2717 - server: ComAtprotoServerNS<T>; 2718 2718 - lexicon: ComAtprotoLexiconNS<T>; 2719 2719 - sync: ComAtprotoSyncNS<T>; 2720 2720 - repo: ComAtprotoRepoNS<T>; 2721 2721 - moderation: ComAtprotoModerationNS<T>; 2890 2890 + export class ComAtprotoNS { 2891 2891 + _server: Server; 2892 2892 + temp: ComAtprotoTempNS; 2893 2893 + identity: ComAtprotoIdentityNS; 2894 2894 + admin: ComAtprotoAdminNS; 2895 2895 + label: ComAtprotoLabelNS; 2896 2896 + server: ComAtprotoServerNS; 2897 2897 + lexicon: ComAtprotoLexiconNS; 2898 2898 + sync: ComAtprotoSyncNS; 2899 2899 + repo: ComAtprotoRepoNS; 2900 2900 + moderation: ComAtprotoModerationNS; 2722 2901 2723 2723 - constructor(server: Server<T>) { 2902 2902 + constructor(server: Server) { 2724 2903 this._server = server; 2725 2904 this.temp = new ComAtprotoTempNS(server); 2726 2905 this.identity = new ComAtprotoIdentityNS(server); ··· 2734 2913 } 2735 2914 } 2736 2915 2737 2737 - export class ComAtprotoTempNS<T extends Env> { 2738 2738 - _server: Server<T>; 2916 2916 + export class ComAtprotoTempNS { 2917 2917 + _server: Server; 2739 2918 2740 2740 - constructor(server: Server<T>) { 2919 2919 + constructor(server: Server) { 2741 2920 this._server = server; 2742 2921 } 2743 2922 2744 2744 - addReservedHandle<AV extends AuthVerifier>( 2745 2745 - cfg: ConfigOf< 2746 2746 - AV, 2747 2747 - ComAtprotoTempAddReservedHandle.Handler<ExtractAuth<AV>>, 2748 2748 - ComAtprotoTempAddReservedHandle.HandlerReqCtx<ExtractAuth<AV>> 2923 2923 + addReservedHandle<A extends Auth = void>( 2924 2924 + cfg: MethodConfigOrHandler< 2925 2925 + A, 2926 2926 + ComAtprotoTempAddReservedHandle.QueryParams, 2927 2927 + ComAtprotoTempAddReservedHandle.HandlerInput, 2928 2928 + ComAtprotoTempAddReservedHandle.HandlerOutput 2749 2929 >, 2750 2930 ) { 2751 2931 const nsid = "com.atproto.temp.addReservedHandle"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2752 2932 return this._server.xrpc.method(nsid, cfg); 2753 2933 } 2754 2934 2755 2755 - checkSignupQueue<AV extends AuthVerifier>( 2756 2756 - cfg: ConfigOf< 2757 2757 - AV, 2758 2758 - ComAtprotoTempCheckSignupQueue.Handler<ExtractAuth<AV>>, 2759 2759 - ComAtprotoTempCheckSignupQueue.HandlerReqCtx<ExtractAuth<AV>> 2935 2935 + checkSignupQueue<A extends Auth = void>( 2936 2936 + cfg: MethodConfigOrHandler< 2937 2937 + A, 2938 2938 + ComAtprotoTempCheckSignupQueue.QueryParams, 2939 2939 + ComAtprotoTempCheckSignupQueue.HandlerInput, 2940 2940 + ComAtprotoTempCheckSignupQueue.HandlerOutput 2760 2941 >, 2761 2942 ) { 2762 2943 const nsid = "com.atproto.temp.checkSignupQueue"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2763 2944 return this._server.xrpc.method(nsid, cfg); 2764 2945 } 2765 2946 2766 2766 - requestPhoneVerification<AV extends AuthVerifier>( 2767 2767 - cfg: ConfigOf< 2768 2768 - AV, 2769 2769 - ComAtprotoTempRequestPhoneVerification.Handler<ExtractAuth<AV>>, 2770 2770 - ComAtprotoTempRequestPhoneVerification.HandlerReqCtx<ExtractAuth<AV>> 2947 2947 + requestPhoneVerification<A extends Auth = void>( 2948 2948 + cfg: MethodConfigOrHandler< 2949 2949 + A, 2950 2950 + ComAtprotoTempRequestPhoneVerification.QueryParams, 2951 2951 + ComAtprotoTempRequestPhoneVerification.HandlerInput, 2952 2952 + ComAtprotoTempRequestPhoneVerification.HandlerOutput 2771 2953 >, 2772 2954 ) { 2773 2955 const nsid = "com.atproto.temp.requestPhoneVerification"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2774 2956 return this._server.xrpc.method(nsid, cfg); 2775 2957 } 2776 2958 2777 2777 - fetchLabels<AV extends AuthVerifier>( 2778 2778 - cfg: ConfigOf< 2779 2779 - AV, 2780 2780 - ComAtprotoTempFetchLabels.Handler<ExtractAuth<AV>>, 2781 2781 - ComAtprotoTempFetchLabels.HandlerReqCtx<ExtractAuth<AV>> 2959 2959 + fetchLabels<A extends Auth = void>( 2960 2960 + cfg: MethodConfigOrHandler< 2961 2961 + A, 2962 2962 + ComAtprotoTempFetchLabels.QueryParams, 2963 2963 + ComAtprotoTempFetchLabels.HandlerInput, 2964 2964 + ComAtprotoTempFetchLabels.HandlerOutput 2782 2965 >, 2783 2966 ) { 2784 2967 const nsid = "com.atproto.temp.fetchLabels"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2786 2969 } 2787 2970 } 2788 2971 2789 2789 - export class ComAtprotoIdentityNS<T extends Env> { 2790 2790 - _server: Server<T>; 2972 2972 + export class ComAtprotoIdentityNS { 2973 2973 + _server: Server; 2791 2974 2792 2792 - constructor(server: Server<T>) { 2975 2975 + constructor(server: Server) { 2793 2976 this._server = server; 2794 2977 } 2795 2978 2796 2796 - updateHandle<AV extends AuthVerifier>( 2797 2797 - cfg: ConfigOf< 2798 2798 - AV, 2799 2799 - ComAtprotoIdentityUpdateHandle.Handler<ExtractAuth<AV>>, 2800 2800 - ComAtprotoIdentityUpdateHandle.HandlerReqCtx<ExtractAuth<AV>> 2979 2979 + updateHandle<A extends Auth = void>( 2980 2980 + cfg: MethodConfigOrHandler< 2981 2981 + A, 2982 2982 + ComAtprotoIdentityUpdateHandle.QueryParams, 2983 2983 + ComAtprotoIdentityUpdateHandle.HandlerInput, 2984 2984 + ComAtprotoIdentityUpdateHandle.HandlerOutput 2801 2985 >, 2802 2986 ) { 2803 2987 const nsid = "com.atproto.identity.updateHandle"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2804 2988 return this._server.xrpc.method(nsid, cfg); 2805 2989 } 2806 2990 2807 2807 - signPlcOperation<AV extends AuthVerifier>( 2808 2808 - cfg: ConfigOf< 2809 2809 - AV, 2810 2810 - ComAtprotoIdentitySignPlcOperation.Handler<ExtractAuth<AV>>, 2811 2811 - ComAtprotoIdentitySignPlcOperation.HandlerReqCtx<ExtractAuth<AV>> 2991 2991 + signPlcOperation<A extends Auth = void>( 2992 2992 + cfg: MethodConfigOrHandler< 2993 2993 + A, 2994 2994 + ComAtprotoIdentitySignPlcOperation.QueryParams, 2995 2995 + ComAtprotoIdentitySignPlcOperation.HandlerInput, 2996 2996 + ComAtprotoIdentitySignPlcOperation.HandlerOutput 2812 2997 >, 2813 2998 ) { 2814 2999 const nsid = "com.atproto.identity.signPlcOperation"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2815 3000 return this._server.xrpc.method(nsid, cfg); 2816 3001 } 2817 3002 2818 2818 - submitPlcOperation<AV extends AuthVerifier>( 2819 2819 - cfg: ConfigOf< 2820 2820 - AV, 2821 2821 - ComAtprotoIdentitySubmitPlcOperation.Handler<ExtractAuth<AV>>, 2822 2822 - ComAtprotoIdentitySubmitPlcOperation.HandlerReqCtx<ExtractAuth<AV>> 3003 3003 + submitPlcOperation<A extends Auth = void>( 3004 3004 + cfg: MethodConfigOrHandler< 3005 3005 + A, 3006 3006 + ComAtprotoIdentitySubmitPlcOperation.QueryParams, 3007 3007 + ComAtprotoIdentitySubmitPlcOperation.HandlerInput, 3008 3008 + ComAtprotoIdentitySubmitPlcOperation.HandlerOutput 2823 3009 >, 2824 3010 ) { 2825 3011 const nsid = "com.atproto.identity.submitPlcOperation"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2826 3012 return this._server.xrpc.method(nsid, cfg); 2827 3013 } 2828 3014 2829 2829 - resolveHandle<AV extends AuthVerifier>( 2830 2830 - cfg: ConfigOf< 2831 2831 - AV, 2832 2832 - ComAtprotoIdentityResolveHandle.Handler<ExtractAuth<AV>>, 2833 2833 - ComAtprotoIdentityResolveHandle.HandlerReqCtx<ExtractAuth<AV>> 3015 3015 + resolveHandle<A extends Auth = void>( 3016 3016 + cfg: MethodConfigOrHandler< 3017 3017 + A, 3018 3018 + ComAtprotoIdentityResolveHandle.QueryParams, 3019 3019 + ComAtprotoIdentityResolveHandle.HandlerInput, 3020 3020 + ComAtprotoIdentityResolveHandle.HandlerOutput 2834 3021 >, 2835 3022 ) { 2836 3023 const nsid = "com.atproto.identity.resolveHandle"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2837 3024 return this._server.xrpc.method(nsid, cfg); 2838 3025 } 2839 3026 2840 2840 - requestPlcOperationSignature<AV extends AuthVerifier>( 2841 2841 - cfg: ConfigOf< 2842 2842 - AV, 2843 2843 - ComAtprotoIdentityRequestPlcOperationSignature.Handler<ExtractAuth<AV>>, 2844 2844 - ComAtprotoIdentityRequestPlcOperationSignature.HandlerReqCtx< 2845 2845 - ExtractAuth<AV> 2846 2846 - > 3027 3027 + requestPlcOperationSignature<A extends Auth = void>( 3028 3028 + cfg: MethodConfigOrHandler< 3029 3029 + A, 3030 3030 + ComAtprotoIdentityRequestPlcOperationSignature.QueryParams, 3031 3031 + ComAtprotoIdentityRequestPlcOperationSignature.HandlerInput, 3032 3032 + ComAtprotoIdentityRequestPlcOperationSignature.HandlerOutput 2847 3033 >, 2848 3034 ) { 2849 3035 const nsid = "com.atproto.identity.requestPlcOperationSignature"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2850 3036 return this._server.xrpc.method(nsid, cfg); 2851 3037 } 2852 3038 2853 2853 - getRecommendedDidCredentials<AV extends AuthVerifier>( 2854 2854 - cfg: ConfigOf< 2855 2855 - AV, 2856 2856 - ComAtprotoIdentityGetRecommendedDidCredentials.Handler<ExtractAuth<AV>>, 2857 2857 - ComAtprotoIdentityGetRecommendedDidCredentials.HandlerReqCtx< 2858 2858 - ExtractAuth<AV> 2859 2859 - > 3039 3039 + getRecommendedDidCredentials<A extends Auth = void>( 3040 3040 + cfg: MethodConfigOrHandler< 3041 3041 + A, 3042 3042 + ComAtprotoIdentityGetRecommendedDidCredentials.QueryParams, 3043 3043 + ComAtprotoIdentityGetRecommendedDidCredentials.HandlerInput, 3044 3044 + ComAtprotoIdentityGetRecommendedDidCredentials.HandlerOutput 2860 3045 >, 2861 3046 ) { 2862 3047 const nsid = "com.atproto.identity.getRecommendedDidCredentials"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 2864 3049 } 2865 3050 } 2866 3051 2867 2867 - export class ComAtprotoAdminNS<T extends Env> { 2868 2868 - _server: Server<T>; 3052 3052 + export class ComAtprotoAdminNS { 3053 3053 + _server: Server; 2869 3054 2870 2870 - constructor(server: Server<T>) { 3055 3055 + constructor(server: Server) { 2871 3056 this._server = server; 2872 3057 } 2873 3058 2874 2874 - updateAccountEmail<AV extends AuthVerifier>( 2875 2875 - cfg: ConfigOf< 2876 2876 - AV, 2877 2877 - ComAtprotoAdminUpdateAccountEmail.Handler<ExtractAuth<AV>>, 2878 2878 - ComAtprotoAdminUpdateAccountEmail.HandlerReqCtx<ExtractAuth<AV>> 3059 3059 + updateAccountEmail<A extends Auth = void>( 3060 3060 + cfg: MethodConfigOrHandler< 3061 3061 + A, 3062 3062 + ComAtprotoAdminUpdateAccountEmail.QueryParams, 3063 3063 + ComAtprotoAdminUpdateAccountEmail.HandlerInput, 3064 3064 + ComAtprotoAdminUpdateAccountEmail.HandlerOutput 2879 3065 >, 2880 3066 ) { 2881 3067 const nsid = "com.atproto.admin.updateAccountEmail"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2882 3068 return this._server.xrpc.method(nsid, cfg); 2883 3069 } 2884 3070 2885 2885 - getAccountInfo<AV extends AuthVerifier>( 2886 2886 - cfg: ConfigOf< 2887 2887 - AV, 2888 2888 - ComAtprotoAdminGetAccountInfo.Handler<ExtractAuth<AV>>, 2889 2889 - ComAtprotoAdminGetAccountInfo.HandlerReqCtx<ExtractAuth<AV>> 3071 3071 + getAccountInfo<A extends Auth = void>( 3072 3072 + cfg: MethodConfigOrHandler< 3073 3073 + A, 3074 3074 + ComAtprotoAdminGetAccountInfo.QueryParams, 3075 3075 + ComAtprotoAdminGetAccountInfo.HandlerInput, 3076 3076 + ComAtprotoAdminGetAccountInfo.HandlerOutput 2890 3077 >, 2891 3078 ) { 2892 3079 const nsid = "com.atproto.admin.getAccountInfo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2893 3080 return this._server.xrpc.method(nsid, cfg); 2894 3081 } 2895 3082 2896 2896 - getSubjectStatus<AV extends AuthVerifier>( 2897 2897 - cfg: ConfigOf< 2898 2898 - AV, 2899 2899 - ComAtprotoAdminGetSubjectStatus.Handler<ExtractAuth<AV>>, 2900 2900 - ComAtprotoAdminGetSubjectStatus.HandlerReqCtx<ExtractAuth<AV>> 3083 3083 + getSubjectStatus<A extends Auth = void>( 3084 3084 + cfg: MethodConfigOrHandler< 3085 3085 + A, 3086 3086 + ComAtprotoAdminGetSubjectStatus.QueryParams, 3087 3087 + ComAtprotoAdminGetSubjectStatus.HandlerInput, 3088 3088 + ComAtprotoAdminGetSubjectStatus.HandlerOutput 2901 3089 >, 2902 3090 ) { 2903 3091 const nsid = "com.atproto.admin.getSubjectStatus"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2904 3092 return this._server.xrpc.method(nsid, cfg); 2905 3093 } 2906 3094 2907 2907 - searchAccounts<AV extends AuthVerifier>( 2908 2908 - cfg: ConfigOf< 2909 2909 - AV, 2910 2910 - ComAtprotoAdminSearchAccounts.Handler<ExtractAuth<AV>>, 2911 2911 - ComAtprotoAdminSearchAccounts.HandlerReqCtx<ExtractAuth<AV>> 3095 3095 + searchAccounts<A extends Auth = void>( 3096 3096 + cfg: MethodConfigOrHandler< 3097 3097 + A, 3098 3098 + ComAtprotoAdminSearchAccounts.QueryParams, 3099 3099 + ComAtprotoAdminSearchAccounts.HandlerInput, 3100 3100 + ComAtprotoAdminSearchAccounts.HandlerOutput 2912 3101 >, 2913 3102 ) { 2914 3103 const nsid = "com.atproto.admin.searchAccounts"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2915 3104 return this._server.xrpc.method(nsid, cfg); 2916 3105 } 2917 3106 2918 2918 - updateAccountPassword<AV extends AuthVerifier>( 2919 2919 - cfg: ConfigOf< 2920 2920 - AV, 2921 2921 - ComAtprotoAdminUpdateAccountPassword.Handler<ExtractAuth<AV>>, 2922 2922 - ComAtprotoAdminUpdateAccountPassword.HandlerReqCtx<ExtractAuth<AV>> 3107 3107 + updateAccountPassword<A extends Auth = void>( 3108 3108 + cfg: MethodConfigOrHandler< 3109 3109 + A, 3110 3110 + ComAtprotoAdminUpdateAccountPassword.QueryParams, 3111 3111 + ComAtprotoAdminUpdateAccountPassword.HandlerInput, 3112 3112 + ComAtprotoAdminUpdateAccountPassword.HandlerOutput 2923 3113 >, 2924 3114 ) { 2925 3115 const nsid = "com.atproto.admin.updateAccountPassword"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2926 3116 return this._server.xrpc.method(nsid, cfg); 2927 3117 } 2928 3118 2929 2929 - updateAccountHandle<AV extends AuthVerifier>( 2930 2930 - cfg: ConfigOf< 2931 2931 - AV, 2932 2932 - ComAtprotoAdminUpdateAccountHandle.Handler<ExtractAuth<AV>>, 2933 2933 - ComAtprotoAdminUpdateAccountHandle.HandlerReqCtx<ExtractAuth<AV>> 3119 3119 + updateAccountHandle<A extends Auth = void>( 3120 3120 + cfg: MethodConfigOrHandler< 3121 3121 + A, 3122 3122 + ComAtprotoAdminUpdateAccountHandle.QueryParams, 3123 3123 + ComAtprotoAdminUpdateAccountHandle.HandlerInput, 3124 3124 + ComAtprotoAdminUpdateAccountHandle.HandlerOutput 2934 3125 >, 2935 3126 ) { 2936 3127 const nsid = "com.atproto.admin.updateAccountHandle"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2937 3128 return this._server.xrpc.method(nsid, cfg); 2938 3129 } 2939 3130 2940 2940 - getInviteCodes<AV extends AuthVerifier>( 2941 2941 - cfg: ConfigOf< 2942 2942 - AV, 2943 2943 - ComAtprotoAdminGetInviteCodes.Handler<ExtractAuth<AV>>, 2944 2944 - ComAtprotoAdminGetInviteCodes.HandlerReqCtx<ExtractAuth<AV>> 3131 3131 + getInviteCodes<A extends Auth = void>( 3132 3132 + cfg: MethodConfigOrHandler< 3133 3133 + A, 3134 3134 + ComAtprotoAdminGetInviteCodes.QueryParams, 3135 3135 + ComAtprotoAdminGetInviteCodes.HandlerInput, 3136 3136 + ComAtprotoAdminGetInviteCodes.HandlerOutput 2945 3137 >, 2946 3138 ) { 2947 3139 const nsid = "com.atproto.admin.getInviteCodes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2948 3140 return this._server.xrpc.method(nsid, cfg); 2949 3141 } 2950 3142 2951 2951 - enableAccountInvites<AV extends AuthVerifier>( 2952 2952 - cfg: ConfigOf< 2953 2953 - AV, 2954 2954 - ComAtprotoAdminEnableAccountInvites.Handler<ExtractAuth<AV>>, 2955 2955 - ComAtprotoAdminEnableAccountInvites.HandlerReqCtx<ExtractAuth<AV>> 3143 3143 + enableAccountInvites<A extends Auth = void>( 3144 3144 + cfg: MethodConfigOrHandler< 3145 3145 + A, 3146 3146 + ComAtprotoAdminEnableAccountInvites.QueryParams, 3147 3147 + ComAtprotoAdminEnableAccountInvites.HandlerInput, 3148 3148 + ComAtprotoAdminEnableAccountInvites.HandlerOutput 2956 3149 >, 2957 3150 ) { 2958 3151 const nsid = "com.atproto.admin.enableAccountInvites"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2959 3152 return this._server.xrpc.method(nsid, cfg); 2960 3153 } 2961 3154 2962 2962 - disableAccountInvites<AV extends AuthVerifier>( 2963 2963 - cfg: ConfigOf< 2964 2964 - AV, 2965 2965 - ComAtprotoAdminDisableAccountInvites.Handler<ExtractAuth<AV>>, 2966 2966 - ComAtprotoAdminDisableAccountInvites.HandlerReqCtx<ExtractAuth<AV>> 3155 3155 + disableAccountInvites<A extends Auth = void>( 3156 3156 + cfg: MethodConfigOrHandler< 3157 3157 + A, 3158 3158 + ComAtprotoAdminDisableAccountInvites.QueryParams, 3159 3159 + ComAtprotoAdminDisableAccountInvites.HandlerInput, 3160 3160 + ComAtprotoAdminDisableAccountInvites.HandlerOutput 2967 3161 >, 2968 3162 ) { 2969 3163 const nsid = "com.atproto.admin.disableAccountInvites"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2970 3164 return this._server.xrpc.method(nsid, cfg); 2971 3165 } 2972 3166 2973 2973 - disableInviteCodes<AV extends AuthVerifier>( 2974 2974 - cfg: ConfigOf< 2975 2975 - AV, 2976 2976 - ComAtprotoAdminDisableInviteCodes.Handler<ExtractAuth<AV>>, 2977 2977 - ComAtprotoAdminDisableInviteCodes.HandlerReqCtx<ExtractAuth<AV>> 3167 3167 + disableInviteCodes<A extends Auth = void>( 3168 3168 + cfg: MethodConfigOrHandler< 3169 3169 + A, 3170 3170 + ComAtprotoAdminDisableInviteCodes.QueryParams, 3171 3171 + ComAtprotoAdminDisableInviteCodes.HandlerInput, 3172 3172 + ComAtprotoAdminDisableInviteCodes.HandlerOutput 2978 3173 >, 2979 3174 ) { 2980 3175 const nsid = "com.atproto.admin.disableInviteCodes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2981 3176 return this._server.xrpc.method(nsid, cfg); 2982 3177 } 2983 3178 2984 2984 - updateSubjectStatus<AV extends AuthVerifier>( 2985 2985 - cfg: ConfigOf< 2986 2986 - AV, 2987 2987 - ComAtprotoAdminUpdateSubjectStatus.Handler<ExtractAuth<AV>>, 2988 2988 - ComAtprotoAdminUpdateSubjectStatus.HandlerReqCtx<ExtractAuth<AV>> 3179 3179 + updateSubjectStatus<A extends Auth = void>( 3180 3180 + cfg: MethodConfigOrHandler< 3181 3181 + A, 3182 3182 + ComAtprotoAdminUpdateSubjectStatus.QueryParams, 3183 3183 + ComAtprotoAdminUpdateSubjectStatus.HandlerInput, 3184 3184 + ComAtprotoAdminUpdateSubjectStatus.HandlerOutput 2989 3185 >, 2990 3186 ) { 2991 3187 const nsid = "com.atproto.admin.updateSubjectStatus"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 2992 3188 return this._server.xrpc.method(nsid, cfg); 2993 3189 } 2994 3190 2995 2995 - sendEmail<AV extends AuthVerifier>( 2996 2996 - cfg: ConfigOf< 2997 2997 - AV, 2998 2998 - ComAtprotoAdminSendEmail.Handler<ExtractAuth<AV>>, 2999 2999 - ComAtprotoAdminSendEmail.HandlerReqCtx<ExtractAuth<AV>> 3191 3191 + sendEmail<A extends Auth = void>( 3192 3192 + cfg: MethodConfigOrHandler< 3193 3193 + A, 3194 3194 + ComAtprotoAdminSendEmail.QueryParams, 3195 3195 + ComAtprotoAdminSendEmail.HandlerInput, 3196 3196 + ComAtprotoAdminSendEmail.HandlerOutput 3000 3197 >, 3001 3198 ) { 3002 3199 const nsid = "com.atproto.admin.sendEmail"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3003 3200 return this._server.xrpc.method(nsid, cfg); 3004 3201 } 3005 3202 3006 3006 - getAccountInfos<AV extends AuthVerifier>( 3007 3007 - cfg: ConfigOf< 3008 3008 - AV, 3009 3009 - ComAtprotoAdminGetAccountInfos.Handler<ExtractAuth<AV>>, 3010 3010 - ComAtprotoAdminGetAccountInfos.HandlerReqCtx<ExtractAuth<AV>> 3203 3203 + getAccountInfos<A extends Auth = void>( 3204 3204 + cfg: MethodConfigOrHandler< 3205 3205 + A, 3206 3206 + ComAtprotoAdminGetAccountInfos.QueryParams, 3207 3207 + ComAtprotoAdminGetAccountInfos.HandlerInput, 3208 3208 + ComAtprotoAdminGetAccountInfos.HandlerOutput 3011 3209 >, 3012 3210 ) { 3013 3211 const nsid = "com.atproto.admin.getAccountInfos"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3014 3212 return this._server.xrpc.method(nsid, cfg); 3015 3213 } 3016 3214 3017 3017 - deleteAccount<AV extends AuthVerifier>( 3018 3018 - cfg: ConfigOf< 3019 3019 - AV, 3020 3020 - ComAtprotoAdminDeleteAccount.Handler<ExtractAuth<AV>>, 3021 3021 - ComAtprotoAdminDeleteAccount.HandlerReqCtx<ExtractAuth<AV>> 3215 3215 + deleteAccount<A extends Auth = void>( 3216 3216 + cfg: MethodConfigOrHandler< 3217 3217 + A, 3218 3218 + ComAtprotoAdminDeleteAccount.QueryParams, 3219 3219 + ComAtprotoAdminDeleteAccount.HandlerInput, 3220 3220 + ComAtprotoAdminDeleteAccount.HandlerOutput 3022 3221 >, 3023 3222 ) { 3024 3223 const nsid = "com.atproto.admin.deleteAccount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 3026 3225 } 3027 3226 } 3028 3227 3029 3029 - export class ComAtprotoLabelNS<T extends Env> { 3030 3030 - _server: Server<T>; 3228 3228 + export class ComAtprotoLabelNS { 3229 3229 + _server: Server; 3031 3230 3032 3032 - constructor(server: Server<T>) { 3231 3231 + constructor(server: Server) { 3033 3232 this._server = server; 3034 3233 } 3035 3234 3036 3036 - subscribeLabels<AV extends StreamAuthVerifier>( 3037 3037 - cfg: ConfigOf< 3038 3038 - AV, 3039 3039 - ComAtprotoLabelSubscribeLabels.Handler<ExtractAuth<AV>>, 3040 3040 - ComAtprotoLabelSubscribeLabels.HandlerReqCtx<ExtractAuth<AV>> 3235 3235 + subscribeLabels<A extends Auth = void>( 3236 3236 + cfg: StreamConfigOrHandler< 3237 3237 + A, 3238 3238 + ComAtprotoLabelSubscribeLabels.QueryParams, 3239 3239 + ComAtprotoLabelSubscribeLabels.HandlerOutput 3041 3240 >, 3042 3241 ) { 3043 3242 const nsid = "com.atproto.label.subscribeLabels"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3044 3243 return this._server.xrpc.streamMethod(nsid, cfg); 3045 3244 } 3046 3245 3047 3047 - queryLabels<AV extends AuthVerifier>( 3048 3048 - cfg: ConfigOf< 3049 3049 - AV, 3050 3050 - ComAtprotoLabelQueryLabels.Handler<ExtractAuth<AV>>, 3051 3051 - ComAtprotoLabelQueryLabels.HandlerReqCtx<ExtractAuth<AV>> 3246 3246 + queryLabels<A extends Auth = void>( 3247 3247 + cfg: MethodConfigOrHandler< 3248 3248 + A, 3249 3249 + ComAtprotoLabelQueryLabels.QueryParams, 3250 3250 + ComAtprotoLabelQueryLabels.HandlerInput, 3251 3251 + ComAtprotoLabelQueryLabels.HandlerOutput 3052 3252 >, 3053 3253 ) { 3054 3254 const nsid = "com.atproto.label.queryLabels"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 3056 3256 } 3057 3257 } 3058 3258 3059 3059 - export class ComAtprotoServerNS<T extends Env> { 3060 3060 - _server: Server<T>; 3259 3259 + export class ComAtprotoServerNS { 3260 3260 + _server: Server; 3061 3261 3062 3062 - constructor(server: Server<T>) { 3262 3262 + constructor(server: Server) { 3063 3263 this._server = server; 3064 3264 } 3065 3265 3066 3066 - requestEmailConfirmation<AV extends AuthVerifier>( 3067 3067 - cfg: ConfigOf< 3068 3068 - AV, 3069 3069 - ComAtprotoServerRequestEmailConfirmation.Handler<ExtractAuth<AV>>, 3070 3070 - ComAtprotoServerRequestEmailConfirmation.HandlerReqCtx<ExtractAuth<AV>> 3266 3266 + requestEmailConfirmation<A extends Auth = void>( 3267 3267 + cfg: MethodConfigOrHandler< 3268 3268 + A, 3269 3269 + ComAtprotoServerRequestEmailConfirmation.QueryParams, 3270 3270 + ComAtprotoServerRequestEmailConfirmation.HandlerInput, 3271 3271 + ComAtprotoServerRequestEmailConfirmation.HandlerOutput 3071 3272 >, 3072 3273 ) { 3073 3274 const nsid = "com.atproto.server.requestEmailConfirmation"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3074 3275 return this._server.xrpc.method(nsid, cfg); 3075 3276 } 3076 3277 3077 3077 - reserveSigningKey<AV extends AuthVerifier>( 3078 3078 - cfg: ConfigOf< 3079 3079 - AV, 3080 3080 - ComAtprotoServerReserveSigningKey.Handler<ExtractAuth<AV>>, 3081 3081 - ComAtprotoServerReserveSigningKey.HandlerReqCtx<ExtractAuth<AV>> 3278 3278 + reserveSigningKey<A extends Auth = void>( 3279 3279 + cfg: MethodConfigOrHandler< 3280 3280 + A, 3281 3281 + ComAtprotoServerReserveSigningKey.QueryParams, 3282 3282 + ComAtprotoServerReserveSigningKey.HandlerInput, 3283 3283 + ComAtprotoServerReserveSigningKey.HandlerOutput 3082 3284 >, 3083 3285 ) { 3084 3286 const nsid = "com.atproto.server.reserveSigningKey"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3085 3287 return this._server.xrpc.method(nsid, cfg); 3086 3288 } 3087 3289 3088 3088 - getServiceAuth<AV extends AuthVerifier>( 3089 3089 - cfg: ConfigOf< 3090 3090 - AV, 3091 3091 - ComAtprotoServerGetServiceAuth.Handler<ExtractAuth<AV>>, 3092 3092 - ComAtprotoServerGetServiceAuth.HandlerReqCtx<ExtractAuth<AV>> 3290 3290 + getServiceAuth<A extends Auth = void>( 3291 3291 + cfg: MethodConfigOrHandler< 3292 3292 + A, 3293 3293 + ComAtprotoServerGetServiceAuth.QueryParams, 3294 3294 + ComAtprotoServerGetServiceAuth.HandlerInput, 3295 3295 + ComAtprotoServerGetServiceAuth.HandlerOutput 3093 3296 >, 3094 3297 ) { 3095 3298 const nsid = "com.atproto.server.getServiceAuth"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3096 3299 return this._server.xrpc.method(nsid, cfg); 3097 3300 } 3098 3301 3099 3099 - getAccountInviteCodes<AV extends AuthVerifier>( 3100 3100 - cfg: ConfigOf< 3101 3101 - AV, 3102 3102 - ComAtprotoServerGetAccountInviteCodes.Handler<ExtractAuth<AV>>, 3103 3103 - ComAtprotoServerGetAccountInviteCodes.HandlerReqCtx<ExtractAuth<AV>> 3302 3302 + getAccountInviteCodes<A extends Auth = void>( 3303 3303 + cfg: MethodConfigOrHandler< 3304 3304 + A, 3305 3305 + ComAtprotoServerGetAccountInviteCodes.QueryParams, 3306 3306 + ComAtprotoServerGetAccountInviteCodes.HandlerInput, 3307 3307 + ComAtprotoServerGetAccountInviteCodes.HandlerOutput 3104 3308 >, 3105 3309 ) { 3106 3310 const nsid = "com.atproto.server.getAccountInviteCodes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3107 3311 return this._server.xrpc.method(nsid, cfg); 3108 3312 } 3109 3313 3110 3110 - createSession<AV extends AuthVerifier>( 3111 3111 - cfg: ConfigOf< 3112 3112 - AV, 3113 3113 - ComAtprotoServerCreateSession.Handler<ExtractAuth<AV>>, 3114 3114 - ComAtprotoServerCreateSession.HandlerReqCtx<ExtractAuth<AV>> 3314 3314 + createSession<A extends Auth = void>( 3315 3315 + cfg: MethodConfigOrHandler< 3316 3316 + A, 3317 3317 + ComAtprotoServerCreateSession.QueryParams, 3318 3318 + ComAtprotoServerCreateSession.HandlerInput, 3319 3319 + ComAtprotoServerCreateSession.HandlerOutput 3115 3320 >, 3116 3321 ) { 3117 3322 const nsid = "com.atproto.server.createSession"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3118 3323 return this._server.xrpc.method(nsid, cfg); 3119 3324 } 3120 3325 3121 3121 - listAppPasswords<AV extends AuthVerifier>( 3122 3122 - cfg: ConfigOf< 3123 3123 - AV, 3124 3124 - ComAtprotoServerListAppPasswords.Handler<ExtractAuth<AV>>, 3125 3125 - ComAtprotoServerListAppPasswords.HandlerReqCtx<ExtractAuth<AV>> 3326 3326 + listAppPasswords<A extends Auth = void>( 3327 3327 + cfg: MethodConfigOrHandler< 3328 3328 + A, 3329 3329 + ComAtprotoServerListAppPasswords.QueryParams, 3330 3330 + ComAtprotoServerListAppPasswords.HandlerInput, 3331 3331 + ComAtprotoServerListAppPasswords.HandlerOutput 3126 3332 >, 3127 3333 ) { 3128 3334 const nsid = "com.atproto.server.listAppPasswords"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3129 3335 return this._server.xrpc.method(nsid, cfg); 3130 3336 } 3131 3337 3132 3132 - createInviteCodes<AV extends AuthVerifier>( 3133 3133 - cfg: ConfigOf< 3134 3134 - AV, 3135 3135 - ComAtprotoServerCreateInviteCodes.Handler<ExtractAuth<AV>>, 3136 3136 - ComAtprotoServerCreateInviteCodes.HandlerReqCtx<ExtractAuth<AV>> 3338 3338 + createInviteCodes<A extends Auth = void>( 3339 3339 + cfg: MethodConfigOrHandler< 3340 3340 + A, 3341 3341 + ComAtprotoServerCreateInviteCodes.QueryParams, 3342 3342 + ComAtprotoServerCreateInviteCodes.HandlerInput, 3343 3343 + ComAtprotoServerCreateInviteCodes.HandlerOutput 3137 3344 >, 3138 3345 ) { 3139 3346 const nsid = "com.atproto.server.createInviteCodes"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3140 3347 return this._server.xrpc.method(nsid, cfg); 3141 3348 } 3142 3349 3143 3143 - deleteSession<AV extends AuthVerifier>( 3144 3144 - cfg: ConfigOf< 3145 3145 - AV, 3146 3146 - ComAtprotoServerDeleteSession.Handler<ExtractAuth<AV>>, 3147 3147 - ComAtprotoServerDeleteSession.HandlerReqCtx<ExtractAuth<AV>> 3350 3350 + deleteSession<A extends Auth = void>( 3351 3351 + cfg: MethodConfigOrHandler< 3352 3352 + A, 3353 3353 + ComAtprotoServerDeleteSession.QueryParams, 3354 3354 + ComAtprotoServerDeleteSession.HandlerInput, 3355 3355 + ComAtprotoServerDeleteSession.HandlerOutput 3148 3356 >, 3149 3357 ) { 3150 3358 const nsid = "com.atproto.server.deleteSession"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3151 3359 return this._server.xrpc.method(nsid, cfg); 3152 3360 } 3153 3361 3154 3154 - revokeAppPassword<AV extends AuthVerifier>( 3155 3155 - cfg: ConfigOf< 3156 3156 - AV, 3157 3157 - ComAtprotoServerRevokeAppPassword.Handler<ExtractAuth<AV>>, 3158 3158 - ComAtprotoServerRevokeAppPassword.HandlerReqCtx<ExtractAuth<AV>> 3362 3362 + revokeAppPassword<A extends Auth = void>( 3363 3363 + cfg: MethodConfigOrHandler< 3364 3364 + A, 3365 3365 + ComAtprotoServerRevokeAppPassword.QueryParams, 3366 3366 + ComAtprotoServerRevokeAppPassword.HandlerInput, 3367 3367 + ComAtprotoServerRevokeAppPassword.HandlerOutput 3159 3368 >, 3160 3369 ) { 3161 3370 const nsid = "com.atproto.server.revokeAppPassword"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3162 3371 return this._server.xrpc.method(nsid, cfg); 3163 3372 } 3164 3373 3165 3165 - createAppPassword<AV extends AuthVerifier>( 3166 3166 - cfg: ConfigOf< 3167 3167 - AV, 3168 3168 - ComAtprotoServerCreateAppPassword.Handler<ExtractAuth<AV>>, 3169 3169 - ComAtprotoServerCreateAppPassword.HandlerReqCtx<ExtractAuth<AV>> 3374 3374 + createAppPassword<A extends Auth = void>( 3375 3375 + cfg: MethodConfigOrHandler< 3376 3376 + A, 3377 3377 + ComAtprotoServerCreateAppPassword.QueryParams, 3378 3378 + ComAtprotoServerCreateAppPassword.HandlerInput, 3379 3379 + ComAtprotoServerCreateAppPassword.HandlerOutput 3170 3380 >, 3171 3381 ) { 3172 3382 const nsid = "com.atproto.server.createAppPassword"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3173 3383 return this._server.xrpc.method(nsid, cfg); 3174 3384 } 3175 3385 3176 3176 - activateAccount<AV extends AuthVerifier>( 3177 3177 - cfg: ConfigOf< 3178 3178 - AV, 3179 3179 - ComAtprotoServerActivateAccount.Handler<ExtractAuth<AV>>, 3180 3180 - ComAtprotoServerActivateAccount.HandlerReqCtx<ExtractAuth<AV>> 3386 3386 + activateAccount<A extends Auth = void>( 3387 3387 + cfg: MethodConfigOrHandler< 3388 3388 + A, 3389 3389 + ComAtprotoServerActivateAccount.QueryParams, 3390 3390 + ComAtprotoServerActivateAccount.HandlerInput, 3391 3391 + ComAtprotoServerActivateAccount.HandlerOutput 3181 3392 >, 3182 3393 ) { 3183 3394 const nsid = "com.atproto.server.activateAccount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3184 3395 return this._server.xrpc.method(nsid, cfg); 3185 3396 } 3186 3397 3187 3187 - describeServer<AV extends AuthVerifier>( 3188 3188 - cfg: ConfigOf< 3189 3189 - AV, 3190 3190 - ComAtprotoServerDescribeServer.Handler<ExtractAuth<AV>>, 3191 3191 - ComAtprotoServerDescribeServer.HandlerReqCtx<ExtractAuth<AV>> 3398 3398 + describeServer<A extends Auth = void>( 3399 3399 + cfg: MethodConfigOrHandler< 3400 3400 + A, 3401 3401 + ComAtprotoServerDescribeServer.QueryParams, 3402 3402 + ComAtprotoServerDescribeServer.HandlerInput, 3403 3403 + ComAtprotoServerDescribeServer.HandlerOutput 3192 3404 >, 3193 3405 ) { 3194 3406 const nsid = "com.atproto.server.describeServer"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3195 3407 return this._server.xrpc.method(nsid, cfg); 3196 3408 } 3197 3409 3198 3198 - confirmEmail<AV extends AuthVerifier>( 3199 3199 - cfg: ConfigOf< 3200 3200 - AV, 3201 3201 - ComAtprotoServerConfirmEmail.Handler<ExtractAuth<AV>>, 3202 3202 - ComAtprotoServerConfirmEmail.HandlerReqCtx<ExtractAuth<AV>> 3410 3410 + confirmEmail<A extends Auth = void>( 3411 3411 + cfg: MethodConfigOrHandler< 3412 3412 + A, 3413 3413 + ComAtprotoServerConfirmEmail.QueryParams, 3414 3414 + ComAtprotoServerConfirmEmail.HandlerInput, 3415 3415 + ComAtprotoServerConfirmEmail.HandlerOutput 3203 3416 >, 3204 3417 ) { 3205 3418 const nsid = "com.atproto.server.confirmEmail"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3206 3419 return this._server.xrpc.method(nsid, cfg); 3207 3420 } 3208 3421 3209 3209 - getSession<AV extends AuthVerifier>( 3210 3210 - cfg: ConfigOf< 3211 3211 - AV, 3212 3212 - ComAtprotoServerGetSession.Handler<ExtractAuth<AV>>, 3213 3213 - ComAtprotoServerGetSession.HandlerReqCtx<ExtractAuth<AV>> 3422 3422 + getSession<A extends Auth = void>( 3423 3423 + cfg: MethodConfigOrHandler< 3424 3424 + A, 3425 3425 + ComAtprotoServerGetSession.QueryParams, 3426 3426 + ComAtprotoServerGetSession.HandlerInput, 3427 3427 + ComAtprotoServerGetSession.HandlerOutput 3214 3428 >, 3215 3429 ) { 3216 3430 const nsid = "com.atproto.server.getSession"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3217 3431 return this._server.xrpc.method(nsid, cfg); 3218 3432 } 3219 3433 3220 3220 - refreshSession<AV extends AuthVerifier>( 3221 3221 - cfg: ConfigOf< 3222 3222 - AV, 3223 3223 - ComAtprotoServerRefreshSession.Handler<ExtractAuth<AV>>, 3224 3224 - ComAtprotoServerRefreshSession.HandlerReqCtx<ExtractAuth<AV>> 3434 3434 + refreshSession<A extends Auth = void>( 3435 3435 + cfg: MethodConfigOrHandler< 3436 3436 + A, 3437 3437 + ComAtprotoServerRefreshSession.QueryParams, 3438 3438 + ComAtprotoServerRefreshSession.HandlerInput, 3439 3439 + ComAtprotoServerRefreshSession.HandlerOutput 3225 3440 >, 3226 3441 ) { 3227 3442 const nsid = "com.atproto.server.refreshSession"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3228 3443 return this._server.xrpc.method(nsid, cfg); 3229 3444 } 3230 3445 3231 3231 - deactivateAccount<AV extends AuthVerifier>( 3232 3232 - cfg: ConfigOf< 3233 3233 - AV, 3234 3234 - ComAtprotoServerDeactivateAccount.Handler<ExtractAuth<AV>>, 3235 3235 - ComAtprotoServerDeactivateAccount.HandlerReqCtx<ExtractAuth<AV>> 3446 3446 + deactivateAccount<A extends Auth = void>( 3447 3447 + cfg: MethodConfigOrHandler< 3448 3448 + A, 3449 3449 + ComAtprotoServerDeactivateAccount.QueryParams, 3450 3450 + ComAtprotoServerDeactivateAccount.HandlerInput, 3451 3451 + ComAtprotoServerDeactivateAccount.HandlerOutput 3236 3452 >, 3237 3453 ) { 3238 3454 const nsid = "com.atproto.server.deactivateAccount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3239 3455 return this._server.xrpc.method(nsid, cfg); 3240 3456 } 3241 3457 3242 3242 - updateEmail<AV extends AuthVerifier>( 3243 3243 - cfg: ConfigOf< 3244 3244 - AV, 3245 3245 - ComAtprotoServerUpdateEmail.Handler<ExtractAuth<AV>>, 3246 3246 - ComAtprotoServerUpdateEmail.HandlerReqCtx<ExtractAuth<AV>> 3458 3458 + updateEmail<A extends Auth = void>( 3459 3459 + cfg: MethodConfigOrHandler< 3460 3460 + A, 3461 3461 + ComAtprotoServerUpdateEmail.QueryParams, 3462 3462 + ComAtprotoServerUpdateEmail.HandlerInput, 3463 3463 + ComAtprotoServerUpdateEmail.HandlerOutput 3247 3464 >, 3248 3465 ) { 3249 3466 const nsid = "com.atproto.server.updateEmail"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3250 3467 return this._server.xrpc.method(nsid, cfg); 3251 3468 } 3252 3469 3253 3253 - resetPassword<AV extends AuthVerifier>( 3254 3254 - cfg: ConfigOf< 3255 3255 - AV, 3256 3256 - ComAtprotoServerResetPassword.Handler<ExtractAuth<AV>>, 3257 3257 - ComAtprotoServerResetPassword.HandlerReqCtx<ExtractAuth<AV>> 3470 3470 + resetPassword<A extends Auth = void>( 3471 3471 + cfg: MethodConfigOrHandler< 3472 3472 + A, 3473 3473 + ComAtprotoServerResetPassword.QueryParams, 3474 3474 + ComAtprotoServerResetPassword.HandlerInput, 3475 3475 + ComAtprotoServerResetPassword.HandlerOutput 3258 3476 >, 3259 3477 ) { 3260 3478 const nsid = "com.atproto.server.resetPassword"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3261 3479 return this._server.xrpc.method(nsid, cfg); 3262 3480 } 3263 3481 3264 3264 - checkAccountStatus<AV extends AuthVerifier>( 3265 3265 - cfg: ConfigOf< 3266 3266 - AV, 3267 3267 - ComAtprotoServerCheckAccountStatus.Handler<ExtractAuth<AV>>, 3268 3268 - ComAtprotoServerCheckAccountStatus.HandlerReqCtx<ExtractAuth<AV>> 3482 3482 + checkAccountStatus<A extends Auth = void>( 3483 3483 + cfg: MethodConfigOrHandler< 3484 3484 + A, 3485 3485 + ComAtprotoServerCheckAccountStatus.QueryParams, 3486 3486 + ComAtprotoServerCheckAccountStatus.HandlerInput, 3487 3487 + ComAtprotoServerCheckAccountStatus.HandlerOutput 3269 3488 >, 3270 3489 ) { 3271 3490 const nsid = "com.atproto.server.checkAccountStatus"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3272 3491 return this._server.xrpc.method(nsid, cfg); 3273 3492 } 3274 3493 3275 3275 - requestEmailUpdate<AV extends AuthVerifier>( 3276 3276 - cfg: ConfigOf< 3277 3277 - AV, 3278 3278 - ComAtprotoServerRequestEmailUpdate.Handler<ExtractAuth<AV>>, 3279 3279 - ComAtprotoServerRequestEmailUpdate.HandlerReqCtx<ExtractAuth<AV>> 3494 3494 + requestEmailUpdate<A extends Auth = void>( 3495 3495 + cfg: MethodConfigOrHandler< 3496 3496 + A, 3497 3497 + ComAtprotoServerRequestEmailUpdate.QueryParams, 3498 3498 + ComAtprotoServerRequestEmailUpdate.HandlerInput, 3499 3499 + ComAtprotoServerRequestEmailUpdate.HandlerOutput 3280 3500 >, 3281 3501 ) { 3282 3502 const nsid = "com.atproto.server.requestEmailUpdate"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3283 3503 return this._server.xrpc.method(nsid, cfg); 3284 3504 } 3285 3505 3286 3286 - requestPasswordReset<AV extends AuthVerifier>( 3287 3287 - cfg: ConfigOf< 3288 3288 - AV, 3289 3289 - ComAtprotoServerRequestPasswordReset.Handler<ExtractAuth<AV>>, 3290 3290 - ComAtprotoServerRequestPasswordReset.HandlerReqCtx<ExtractAuth<AV>> 3506 3506 + requestPasswordReset<A extends Auth = void>( 3507 3507 + cfg: MethodConfigOrHandler< 3508 3508 + A, 3509 3509 + ComAtprotoServerRequestPasswordReset.QueryParams, 3510 3510 + ComAtprotoServerRequestPasswordReset.HandlerInput, 3511 3511 + ComAtprotoServerRequestPasswordReset.HandlerOutput 3291 3512 >, 3292 3513 ) { 3293 3514 const nsid = "com.atproto.server.requestPasswordReset"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3294 3515 return this._server.xrpc.method(nsid, cfg); 3295 3516 } 3296 3517 3297 3297 - requestAccountDelete<AV extends AuthVerifier>( 3298 3298 - cfg: ConfigOf< 3299 3299 - AV, 3300 3300 - ComAtprotoServerRequestAccountDelete.Handler<ExtractAuth<AV>>, 3301 3301 - ComAtprotoServerRequestAccountDelete.HandlerReqCtx<ExtractAuth<AV>> 3518 3518 + requestAccountDelete<A extends Auth = void>( 3519 3519 + cfg: MethodConfigOrHandler< 3520 3520 + A, 3521 3521 + ComAtprotoServerRequestAccountDelete.QueryParams, 3522 3522 + ComAtprotoServerRequestAccountDelete.HandlerInput, 3523 3523 + ComAtprotoServerRequestAccountDelete.HandlerOutput 3302 3524 >, 3303 3525 ) { 3304 3526 const nsid = "com.atproto.server.requestAccountDelete"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3305 3527 return this._server.xrpc.method(nsid, cfg); 3306 3528 } 3307 3529 3308 3308 - createAccount<AV extends AuthVerifier>( 3309 3309 - cfg: ConfigOf< 3310 3310 - AV, 3311 3311 - ComAtprotoServerCreateAccount.Handler<ExtractAuth<AV>>, 3312 3312 - ComAtprotoServerCreateAccount.HandlerReqCtx<ExtractAuth<AV>> 3530 3530 + createAccount<A extends Auth = void>( 3531 3531 + cfg: MethodConfigOrHandler< 3532 3532 + A, 3533 3533 + ComAtprotoServerCreateAccount.QueryParams, 3534 3534 + ComAtprotoServerCreateAccount.HandlerInput, 3535 3535 + ComAtprotoServerCreateAccount.HandlerOutput 3313 3536 >, 3314 3537 ) { 3315 3538 const nsid = "com.atproto.server.createAccount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3316 3539 return this._server.xrpc.method(nsid, cfg); 3317 3540 } 3318 3541 3319 3319 - deleteAccount<AV extends AuthVerifier>( 3320 3320 - cfg: ConfigOf< 3321 3321 - AV, 3322 3322 - ComAtprotoServerDeleteAccount.Handler<ExtractAuth<AV>>, 3323 3323 - ComAtprotoServerDeleteAccount.HandlerReqCtx<ExtractAuth<AV>> 3542 3542 + deleteAccount<A extends Auth = void>( 3543 3543 + cfg: MethodConfigOrHandler< 3544 3544 + A, 3545 3545 + ComAtprotoServerDeleteAccount.QueryParams, 3546 3546 + ComAtprotoServerDeleteAccount.HandlerInput, 3547 3547 + ComAtprotoServerDeleteAccount.HandlerOutput 3324 3548 >, 3325 3549 ) { 3326 3550 const nsid = "com.atproto.server.deleteAccount"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3327 3551 return this._server.xrpc.method(nsid, cfg); 3328 3552 } 3329 3553 3330 3330 - createInviteCode<AV extends AuthVerifier>( 3331 3331 - cfg: ConfigOf< 3332 3332 - AV, 3333 3333 - ComAtprotoServerCreateInviteCode.Handler<ExtractAuth<AV>>, 3334 3334 - ComAtprotoServerCreateInviteCode.HandlerReqCtx<ExtractAuth<AV>> 3554 3554 + createInviteCode<A extends Auth = void>( 3555 3555 + cfg: MethodConfigOrHandler< 3556 3556 + A, 3557 3557 + ComAtprotoServerCreateInviteCode.QueryParams, 3558 3558 + ComAtprotoServerCreateInviteCode.HandlerInput, 3559 3559 + ComAtprotoServerCreateInviteCode.HandlerOutput 3335 3560 >, 3336 3561 ) { 3337 3562 const nsid = "com.atproto.server.createInviteCode"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 3339 3564 } 3340 3565 } 3341 3566 3342 3342 - export class ComAtprotoLexiconNS<T extends Env> { 3343 3343 - _server: Server<T>; 3567 3567 + export class ComAtprotoLexiconNS { 3568 3568 + _server: Server; 3344 3569 3345 3345 - constructor(server: Server<T>) { 3570 3570 + constructor(server: Server) { 3346 3571 this._server = server; 3347 3572 } 3348 3573 } 3349 3574 3350 3350 - export class ComAtprotoSyncNS<T extends Env> { 3351 3351 - _server: Server<T>; 3575 3575 + export class ComAtprotoSyncNS { 3576 3576 + _server: Server; 3352 3577 3353 3353 - constructor(server: Server<T>) { 3578 3578 + constructor(server: Server) { 3354 3579 this._server = server; 3355 3580 } 3356 3581 3357 3357 - getHead<AV extends AuthVerifier>( 3358 3358 - cfg: ConfigOf< 3359 3359 - AV, 3360 3360 - ComAtprotoSyncGetHead.Handler<ExtractAuth<AV>>, 3361 3361 - ComAtprotoSyncGetHead.HandlerReqCtx<ExtractAuth<AV>> 3582 3582 + getHead<A extends Auth = void>( 3583 3583 + cfg: MethodConfigOrHandler< 3584 3584 + A, 3585 3585 + ComAtprotoSyncGetHead.QueryParams, 3586 3586 + ComAtprotoSyncGetHead.HandlerInput, 3587 3587 + ComAtprotoSyncGetHead.HandlerOutput 3362 3588 >, 3363 3589 ) { 3364 3590 const nsid = "com.atproto.sync.getHead"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3365 3591 return this._server.xrpc.method(nsid, cfg); 3366 3592 } 3367 3593 3368 3368 - getBlob<AV extends AuthVerifier>( 3369 3369 - cfg: ConfigOf< 3370 3370 - AV, 3371 3371 - ComAtprotoSyncGetBlob.Handler<ExtractAuth<AV>>, 3372 3372 - ComAtprotoSyncGetBlob.HandlerReqCtx<ExtractAuth<AV>> 3594 3594 + getBlob<A extends Auth = void>( 3595 3595 + cfg: MethodConfigOrHandler< 3596 3596 + A, 3597 3597 + ComAtprotoSyncGetBlob.QueryParams, 3598 3598 + ComAtprotoSyncGetBlob.HandlerInput, 3599 3599 + ComAtprotoSyncGetBlob.HandlerOutput 3373 3600 >, 3374 3601 ) { 3375 3602 const nsid = "com.atproto.sync.getBlob"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3376 3603 return this._server.xrpc.method(nsid, cfg); 3377 3604 } 3378 3605 3379 3379 - getRepo<AV extends AuthVerifier>( 3380 3380 - cfg: ConfigOf< 3381 3381 - AV, 3382 3382 - ComAtprotoSyncGetRepo.Handler<ExtractAuth<AV>>, 3383 3383 - ComAtprotoSyncGetRepo.HandlerReqCtx<ExtractAuth<AV>> 3606 3606 + getRepo<A extends Auth = void>( 3607 3607 + cfg: MethodConfigOrHandler< 3608 3608 + A, 3609 3609 + ComAtprotoSyncGetRepo.QueryParams, 3610 3610 + ComAtprotoSyncGetRepo.HandlerInput, 3611 3611 + ComAtprotoSyncGetRepo.HandlerOutput 3384 3612 >, 3385 3613 ) { 3386 3614 const nsid = "com.atproto.sync.getRepo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3387 3615 return this._server.xrpc.method(nsid, cfg); 3388 3616 } 3389 3617 3390 3390 - notifyOfUpdate<AV extends AuthVerifier>( 3391 3391 - cfg: ConfigOf< 3392 3392 - AV, 3393 3393 - ComAtprotoSyncNotifyOfUpdate.Handler<ExtractAuth<AV>>, 3394 3394 - ComAtprotoSyncNotifyOfUpdate.HandlerReqCtx<ExtractAuth<AV>> 3618 3618 + notifyOfUpdate<A extends Auth = void>( 3619 3619 + cfg: MethodConfigOrHandler< 3620 3620 + A, 3621 3621 + ComAtprotoSyncNotifyOfUpdate.QueryParams, 3622 3622 + ComAtprotoSyncNotifyOfUpdate.HandlerInput, 3623 3623 + ComAtprotoSyncNotifyOfUpdate.HandlerOutput 3395 3624 >, 3396 3625 ) { 3397 3626 const nsid = "com.atproto.sync.notifyOfUpdate"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3398 3627 return this._server.xrpc.method(nsid, cfg); 3399 3628 } 3400 3629 3401 3401 - requestCrawl<AV extends AuthVerifier>( 3402 3402 - cfg: ConfigOf< 3403 3403 - AV, 3404 3404 - ComAtprotoSyncRequestCrawl.Handler<ExtractAuth<AV>>, 3405 3405 - ComAtprotoSyncRequestCrawl.HandlerReqCtx<ExtractAuth<AV>> 3630 3630 + requestCrawl<A extends Auth = void>( 3631 3631 + cfg: MethodConfigOrHandler< 3632 3632 + A, 3633 3633 + ComAtprotoSyncRequestCrawl.QueryParams, 3634 3634 + ComAtprotoSyncRequestCrawl.HandlerInput, 3635 3635 + ComAtprotoSyncRequestCrawl.HandlerOutput 3406 3636 >, 3407 3637 ) { 3408 3638 const nsid = "com.atproto.sync.requestCrawl"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3409 3639 return this._server.xrpc.method(nsid, cfg); 3410 3640 } 3411 3641 3412 3412 - listBlobs<AV extends AuthVerifier>( 3413 3413 - cfg: ConfigOf< 3414 3414 - AV, 3415 3415 - ComAtprotoSyncListBlobs.Handler<ExtractAuth<AV>>, 3416 3416 - ComAtprotoSyncListBlobs.HandlerReqCtx<ExtractAuth<AV>> 3642 3642 + listBlobs<A extends Auth = void>( 3643 3643 + cfg: MethodConfigOrHandler< 3644 3644 + A, 3645 3645 + ComAtprotoSyncListBlobs.QueryParams, 3646 3646 + ComAtprotoSyncListBlobs.HandlerInput, 3647 3647 + ComAtprotoSyncListBlobs.HandlerOutput 3417 3648 >, 3418 3649 ) { 3419 3650 const nsid = "com.atproto.sync.listBlobs"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3420 3651 return this._server.xrpc.method(nsid, cfg); 3421 3652 } 3422 3653 3423 3423 - getLatestCommit<AV extends AuthVerifier>( 3424 3424 - cfg: ConfigOf< 3425 3425 - AV, 3426 3426 - ComAtprotoSyncGetLatestCommit.Handler<ExtractAuth<AV>>, 3427 3427 - ComAtprotoSyncGetLatestCommit.HandlerReqCtx<ExtractAuth<AV>> 3654 3654 + getLatestCommit<A extends Auth = void>( 3655 3655 + cfg: MethodConfigOrHandler< 3656 3656 + A, 3657 3657 + ComAtprotoSyncGetLatestCommit.QueryParams, 3658 3658 + ComAtprotoSyncGetLatestCommit.HandlerInput, 3659 3659 + ComAtprotoSyncGetLatestCommit.HandlerOutput 3428 3660 >, 3429 3661 ) { 3430 3662 const nsid = "com.atproto.sync.getLatestCommit"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3431 3663 return this._server.xrpc.method(nsid, cfg); 3432 3664 } 3433 3665 3434 3434 - subscribeRepos<AV extends StreamAuthVerifier>( 3435 3435 - cfg: ConfigOf< 3436 3436 - AV, 3437 3437 - ComAtprotoSyncSubscribeRepos.Handler<ExtractAuth<AV>>, 3438 3438 - ComAtprotoSyncSubscribeRepos.HandlerReqCtx<ExtractAuth<AV>> 3666 3666 + subscribeRepos<A extends Auth = void>( 3667 3667 + cfg: StreamConfigOrHandler< 3668 3668 + A, 3669 3669 + ComAtprotoSyncSubscribeRepos.QueryParams, 3670 3670 + ComAtprotoSyncSubscribeRepos.HandlerOutput 3439 3671 >, 3440 3672 ) { 3441 3673 const nsid = "com.atproto.sync.subscribeRepos"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3442 3674 return this._server.xrpc.streamMethod(nsid, cfg); 3443 3675 } 3444 3676 3445 3445 - getRepoStatus<AV extends AuthVerifier>( 3446 3446 - cfg: ConfigOf< 3447 3447 - AV, 3448 3448 - ComAtprotoSyncGetRepoStatus.Handler<ExtractAuth<AV>>, 3449 3449 - ComAtprotoSyncGetRepoStatus.HandlerReqCtx<ExtractAuth<AV>> 3677 3677 + getRepoStatus<A extends Auth = void>( 3678 3678 + cfg: MethodConfigOrHandler< 3679 3679 + A, 3680 3680 + ComAtprotoSyncGetRepoStatus.QueryParams, 3681 3681 + ComAtprotoSyncGetRepoStatus.HandlerInput, 3682 3682 + ComAtprotoSyncGetRepoStatus.HandlerOutput 3450 3683 >, 3451 3684 ) { 3452 3685 const nsid = "com.atproto.sync.getRepoStatus"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3453 3686 return this._server.xrpc.method(nsid, cfg); 3454 3687 } 3455 3688 3456 3456 - getRecord<AV extends AuthVerifier>( 3457 3457 - cfg: ConfigOf< 3458 3458 - AV, 3459 3459 - ComAtprotoSyncGetRecord.Handler<ExtractAuth<AV>>, 3460 3460 - ComAtprotoSyncGetRecord.HandlerReqCtx<ExtractAuth<AV>> 3689 3689 + getRecord<A extends Auth = void>( 3690 3690 + cfg: MethodConfigOrHandler< 3691 3691 + A, 3692 3692 + ComAtprotoSyncGetRecord.QueryParams, 3693 3693 + ComAtprotoSyncGetRecord.HandlerInput, 3694 3694 + ComAtprotoSyncGetRecord.HandlerOutput 3461 3695 >, 3462 3696 ) { 3463 3697 const nsid = "com.atproto.sync.getRecord"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3464 3698 return this._server.xrpc.method(nsid, cfg); 3465 3699 } 3466 3700 3467 3467 - listRepos<AV extends AuthVerifier>( 3468 3468 - cfg: ConfigOf< 3469 3469 - AV, 3470 3470 - ComAtprotoSyncListRepos.Handler<ExtractAuth<AV>>, 3471 3471 - ComAtprotoSyncListRepos.HandlerReqCtx<ExtractAuth<AV>> 3701 3701 + listRepos<A extends Auth = void>( 3702 3702 + cfg: MethodConfigOrHandler< 3703 3703 + A, 3704 3704 + ComAtprotoSyncListRepos.QueryParams, 3705 3705 + ComAtprotoSyncListRepos.HandlerInput, 3706 3706 + ComAtprotoSyncListRepos.HandlerOutput 3472 3707 >, 3473 3708 ) { 3474 3709 const nsid = "com.atproto.sync.listRepos"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3475 3710 return this._server.xrpc.method(nsid, cfg); 3476 3711 } 3477 3712 3478 3478 - getBlocks<AV extends AuthVerifier>( 3479 3479 - cfg: ConfigOf< 3480 3480 - AV, 3481 3481 - ComAtprotoSyncGetBlocks.Handler<ExtractAuth<AV>>, 3482 3482 - ComAtprotoSyncGetBlocks.HandlerReqCtx<ExtractAuth<AV>> 3713 3713 + getBlocks<A extends Auth = void>( 3714 3714 + cfg: MethodConfigOrHandler< 3715 3715 + A, 3716 3716 + ComAtprotoSyncGetBlocks.QueryParams, 3717 3717 + ComAtprotoSyncGetBlocks.HandlerInput, 3718 3718 + ComAtprotoSyncGetBlocks.HandlerOutput 3483 3719 >, 3484 3720 ) { 3485 3721 const nsid = "com.atproto.sync.getBlocks"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3486 3722 return this._server.xrpc.method(nsid, cfg); 3487 3723 } 3488 3724 3489 3489 - listReposByCollection<AV extends AuthVerifier>( 3490 3490 - cfg: ConfigOf< 3491 3491 - AV, 3492 3492 - ComAtprotoSyncListReposByCollection.Handler<ExtractAuth<AV>>, 3493 3493 - ComAtprotoSyncListReposByCollection.HandlerReqCtx<ExtractAuth<AV>> 3725 3725 + listReposByCollection<A extends Auth = void>( 3726 3726 + cfg: MethodConfigOrHandler< 3727 3727 + A, 3728 3728 + ComAtprotoSyncListReposByCollection.QueryParams, 3729 3729 + ComAtprotoSyncListReposByCollection.HandlerInput, 3730 3730 + ComAtprotoSyncListReposByCollection.HandlerOutput 3494 3731 >, 3495 3732 ) { 3496 3733 const nsid = "com.atproto.sync.listReposByCollection"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3497 3734 return this._server.xrpc.method(nsid, cfg); 3498 3735 } 3499 3736 3500 3500 - getCheckout<AV extends AuthVerifier>( 3501 3501 - cfg: ConfigOf< 3502 3502 - AV, 3503 3503 - ComAtprotoSyncGetCheckout.Handler<ExtractAuth<AV>>, 3504 3504 - ComAtprotoSyncGetCheckout.HandlerReqCtx<ExtractAuth<AV>> 3737 3737 + getCheckout<A extends Auth = void>( 3738 3738 + cfg: MethodConfigOrHandler< 3739 3739 + A, 3740 3740 + ComAtprotoSyncGetCheckout.QueryParams, 3741 3741 + ComAtprotoSyncGetCheckout.HandlerInput, 3742 3742 + ComAtprotoSyncGetCheckout.HandlerOutput 3505 3743 >, 3506 3744 ) { 3507 3745 const nsid = "com.atproto.sync.getCheckout"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 3509 3747 } 3510 3748 } 3511 3749 3512 3512 - export class ComAtprotoRepoNS<T extends Env> { 3513 3513 - _server: Server<T>; 3750 3750 + export class ComAtprotoRepoNS { 3751 3751 + _server: Server; 3514 3752 3515 3515 - constructor(server: Server<T>) { 3753 3753 + constructor(server: Server) { 3516 3754 this._server = server; 3517 3755 } 3518 3756 3519 3519 - listMissingBlobs<AV extends AuthVerifier>( 3520 3520 - cfg: ConfigOf< 3521 3521 - AV, 3522 3522 - ComAtprotoRepoListMissingBlobs.Handler<ExtractAuth<AV>>, 3523 3523 - ComAtprotoRepoListMissingBlobs.HandlerReqCtx<ExtractAuth<AV>> 3757 3757 + listMissingBlobs<A extends Auth = void>( 3758 3758 + cfg: MethodConfigOrHandler< 3759 3759 + A, 3760 3760 + ComAtprotoRepoListMissingBlobs.QueryParams, 3761 3761 + ComAtprotoRepoListMissingBlobs.HandlerInput, 3762 3762 + ComAtprotoRepoListMissingBlobs.HandlerOutput 3524 3763 >, 3525 3764 ) { 3526 3765 const nsid = "com.atproto.repo.listMissingBlobs"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3527 3766 return this._server.xrpc.method(nsid, cfg); 3528 3767 } 3529 3768 3530 3530 - createRecord<AV extends AuthVerifier>( 3531 3531 - cfg: ConfigOf< 3532 3532 - AV, 3533 3533 - ComAtprotoRepoCreateRecord.Handler<ExtractAuth<AV>>, 3534 3534 - ComAtprotoRepoCreateRecord.HandlerReqCtx<ExtractAuth<AV>> 3769 3769 + createRecord<A extends Auth = void>( 3770 3770 + cfg: MethodConfigOrHandler< 3771 3771 + A, 3772 3772 + ComAtprotoRepoCreateRecord.QueryParams, 3773 3773 + ComAtprotoRepoCreateRecord.HandlerInput, 3774 3774 + ComAtprotoRepoCreateRecord.HandlerOutput 3535 3775 >, 3536 3776 ) { 3537 3777 const nsid = "com.atproto.repo.createRecord"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3538 3778 return this._server.xrpc.method(nsid, cfg); 3539 3779 } 3540 3780 3541 3541 - deleteRecord<AV extends AuthVerifier>( 3542 3542 - cfg: ConfigOf< 3543 3543 - AV, 3544 3544 - ComAtprotoRepoDeleteRecord.Handler<ExtractAuth<AV>>, 3545 3545 - ComAtprotoRepoDeleteRecord.HandlerReqCtx<ExtractAuth<AV>> 3781 3781 + deleteRecord<A extends Auth = void>( 3782 3782 + cfg: MethodConfigOrHandler< 3783 3783 + A, 3784 3784 + ComAtprotoRepoDeleteRecord.QueryParams, 3785 3785 + ComAtprotoRepoDeleteRecord.HandlerInput, 3786 3786 + ComAtprotoRepoDeleteRecord.HandlerOutput 3546 3787 >, 3547 3788 ) { 3548 3789 const nsid = "com.atproto.repo.deleteRecord"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3549 3790 return this._server.xrpc.method(nsid, cfg); 3550 3791 } 3551 3792 3552 3552 - putRecord<AV extends AuthVerifier>( 3553 3553 - cfg: ConfigOf< 3554 3554 - AV, 3555 3555 - ComAtprotoRepoPutRecord.Handler<ExtractAuth<AV>>, 3556 3556 - ComAtprotoRepoPutRecord.HandlerReqCtx<ExtractAuth<AV>> 3793 3793 + putRecord<A extends Auth = void>( 3794 3794 + cfg: MethodConfigOrHandler< 3795 3795 + A, 3796 3796 + ComAtprotoRepoPutRecord.QueryParams, 3797 3797 + ComAtprotoRepoPutRecord.HandlerInput, 3798 3798 + ComAtprotoRepoPutRecord.HandlerOutput 3557 3799 >, 3558 3800 ) { 3559 3801 const nsid = "com.atproto.repo.putRecord"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3560 3802 return this._server.xrpc.method(nsid, cfg); 3561 3803 } 3562 3804 3563 3563 - uploadBlob<AV extends AuthVerifier>( 3564 3564 - cfg: ConfigOf< 3565 3565 - AV, 3566 3566 - ComAtprotoRepoUploadBlob.Handler<ExtractAuth<AV>>, 3567 3567 - ComAtprotoRepoUploadBlob.HandlerReqCtx<ExtractAuth<AV>> 3805 3805 + uploadBlob<A extends Auth = void>( 3806 3806 + cfg: MethodConfigOrHandler< 3807 3807 + A, 3808 3808 + ComAtprotoRepoUploadBlob.QueryParams, 3809 3809 + ComAtprotoRepoUploadBlob.HandlerInput, 3810 3810 + ComAtprotoRepoUploadBlob.HandlerOutput 3568 3811 >, 3569 3812 ) { 3570 3813 const nsid = "com.atproto.repo.uploadBlob"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3571 3814 return this._server.xrpc.method(nsid, cfg); 3572 3815 } 3573 3816 3574 3574 - importRepo<AV extends AuthVerifier>( 3575 3575 - cfg: ConfigOf< 3576 3576 - AV, 3577 3577 - ComAtprotoRepoImportRepo.Handler<ExtractAuth<AV>>, 3578 3578 - ComAtprotoRepoImportRepo.HandlerReqCtx<ExtractAuth<AV>> 3817 3817 + importRepo<A extends Auth = void>( 3818 3818 + cfg: MethodConfigOrHandler< 3819 3819 + A, 3820 3820 + ComAtprotoRepoImportRepo.QueryParams, 3821 3821 + ComAtprotoRepoImportRepo.HandlerInput, 3822 3822 + ComAtprotoRepoImportRepo.HandlerOutput 3579 3823 >, 3580 3824 ) { 3581 3825 const nsid = "com.atproto.repo.importRepo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3582 3826 return this._server.xrpc.method(nsid, cfg); 3583 3827 } 3584 3828 3585 3585 - describeRepo<AV extends AuthVerifier>( 3586 3586 - cfg: ConfigOf< 3587 3587 - AV, 3588 3588 - ComAtprotoRepoDescribeRepo.Handler<ExtractAuth<AV>>, 3589 3589 - ComAtprotoRepoDescribeRepo.HandlerReqCtx<ExtractAuth<AV>> 3829 3829 + describeRepo<A extends Auth = void>( 3830 3830 + cfg: MethodConfigOrHandler< 3831 3831 + A, 3832 3832 + ComAtprotoRepoDescribeRepo.QueryParams, 3833 3833 + ComAtprotoRepoDescribeRepo.HandlerInput, 3834 3834 + ComAtprotoRepoDescribeRepo.HandlerOutput 3590 3835 >, 3591 3836 ) { 3592 3837 const nsid = "com.atproto.repo.describeRepo"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3593 3838 return this._server.xrpc.method(nsid, cfg); 3594 3839 } 3595 3840 3596 3596 - getRecord<AV extends AuthVerifier>( 3597 3597 - cfg: ConfigOf< 3598 3598 - AV, 3599 3599 - ComAtprotoRepoGetRecord.Handler<ExtractAuth<AV>>, 3600 3600 - ComAtprotoRepoGetRecord.HandlerReqCtx<ExtractAuth<AV>> 3841 3841 + getRecord<A extends Auth = void>( 3842 3842 + cfg: MethodConfigOrHandler< 3843 3843 + A, 3844 3844 + ComAtprotoRepoGetRecord.QueryParams, 3845 3845 + ComAtprotoRepoGetRecord.HandlerInput, 3846 3846 + ComAtprotoRepoGetRecord.HandlerOutput 3601 3847 >, 3602 3848 ) { 3603 3849 const nsid = "com.atproto.repo.getRecord"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3604 3850 return this._server.xrpc.method(nsid, cfg); 3605 3851 } 3606 3852 3607 3607 - applyWrites<AV extends AuthVerifier>( 3608 3608 - cfg: ConfigOf< 3609 3609 - AV, 3610 3610 - ComAtprotoRepoApplyWrites.Handler<ExtractAuth<AV>>, 3611 3611 - ComAtprotoRepoApplyWrites.HandlerReqCtx<ExtractAuth<AV>> 3853 3853 + applyWrites<A extends Auth = void>( 3854 3854 + cfg: MethodConfigOrHandler< 3855 3855 + A, 3856 3856 + ComAtprotoRepoApplyWrites.QueryParams, 3857 3857 + ComAtprotoRepoApplyWrites.HandlerInput, 3858 3858 + ComAtprotoRepoApplyWrites.HandlerOutput 3612 3859 >, 3613 3860 ) { 3614 3861 const nsid = "com.atproto.repo.applyWrites"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3615 3862 return this._server.xrpc.method(nsid, cfg); 3616 3863 } 3617 3864 3618 3618 - listRecords<AV extends AuthVerifier>( 3619 3619 - cfg: ConfigOf< 3620 3620 - AV, 3621 3621 - ComAtprotoRepoListRecords.Handler<ExtractAuth<AV>>, 3622 3622 - ComAtprotoRepoListRecords.HandlerReqCtx<ExtractAuth<AV>> 3865 3865 + listRecords<A extends Auth = void>( 3866 3866 + cfg: MethodConfigOrHandler< 3867 3867 + A, 3868 3868 + ComAtprotoRepoListRecords.QueryParams, 3869 3869 + ComAtprotoRepoListRecords.HandlerInput, 3870 3870 + ComAtprotoRepoListRecords.HandlerOutput 3623 3871 >, 3624 3872 ) { 3625 3873 const nsid = "com.atproto.repo.listRecords"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type ··· 3627 3875 } 3628 3876 } 3629 3877 3630 3630 - export class ComAtprotoModerationNS<T extends Env> { 3631 3631 - _server: Server<T>; 3878 3878 + export class ComAtprotoModerationNS { 3879 3879 + _server: Server; 3632 3880 3633 3633 - constructor(server: Server<T>) { 3881 3881 + constructor(server: Server) { 3634 3882 this._server = server; 3635 3883 } 3636 3884 3637 3637 - createReport<AV extends AuthVerifier>( 3638 3638 - cfg: ConfigOf< 3639 3639 - AV, 3640 3640 - ComAtprotoModerationCreateReport.Handler<ExtractAuth<AV>>, 3641 3641 - ComAtprotoModerationCreateReport.HandlerReqCtx<ExtractAuth<AV>> 3885 3885 + createReport<A extends Auth = void>( 3886 3886 + cfg: MethodConfigOrHandler< 3887 3887 + A, 3888 3888 + ComAtprotoModerationCreateReport.QueryParams, 3889 3889 + ComAtprotoModerationCreateReport.HandlerInput, 3890 3890 + ComAtprotoModerationCreateReport.HandlerOutput 3642 3891 >, 3643 3892 ) { 3644 3893 const nsid = "com.atproto.moderation.createReport"; // @ts-ignore - userType.nsid is dynamically generated and TypeScript can't infer its type 3645 3894 return this._server.xrpc.method(nsid, cfg); 3646 3895 } 3647 3896 } 3648 3648 - 3649 3649 - type SharedRateLimitOpts<T> = { 3650 3650 - name: string; 3651 3651 - calcKey?: (ctx: T) => string | null; 3652 3652 - calcPoints?: (ctx: T) => number; 3653 3653 - }; 3654 3654 - type RouteRateLimitOpts<T> = { 3655 3655 - durationMs: number; 3656 3656 - points: number; 3657 3657 - calcKey?: (ctx: T) => string | null; 3658 3658 - calcPoints?: (ctx: T) => number; 3659 3659 - }; 3660 3660 - type HandlerOpts = { blobLimit?: number }; 3661 3661 - type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>; 3662 3662 - type ConfigOf<Auth, Handler, ReqCtx> = 3663 3663 - | Handler 3664 3664 - | { 3665 3665 - auth?: Auth; 3666 3666 - opts?: HandlerOpts; 3667 3667 - rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]; 3668 3668 - handler: Handler; 3669 3669 - }; 3670 3670 - type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract< 3671 3671 - Awaited<ReturnType<AV>>, 3672 3672 - { credentials: unknown } 3673 3673 - >;

+17 -6

services/appview/lexicon/types/app/bsky/actor/defs.ts

reviewed

··· 110 110 111 111 export interface ProfileAssociatedChat { 112 112 $type?: "app.bsky.actor.defs#profileAssociatedChat"; 113 113 - allowIncoming: "all" | "none" | "following" | (string & { __brand?: never }); 113 113 + allowIncoming: 114 114 + | "all" 115 115 + | "none" 116 116 + | "following" 117 117 + | (string & globalThis.Record<PropertyKey, never>); 114 118 } 115 119 116 120 const hashProfileAssociatedChat = "profileAssociatedChat"; ··· 205 209 | "show" 206 210 | "warn" 207 211 | "hide" 208 208 - | (string & { __brand?: never }); 212 212 + | (string & globalThis.Record<PropertyKey, never>); 209 213 } 210 214 211 215 const hashContentLabelPref = "contentLabelPref"; ··· 221 225 export interface SavedFeed { 222 226 $type?: "app.bsky.actor.defs#savedFeed"; 223 227 id: string; 224 224 - type: "feed" | "list" | "timeline" | (string & { __brand?: never }); 228 228 + type: 229 229 + | "feed" 230 230 + | "list" 231 231 + | "timeline" 232 232 + | (string & globalThis.Record<PropertyKey, never>); 225 233 value: string; 226 234 pinned: boolean; 227 235 } ··· 319 327 | "most-likes" 320 328 | "random" 321 329 | "hotness" 322 322 - | (string & { __brand?: never }); 330 330 + | (string & globalThis.Record<PropertyKey, never>); 323 331 /** Show followed users at the top of all replies. */ 324 332 prioritizeFollowedUsers?: boolean; 325 333 } ··· 353 361 export type MutedWordTarget = 354 362 | "content" 355 363 | "tag" 356 356 - | (string & { __brand?: never }); 364 364 + | (string & globalThis.Record<PropertyKey, never>); 357 365 358 366 /** A word that the account owner has muted. */ 359 367 export interface MutedWord { ··· 364 372 /** The intended targets of the muted word. */ 365 373 targets: (MutedWordTarget)[]; 366 374 /** Groups of users to apply the muted word to. If undefined, applies to all users. */ 367 367 - actorTarget: "all" | "exclude-following" | (string & { __brand?: never }); 375 375 + actorTarget: 376 376 + | "all" 377 377 + | "exclude-following" 378 378 + | (string & globalThis.Record<PropertyKey, never>); 368 379 /** The date and time at which the muted word will expire and no longer be applied. */ 369 380 expiresAt?: string; 370 381 }

+3 -15

services/appview/lexicon/types/app/bsky/actor/getPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 export type InputSchema = undefined; 10 8 11 9 export interface OutputSchema { 12 10 preferences: AppBskyActorDefs.Preferences; 13 11 } 14 12 15 15 - export type HandlerInput = undefined; 13 13 + export type HandlerInput = void; 16 14 17 15 export interface HandlerSuccess { 18 16 encoding: "application/json"; ··· 25 23 message?: string; 26 24 } 27 25 28 28 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput; 26 26 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/actor/getProfile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Handle or DID of account to fetch profile of. */ 10 8 actor: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 export type OutputSchema = AppBskyActorDefs.ProfileViewDetailed; 15 15 - export type HandlerInput = undefined; 12 12 + export type HandlerInput = void; 16 13 17 14 export interface HandlerSuccess { 18 15 encoding: "application/json"; ··· 25 22 message?: string; 26 23 } 27 24 28 28 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput; 25 25 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/actor/getProfiles.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actors: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 profiles: (AppBskyActorDefs.ProfileViewDetailed)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/actor/getSuggestions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 19 16 recId?: number; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/app/bsky/actor/profile.ts

reviewed

··· 11 11 const is$typed = _is$typed, validate = _validate; 12 12 const id = "app.bsky.actor.profile"; 13 13 14 14 - export interface MainRecord { 14 14 + export interface Record { 15 15 $type: "app.bsky.actor.profile"; 16 16 displayName?: string; 17 17 /** Free-form profile description text. */ ··· 27 27 [k: string]: unknown; 28 28 } 29 29 30 30 - export type Record = MainRecord; 31 31 - 32 32 - const hashMainRecord = "main"; 30 30 + const hashRecord = "main"; 33 31 34 34 - export function isMainRecord<V>(v: V) { 35 35 - return is$typed(v, id, hashMainRecord); 32 32 + export function isRecord<V>(v: V) { 33 33 + return is$typed(v, id, hashRecord); 36 34 } 37 35 38 38 - export function validateMainRecord<V>(v: V) { 39 39 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 36 36 + export function validateRecord<V>(v: V) { 37 37 + return validate<Record & V>(v, id, hashRecord, true); 40 38 }

+1 -15

services/appview/lexicon/types/app/bsky/actor/putPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 preferences: AppBskyActorDefs.Preferences; 12 10 } 13 11 14 14 - export type OutputSchema = undefined; 15 15 - 16 12 export interface HandlerInput { 17 13 encoding: "application/json"; 18 14 body: InputSchema; ··· 24 20 } 25 21 26 22 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/app/bsky/actor/searchActors.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** DEPRECATED: use 'q' instead. */ 10 8 term?: string; 11 9 /** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 12 10 q?: string; 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 21 18 actors: (AppBskyActorDefs.ProfileView)[]; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/actor/searchActorsTypeahead.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** DEPRECATED: use 'q' instead. */ 10 8 term?: string; 11 9 /** Search query prefix; not a full query string. */ 12 10 q?: string; 13 11 limit: number; 14 14 - } 15 15 - 12 12 + }; 16 13 export type InputSchema = undefined; 17 14 18 15 export interface OutputSchema { 19 16 actors: (AppBskyActorDefs.ProfileViewBasic)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -2

services/appview/lexicon/types/app/bsky/feed/defs.ts

reviewed

··· 248 248 contentMode?: 249 249 | "app.bsky.feed.defs#contentModeUnspecified" 250 250 | "app.bsky.feed.defs#contentModeVideo" 251 251 - | (string & { __brand?: never }); 251 251 + | (string & globalThis.Record<PropertyKey, never>); 252 252 indexedAt: string; 253 253 } 254 254 ··· 360 360 | "app.bsky.feed.defs#interactionReply" 361 361 | "app.bsky.feed.defs#interactionQuote" 362 362 | "app.bsky.feed.defs#interactionShare" 363 363 - | (string & { __brand?: never }); 363 363 + | (string & globalThis.Record<PropertyKey, never>); 364 364 /** Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton. */ 365 365 feedContext?: string; 366 366 }

+3 -15

services/appview/lexicon/types/app/bsky/feed/describeFeedGenerator.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "app.bsky.feed.describeFeedGenerator"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 export type InputSchema = undefined; 14 12 15 13 export interface OutputSchema { ··· 18 16 links?: Links; 19 17 } 20 18 21 21 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 22 20 23 21 export interface HandlerSuccess { 24 22 encoding: "application/json"; ··· 31 29 message?: string; 32 30 } 33 31 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess; 45 33 46 34 export interface Feed { 47 35 $type?: "app.bsky.feed.describeFeedGenerator#feed";

+7 -9

services/appview/lexicon/types/app/bsky/feed/generator.ts

reviewed

··· 11 11 const is$typed = _is$typed, validate = _validate; 12 12 const id = "app.bsky.feed.generator"; 13 13 14 14 - export interface MainRecord { 14 14 + export interface Record { 15 15 $type: "app.bsky.feed.generator"; 16 16 did: string; 17 17 displayName: string; ··· 24 24 contentMode?: 25 25 | "app.bsky.feed.defs#contentModeUnspecified" 26 26 | "app.bsky.feed.defs#contentModeVideo" 27 27 - | (string & { __brand?: never }); 27 27 + | (string & globalThis.Record<PropertyKey, never>); 28 28 createdAt: string; 29 29 [k: string]: unknown; 30 30 } 31 31 32 32 - export type Record = MainRecord; 33 33 - 34 34 - const hashMainRecord = "main"; 32 32 + const hashRecord = "main"; 35 33 36 36 - export function isMainRecord<V>(v: V) { 37 37 - return is$typed(v, id, hashMainRecord); 34 34 + export function isRecord<V>(v: V) { 35 35 + return is$typed(v, id, hashRecord); 38 36 } 39 37 40 40 - export function validateMainRecord<V>(v: V) { 41 41 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 38 38 + export function validateRecord<V>(v: V) { 39 39 + return validate<Record & V>(v, id, hashRecord, true); 42 40 }

+4 -17

services/appview/lexicon/types/app/bsky/feed/getActorFeeds.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feeds: (AppBskyFeedDefs.GeneratorView)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getActorLikes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feed: (AppBskyFeedDefs.FeedViewPost)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 32 29 error?: "BlockedActor" | "BlockedByActor"; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/app/bsky/feed/getAuthorFeed.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; ··· 16 14 | "posts_with_media" 17 15 | "posts_and_author_threads" 18 16 | "posts_with_video" 19 19 - | (string & { __brand?: never }); 17 17 + | (string & globalThis.Record<PropertyKey, never>); 20 18 includePins: boolean; 21 21 - } 22 22 - 19 19 + }; 23 20 export type InputSchema = undefined; 24 21 25 22 export interface OutputSchema { ··· 27 24 feed: (AppBskyFeedDefs.FeedViewPost)[]; 28 25 } 29 26 30 30 - export type HandlerInput = undefined; 27 27 + export type HandlerInput = void; 31 28 32 29 export interface HandlerSuccess { 33 30 encoding: "application/json"; ··· 41 38 error?: "BlockedActor" | "BlockedByActor"; 42 39 } 43 40 44 44 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 45 45 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 46 46 - auth: HA; 47 47 - params: QueryParams; 48 48 - input: HandlerInput; 49 49 - req: HonoRequest; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 52 52 - export type Handler<HA extends HandlerAuth = never> = ( 53 53 - ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getFeed.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 feed: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feed: (AppBskyFeedDefs.FeedViewPost)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 32 29 error?: "UnknownFeed"; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getFeedGenerator.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** AT-URI of the feed generator record. */ 10 8 feed: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 20 17 isValid: boolean; 21 18 } 22 19 23 23 - export type HandlerInput = undefined; 20 20 + export type HandlerInput = void; 24 21 25 22 export interface HandlerSuccess { 26 23 encoding: "application/json"; ··· 33 30 message?: string; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getFeedGenerators.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 feeds: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 feeds: (AppBskyFeedDefs.GeneratorView)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getFeedSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference to feed generator record describing the specific feed being requested. */ 10 8 feed: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 feed: (AppBskyFeedDefs.SkeletonFeedPost)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 33 30 error?: "UnknownFeed"; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getLikes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 import type * as AppBskyActorDefs from "../actor/defs.ts"; 9 7 10 8 const is$typed = _is$typed, validate = _validate; 11 9 const id = "app.bsky.feed.getLikes"; 12 10 13 13 - export interface QueryParams { 11 11 + export type QueryParams = { 14 12 /** AT-URI of the subject (eg, a post record). */ 15 13 uri: string; 16 14 /** CID of the subject record (aka, specific version of record), to filter likes. */ 17 15 cid?: string; 18 16 limit: number; 19 17 cursor?: string; 20 20 - } 21 21 - 18 18 + }; 22 19 export type InputSchema = undefined; 23 20 24 21 export interface OutputSchema { ··· 28 25 likes: (Like)[]; 29 26 } 30 27 31 31 - export type HandlerInput = undefined; 28 28 + export type HandlerInput = void; 32 29 33 30 export interface HandlerSuccess { 34 31 encoding: "application/json"; ··· 41 38 message?: string; 42 39 } 43 40 44 44 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 45 45 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 46 46 - auth: HA; 47 47 - params: QueryParams; 48 48 - input: HandlerInput; 49 49 - req: HonoRequest; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 52 52 - export type Handler<HA extends HandlerAuth = never> = ( 53 53 - ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess; 55 42 56 43 export interface Like { 57 44 $type?: "app.bsky.feed.getLikes#like";

+4 -17

services/appview/lexicon/types/app/bsky/feed/getListFeed.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) to the list record. */ 10 8 list: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 feed: (AppBskyFeedDefs.FeedViewPost)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 33 30 error?: "UnknownList"; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getPostThread.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as AppBskyFeedDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 /** Reference (AT-URI) to post record. */ 11 9 uri: string; 12 10 /** How many levels of reply depth should be included in response. */ 13 11 depth: number; 14 12 /** How many levels of parent (and grandparent, etc) post to include. */ 15 13 parentHeight: number; 16 16 - } 17 17 - 14 14 + }; 18 15 export type InputSchema = undefined; 19 16 20 17 export interface OutputSchema { ··· 26 23 threadgate?: AppBskyFeedDefs.ThreadgateView; 27 24 } 28 25 29 29 - export type HandlerInput = undefined; 26 26 + export type HandlerInput = void; 30 27 31 28 export interface HandlerSuccess { 32 29 encoding: "application/json"; ··· 40 37 error?: "NotFound"; 41 38 } 42 39 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 44 44 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: HonoRequest; 49 49 - resetRouteRateLimits: () => Promise<void>; 50 50 - }; 51 51 - export type Handler<HA extends HandlerAuth = never> = ( 52 52 - ctx: HandlerReqCtx<HA>, 53 53 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getPosts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** List of post AT-URIs to return hydrated views for. */ 10 8 uris: string[]; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { 16 13 posts: (AppBskyFeedDefs.PostView)[]; 17 14 } 18 15 19 19 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 20 17 21 18 export interface HandlerSuccess { 22 19 encoding: "application/json"; ··· 29 26 message?: string; 30 27 } 31 28 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getQuotes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of post record */ 10 8 uri: string; 11 9 /** If supplied, filters to quotes of specific version (by CID) of the post record. */ 12 10 cid?: string; 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 23 20 posts: (AppBskyFeedDefs.PostView)[]; 24 21 } 25 22 26 26 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 27 24 28 25 export interface HandlerSuccess { 29 26 encoding: "application/json"; ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getRepostedBy.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of post record */ 10 8 uri: string; 11 9 /** If supplied, filters to reposts of specific version (by CID) of the post record. */ 12 10 cid?: string; 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 23 20 repostedBy: (AppBskyActorDefs.ProfileView)[]; 24 21 } 25 22 26 26 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 27 24 28 25 export interface HandlerSuccess { 29 26 encoding: "application/json"; ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getSuggestedFeeds.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 feeds: (AppBskyFeedDefs.GeneratorView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/feed/getTimeline.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Variant 'algorithm' for timeline. Implementation-specific. NOTE: most feed flexibility has been moved to feed generator mechanism. */ 10 8 algorithm?: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 feed: (AppBskyFeedDefs.FeedViewPost)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/app/bsky/feed/like.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "app.bsky.feed.like"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "app.bsky.feed.like"; 13 13 subject: ComAtprotoRepoStrongRef.Main; 14 14 createdAt: string; 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+6 -8

services/appview/lexicon/types/app/bsky/feed/post.ts

reviewed

··· 16 16 const is$typed = _is$typed, validate = _validate; 17 17 const id = "app.bsky.feed.post"; 18 18 19 19 - export interface MainRecord { 19 19 + export interface Record { 20 20 $type: "app.bsky.feed.post"; 21 21 /** The primary post content. May be an empty string, if there are embeds. */ 22 22 text: string; ··· 42 42 [k: string]: unknown; 43 43 } 44 44 45 45 - export type Record = MainRecord; 46 46 - 47 47 - const hashMainRecord = "main"; 45 45 + const hashRecord = "main"; 48 46 49 49 - export function isMainRecord<V>(v: V) { 50 50 - return is$typed(v, id, hashMainRecord); 47 47 + export function isRecord<V>(v: V) { 48 48 + return is$typed(v, id, hashRecord); 51 49 } 52 50 53 53 - export function validateMainRecord<V>(v: V) { 54 54 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 51 51 + export function validateRecord<V>(v: V) { 52 52 + return validate<Record & V>(v, id, hashRecord, true); 55 53 } 56 54 57 55 export interface ReplyRef {

+6 -8

services/appview/lexicon/types/app/bsky/feed/postgate.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "app.bsky.feed.postgate"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "app.bsky.feed.postgate"; 13 13 createdAt: string; 14 14 /** Reference (AT-URI) to the post record. */ ··· 20 20 [k: string]: unknown; 21 21 } 22 22 23 23 - export type Record = MainRecord; 24 24 - 25 25 - const hashMainRecord = "main"; 23 23 + const hashRecord = "main"; 26 24 27 27 - export function isMainRecord<V>(v: V) { 28 28 - return is$typed(v, id, hashMainRecord); 25 25 + export function isRecord<V>(v: V) { 26 26 + return is$typed(v, id, hashRecord); 29 27 } 30 28 31 31 - export function validateMainRecord<V>(v: V) { 32 32 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 29 29 + export function validateRecord<V>(v: V) { 30 30 + return validate<Record & V>(v, id, hashRecord, true); 33 31 } 34 32 35 33 /** Disables embedding of this post. */

+6 -8

services/appview/lexicon/types/app/bsky/feed/repost.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "app.bsky.feed.repost"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "app.bsky.feed.repost"; 13 13 subject: ComAtprotoRepoStrongRef.Main; 14 14 createdAt: string; 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+5 -18

services/appview/lexicon/types/app/bsky/feed/searchPosts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q: string; 11 9 /** Specifies the ranking order of results. */ 12 12 - sort: "top" | "latest" | (string & { __brand?: never }); 10 10 + sort: "top" | "latest" | (string & globalThis.Record<PropertyKey, never>); 13 11 /** Filter results for posts after the indicated datetime (inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYYY-MM-DD). */ 14 12 since?: string; 15 13 /** Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD). */ ··· 29 27 limit: number; 30 28 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 31 29 cursor?: string; 32 32 - } 33 33 - 30 30 + }; 34 31 export type InputSchema = undefined; 35 32 36 33 export interface OutputSchema { ··· 40 37 posts: (AppBskyFeedDefs.PostView)[]; 41 38 } 42 39 43 43 - export type HandlerInput = undefined; 40 40 + export type HandlerInput = void; 44 41 45 42 export interface HandlerSuccess { 46 43 encoding: "application/json"; ··· 54 51 error?: "BadQueryString"; 55 52 } 56 53 57 57 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 58 58 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 59 59 - auth: HA; 60 60 - params: QueryParams; 61 61 - input: HandlerInput; 62 62 - req: HonoRequest; 63 63 - resetRouteRateLimits: () => Promise<void>; 64 64 - }; 65 65 - export type Handler<HA extends HandlerAuth = never> = ( 66 66 - ctx: HandlerReqCtx<HA>, 67 67 - ) => Promise<HandlerOutput> | HandlerOutput; 54 54 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -15

services/appview/lexicon/types/app/bsky/feed/sendInteractions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 interactions: (AppBskyFeedDefs.Interaction)[]; 12 10 } 13 11 14 14 - export type OutputSchema = Record<never, never>; 12 12 + export type OutputSchema = globalThis.Record<PropertyKey, never>; 15 13 16 14 export interface HandlerInput { 17 15 encoding: "application/json"; ··· 29 27 message?: string; 30 28 } 31 29 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/app/bsky/feed/threadgate.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "app.bsky.feed.threadgate"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "app.bsky.feed.threadgate"; 13 13 /** Reference (AT-URI) to the post record. */ 14 14 post: string; ··· 26 26 [k: string]: unknown; 27 27 } 28 28 29 29 - export type Record = MainRecord; 30 30 - 31 31 - const hashMainRecord = "main"; 29 29 + const hashRecord = "main"; 32 30 33 33 - export function isMainRecord<V>(v: V) { 34 34 - return is$typed(v, id, hashMainRecord); 31 31 + export function isRecord<V>(v: V) { 32 32 + return is$typed(v, id, hashRecord); 35 33 } 36 34 37 37 - export function validateMainRecord<V>(v: V) { 38 38 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 35 35 + export function validateRecord<V>(v: V) { 36 36 + return validate<Record & V>(v, id, hashRecord, true); 39 37 } 40 38 41 39 /** Allow replies from actors mentioned in your post. */

+6 -8

services/appview/lexicon/types/app/bsky/graph/block.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "app.bsky.graph.block"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "app.bsky.graph.block"; 12 12 /** DID of the account to be blocked. */ 13 13 subject: string; ··· 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+1 -1

services/appview/lexicon/types/app/bsky/graph/defs.ts

reviewed

··· 128 128 | "app.bsky.graph.defs#modlist" 129 129 | "app.bsky.graph.defs#curatelist" 130 130 | "app.bsky.graph.defs#referencelist" 131 131 - | (string & { __brand?: never }); 131 131 + | (string & globalThis.Record<PropertyKey, never>); 132 132 133 133 /** A list of actors to apply an aggregate moderation action (mute/block) on. */ 134 134 export const MODLIST = `${id}#modlist`;

+6 -8

services/appview/lexicon/types/app/bsky/graph/follow.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "app.bsky.graph.follow"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "app.bsky.graph.follow"; 12 12 subject: string; 13 13 createdAt: string; 14 14 [k: string]: unknown; 15 15 } 16 16 17 17 - export type Record = MainRecord; 17 17 + const hashRecord = "main"; 18 18 19 19 - const hashMainRecord = "main"; 20 20 - 21 21 - export function isMainRecord<V>(v: V) { 22 22 - return is$typed(v, id, hashMainRecord); 19 19 + export function isRecord<V>(v: V) { 20 20 + return is$typed(v, id, hashRecord); 23 21 } 24 22 25 25 - export function validateMainRecord<V>(v: V) { 26 26 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 23 23 + export function validateRecord<V>(v: V) { 24 24 + return validate<Record & V>(v, id, hashRecord, true); 27 25 }

+4 -17

services/appview/lexicon/types/app/bsky/graph/getActorStarterPacks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 starterPacks: (AppBskyGraphDefs.StarterPackViewBasic)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getBlocks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 blocks: (AppBskyActorDefs.ProfileView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getFollowers.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 19 16 followers: (AppBskyActorDefs.ProfileView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getFollows.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 19 16 follows: (AppBskyActorDefs.ProfileView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getKnownFollowers.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 19 16 followers: (AppBskyActorDefs.ProfileView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getList.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of the list record to hydrate. */ 10 8 list: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 20 17 items: (AppBskyGraphDefs.ListItemView)[]; 21 18 } 22 19 23 23 - export type HandlerInput = undefined; 20 20 + export type HandlerInput = void; 24 21 25 22 export interface HandlerSuccess { 26 23 encoding: "application/json"; ··· 33 30 message?: string; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getListBlocks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 lists: (AppBskyGraphDefs.ListView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getListMutes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 lists: (AppBskyGraphDefs.ListView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getLists.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The account (actor) to enumerate lists from. */ 10 8 actor: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 lists: (AppBskyGraphDefs.ListView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getMutes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 mutes: (AppBskyActorDefs.ProfileView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getRelationships.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as AppBskyGraphDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 /** Primary account requesting relationships for. */ 11 9 actor: string; 12 10 /** List of 'other' accounts to be related back to the primary. */ 13 11 others?: string[]; 14 14 - } 15 15 - 12 12 + }; 16 13 export type InputSchema = undefined; 17 14 18 15 export interface OutputSchema { ··· 24 21 )[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 38 35 error?: "ActorNotFound"; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getStarterPack.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of the starter pack record. */ 10 8 starterPack: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { 16 13 starterPack: AppBskyGraphDefs.StarterPackView; 17 14 } 18 15 19 19 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 20 17 21 18 export interface HandlerSuccess { 22 19 encoding: "application/json"; ··· 29 26 message?: string; 30 27 } 31 28 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getStarterPacks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 uris: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 starterPacks: (AppBskyGraphDefs.StarterPackViewBasic)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/graph/getSuggestedFollowsByActor.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { ··· 19 16 recId?: number; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/app/bsky/graph/list.ts

reviewed

··· 12 12 const is$typed = _is$typed, validate = _validate; 13 13 const id = "app.bsky.graph.list"; 14 14 15 15 - export interface MainRecord { 15 15 + export interface Record { 16 16 $type: "app.bsky.graph.list"; 17 17 purpose: AppBskyGraphDefs.ListPurpose; 18 18 /** Display name for list; can not be empty. */ ··· 25 25 [k: string]: unknown; 26 26 } 27 27 28 28 - export type Record = MainRecord; 29 29 - 30 30 - const hashMainRecord = "main"; 28 28 + const hashRecord = "main"; 31 29 32 32 - export function isMainRecord<V>(v: V) { 33 33 - return is$typed(v, id, hashMainRecord); 30 30 + export function isRecord<V>(v: V) { 31 31 + return is$typed(v, id, hashRecord); 34 32 } 35 33 36 36 - export function validateMainRecord<V>(v: V) { 37 37 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 34 34 + export function validateRecord<V>(v: V) { 35 35 + return validate<Record & V>(v, id, hashRecord, true); 38 36 }

+6 -8

services/appview/lexicon/types/app/bsky/graph/listblock.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "app.bsky.graph.listblock"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "app.bsky.graph.listblock"; 12 12 /** Reference (AT-URI) to the mod list record. */ 13 13 subject: string; ··· 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+6 -8

services/appview/lexicon/types/app/bsky/graph/listitem.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "app.bsky.graph.listitem"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "app.bsky.graph.listitem"; 12 12 /** The account which is included on the list. */ 13 13 subject: string; ··· 17 17 [k: string]: unknown; 18 18 } 19 19 20 20 - export type Record = MainRecord; 20 20 + const hashRecord = "main"; 21 21 22 22 - const hashMainRecord = "main"; 23 23 - 24 24 - export function isMainRecord<V>(v: V) { 25 25 - return is$typed(v, id, hashMainRecord); 22 22 + export function isRecord<V>(v: V) { 23 23 + return is$typed(v, id, hashRecord); 26 24 } 27 25 28 28 - export function validateMainRecord<V>(v: V) { 29 29 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 26 26 + export function validateRecord<V>(v: V) { 27 27 + return validate<Record & V>(v, id, hashRecord, true); 30 28 }

+1 -16

services/appview/lexicon/types/app/bsky/graph/muteActor.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 actor: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/app/bsky/graph/muteActorList.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 list: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/app/bsky/graph/muteThread.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 root: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/app/bsky/graph/searchStarterPacks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 starterPacks: (AppBskyGraphDefs.StarterPackViewBasic)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/app/bsky/graph/starterpack.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "app.bsky.graph.starterpack"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "app.bsky.graph.starterpack"; 13 13 /** Display name for starter pack; can not be empty. */ 14 14 name: string; ··· 21 21 [k: string]: unknown; 22 22 } 23 23 24 24 - export type Record = MainRecord; 25 25 - 26 26 - const hashMainRecord = "main"; 24 24 + const hashRecord = "main"; 27 25 28 28 - export function isMainRecord<V>(v: V) { 29 29 - return is$typed(v, id, hashMainRecord); 26 26 + export function isRecord<V>(v: V) { 27 27 + return is$typed(v, id, hashRecord); 30 28 } 31 29 32 32 - export function validateMainRecord<V>(v: V) { 33 33 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 30 30 + export function validateRecord<V>(v: V) { 31 31 + return validate<Record & V>(v, id, hashRecord, true); 34 32 } 35 33 36 34 export interface FeedItem {

+1 -16

services/appview/lexicon/types/app/bsky/graph/unmuteActor.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 actor: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/app/bsky/graph/unmuteActorList.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 list: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/app/bsky/graph/unmuteThread.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 root: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/app/bsky/labeler/getServices.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as AppBskyLabelerDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 dids: string[]; 11 9 detailed: boolean; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 21 18 )[]; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/app/bsky/labeler/service.ts

reviewed

··· 11 11 const is$typed = _is$typed, validate = _validate; 12 12 const id = "app.bsky.labeler.service"; 13 13 14 14 - export interface MainRecord { 14 14 + export interface Record { 15 15 $type: "app.bsky.labeler.service"; 16 16 policies: AppBskyLabelerDefs.LabelerPolicies; 17 17 labels?: $Typed<ComAtprotoLabelDefs.SelfLabels> | { $type: string }; ··· 25 25 [k: string]: unknown; 26 26 } 27 27 28 28 - export type Record = MainRecord; 29 29 - 30 30 - const hashMainRecord = "main"; 28 28 + const hashRecord = "main"; 31 29 32 32 - export function isMainRecord<V>(v: V) { 33 33 - return is$typed(v, id, hashMainRecord); 30 30 + export function isRecord<V>(v: V) { 31 31 + return is$typed(v, id, hashRecord); 34 32 } 35 33 36 36 - export function validateMainRecord<V>(v: V) { 37 37 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 34 34 + export function validateRecord<V>(v: V) { 35 35 + return validate<Record & V>(v, id, hashRecord, true); 38 36 }

+4 -18

services/appview/lexicon/types/app/bsky/notification/getUnreadCount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 priority?: boolean; 9 6 seenAt?: string; 10 10 - } 11 11 - 7 7 + }; 12 8 export type InputSchema = undefined; 13 9 14 10 export interface OutputSchema { 15 11 count: number; 16 12 } 17 13 18 18 - export type HandlerInput = undefined; 14 14 + export type HandlerInput = void; 19 15 20 16 export interface HandlerSuccess { 21 17 encoding: "application/json"; ··· 28 24 message?: string; 29 25 } 30 26 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 27 27 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/app/bsky/notification/listNotifications.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 import type * as AppBskyActorDefs from "../actor/defs.ts"; 9 7 import type * as ComAtprotoLabelDefs from "../../../com/atproto/label/defs.ts"; 10 8 11 9 const is$typed = _is$typed, validate = _validate; 12 10 const id = "app.bsky.notification.listNotifications"; 13 11 14 14 - export interface QueryParams { 12 12 + export type QueryParams = { 15 13 /** Notification reasons to include in response. */ 16 14 reasons?: string[]; 17 15 limit: number; 18 16 priority?: boolean; 19 17 cursor?: string; 20 18 seenAt?: string; 21 21 - } 22 22 - 19 19 + }; 23 20 export type InputSchema = undefined; 24 21 25 22 export interface OutputSchema { ··· 29 26 seenAt?: string; 30 27 } 31 28 32 32 - export type HandlerInput = undefined; 29 29 + export type HandlerInput = void; 33 30 34 31 export interface HandlerSuccess { 35 32 encoding: "application/json"; ··· 42 39 message?: string; 43 40 } 44 41 45 45 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 46 46 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 47 47 - auth: HA; 48 48 - params: QueryParams; 49 49 - input: HandlerInput; 50 50 - req: HonoRequest; 51 51 - resetRouteRateLimits: () => Promise<void>; 52 52 - }; 53 53 - export type Handler<HA extends HandlerAuth = never> = ( 54 54 - ctx: HandlerReqCtx<HA>, 55 55 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess; 56 43 57 44 export interface Notification { 58 45 $type?: "app.bsky.notification.listNotifications#notification"; ··· 68 55 | "reply" 69 56 | "quote" 70 57 | "starterpack-joined" 71 71 - | (string & { __brand?: never }); 58 58 + | (string & globalThis.Record<PropertyKey, never>); 72 59 reasonSubject?: string; 73 60 record: { [_ in string]: unknown }; 74 61 isRead: boolean;

+1 -16

services/appview/lexicon/types/app/bsky/notification/putPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 priority: boolean; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+6 -17

services/appview/lexicon/types/app/bsky/notification/registerPush.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 serviceDid: string; 11 8 token: string; 12 12 - platform: "ios" | "android" | "web" | (string & { __brand?: never }); 9 9 + platform: 10 10 + | "ios" 11 11 + | "android" 12 12 + | "web" 13 13 + | (string & globalThis.Record<PropertyKey, never>); 13 14 appId: string; 14 15 } 15 16 16 16 - export type OutputSchema = undefined; 17 17 - 18 17 export interface HandlerInput { 19 18 encoding: "application/json"; 20 19 body: InputSchema; ··· 26 25 } 27 26 28 27 export type HandlerOutput = HandlerError | void; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/app/bsky/notification/updateSeen.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 seenAt: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+3 -16

services/appview/lexicon/types/app/bsky/unspecced/getConfig.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { 11 8 checkEmailConfirmed?: boolean; 12 9 } 13 10 14 14 - export type HandlerInput = undefined; 11 11 + export type HandlerInput = void; 15 12 16 13 export interface HandlerSuccess { 17 14 encoding: "application/json"; ··· 24 21 message?: string; 25 22 } 26 23 27 27 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput; 24 24 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/unspecced/getPopularFeedGenerators.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyFeedDefs from "../feed/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 9 query?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feeds: (AppBskyFeedDefs.GeneratorView)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/unspecced/getSuggestionsSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. */ 10 8 viewer?: string; 11 9 limit: number; 12 10 cursor?: string; 13 11 /** DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer. */ 14 12 relativeToDid?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 25 22 recId?: number; 26 23 } 27 24 28 28 - export type HandlerInput = undefined; 25 25 + export type HandlerInput = void; 29 26 30 27 export interface HandlerSuccess { 31 28 encoding: "application/json"; ··· 38 35 message?: string; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+7 -16

services/appview/lexicon/types/app/bsky/unspecced/getTaggedSuggestions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "app.bsky.unspecced.getTaggedSuggestions"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 export type InputSchema = undefined; 14 12 15 13 export interface OutputSchema { 16 14 suggestions: (Suggestion)[]; 17 15 } 18 16 19 19 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 20 18 21 19 export interface HandlerSuccess { 22 20 encoding: "application/json"; ··· 29 27 message?: string; 30 28 } 31 29 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess; 43 31 44 32 export interface Suggestion { 45 33 $type?: "app.bsky.unspecced.getTaggedSuggestions#suggestion"; 46 34 tag: string; 47 47 - subjectType: "actor" | "feed" | (string & { __brand?: never }); 35 35 + subjectType: 36 36 + | "actor" 37 37 + | "feed" 38 38 + | (string & globalThis.Record<PropertyKey, never>); 48 39 subject: string; 49 40 } 50 41

+4 -17

services/appview/lexicon/types/app/bsky/unspecced/getTrendingTopics.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. */ 10 8 viewer?: string; 11 9 limit: number; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 suggested: (AppBskyUnspeccedDefs.TrendingTopic)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/unspecced/searchActorsSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax. */ 10 8 q: string; 11 9 /** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. */ ··· 15 13 limit: number; 16 14 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 17 15 cursor?: string; 18 18 - } 19 19 - 16 16 + }; 20 17 export type InputSchema = undefined; 21 18 22 19 export interface OutputSchema { ··· 26 23 actors: (AppBskyUnspeccedDefs.SkeletonSearchActor)[]; 27 24 } 28 25 29 29 - export type HandlerInput = undefined; 26 26 + export type HandlerInput = void; 30 27 31 28 export interface HandlerSuccess { 32 29 encoding: "application/json"; ··· 40 37 error?: "BadQueryString"; 41 38 } 42 39 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 44 44 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: HonoRequest; 49 49 - resetRouteRateLimits: () => Promise<void>; 50 50 - }; 51 51 - export type Handler<HA extends HandlerAuth = never> = ( 52 52 - ctx: HandlerReqCtx<HA>, 53 53 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/app/bsky/unspecced/searchPostsSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q: string; 11 9 /** Specifies the ranking order of results. */ 12 12 - sort: "top" | "latest" | (string & { __brand?: never }); 10 10 + sort: "top" | "latest" | (string & globalThis.Record<PropertyKey, never>); 13 11 /** Filter results for posts after the indicated datetime (inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYYY-MM-DD). */ 14 12 since?: string; 15 13 /** Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD). */ ··· 31 29 limit: number; 32 30 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 33 31 cursor?: string; 34 34 - } 35 35 - 32 32 + }; 36 33 export type InputSchema = undefined; 37 34 38 35 export interface OutputSchema { ··· 42 39 posts: (AppBskyUnspeccedDefs.SkeletonSearchPost)[]; 43 40 } 44 41 45 45 - export type HandlerInput = undefined; 42 42 + export type HandlerInput = void; 46 43 47 44 export interface HandlerSuccess { 48 45 encoding: "application/json"; ··· 56 53 error?: "BadQueryString"; 57 54 } 58 55 59 59 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 60 60 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 61 61 - auth: HA; 62 62 - params: QueryParams; 63 63 - input: HandlerInput; 64 64 - req: HonoRequest; 65 65 - resetRouteRateLimits: () => Promise<void>; 66 66 - }; 67 67 - export type Handler<HA extends HandlerAuth = never> = ( 68 68 - ctx: HandlerReqCtx<HA>, 69 69 - ) => Promise<HandlerOutput> | HandlerOutput; 56 56 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/app/bsky/unspecced/searchStarterPacksSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q: string; 11 9 /** DID of the account making the request (not included for public/unauthenticated queries). */ ··· 13 11 limit: number; 14 12 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 15 13 cursor?: string; 16 16 - } 17 17 - 14 14 + }; 18 15 export type InputSchema = undefined; 19 16 20 17 export interface OutputSchema { ··· 24 21 starterPacks: (AppBskyUnspeccedDefs.SkeletonSearchStarterPack)[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 38 35 error?: "BadQueryString"; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -1

services/appview/lexicon/types/app/bsky/video/defs.ts

reviewed

··· 16 16 state: 17 17 | "JOB_STATE_COMPLETED" 18 18 | "JOB_STATE_FAILED" 19 19 - | (string & { __brand?: never }); 19 19 + | (string & globalThis.Record<PropertyKey, never>); 20 20 /** Progress within the current processing state. */ 21 21 progress?: number; 22 22 blob?: BlobRef;

+4 -17

services/appview/lexicon/types/app/bsky/video/getJobStatus.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as AppBskyVideoDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 jobId: string; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 jobStatus: AppBskyVideoDefs.JobStatus; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -16

services/appview/lexicon/types/app/bsky/video/getUploadLimits.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { ··· 15 12 error?: string; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/app/bsky/video/uploadVideo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as AppBskyVideoDefs from "./defs.ts"; 8 6 9 9 - export type QueryParams = Record<never, never>; 7 7 + export type QueryParams = globalThis.Record<PropertyKey, never>; 10 8 export type InputSchema = string | Uint8Array | Blob; 11 9 12 10 export interface OutputSchema { ··· 29 27 message?: string; 30 28 } 31 29 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+11 -9

services/appview/lexicon/types/chat/bsky/actor/declaration.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "chat.bsky.actor.declaration"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "chat.bsky.actor.declaration"; 12 12 - allowIncoming: "all" | "none" | "following" | (string & { __brand?: never }); 12 12 + allowIncoming: 13 13 + | "all" 14 14 + | "none" 15 15 + | "following" 16 16 + | (string & globalThis.Record<PropertyKey, never>); 13 17 [k: string]: unknown; 14 18 } 15 19 16 16 - export type Record = MainRecord; 17 17 - 18 18 - const hashMainRecord = "main"; 20 20 + const hashRecord = "main"; 19 21 20 20 - export function isMainRecord<V>(v: V) { 21 21 - return is$typed(v, id, hashMainRecord); 22 22 + export function isRecord<V>(v: V) { 23 23 + return is$typed(v, id, hashRecord); 22 24 } 23 25 24 24 - export function validateMainRecord<V>(v: V) { 25 25 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 26 26 + export function validateRecord<V>(v: V) { 27 27 + return validate<Record & V>(v, id, hashRecord, true); 26 28 }

+4 -17

services/appview/lexicon/types/chat/bsky/actor/deleteAccount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 9 - export type OutputSchema = Record<never, never>; 10 10 - export type HandlerInput = undefined; 6 6 + export type OutputSchema = globalThis.Record<PropertyKey, never>; 7 7 + export type HandlerInput = void; 11 8 12 9 export interface HandlerSuccess { 13 10 encoding: "application/json"; ··· 20 17 message?: string; 21 18 } 22 19 23 23 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 24 24 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 25 25 - auth: HA; 26 26 - params: QueryParams; 27 27 - input: HandlerInput; 28 28 - req: HonoRequest; 29 29 - resetRouteRateLimits: () => Promise<void>; 30 30 - }; 31 31 - export type Handler<HA extends HandlerAuth = never> = ( 32 32 - ctx: HandlerReqCtx<HA>, 33 33 - ) => Promise<HandlerOutput> | HandlerOutput; 20 20 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -16

services/appview/lexicon/types/chat/bsky/actor/exportAccountData.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 export type InputSchema = undefined; 10 10 - export type OutputSchema = undefined; 11 11 - export type HandlerInput = undefined; 8 8 + export type HandlerInput = void; 12 9 13 10 export interface HandlerSuccess { 14 11 encoding: "application/jsonl"; ··· 21 18 message?: string; 22 19 } 23 20 24 24 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 25 25 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA; 27 27 - params: QueryParams; 28 28 - input: HandlerInput; 29 29 - req: HonoRequest; 30 30 - resetRouteRateLimits: () => Promise<void>; 31 31 - }; 32 32 - export type Handler<HA extends HandlerAuth = never> = ( 33 33 - ctx: HandlerReqCtx<HA>, 34 34 - ) => Promise<HandlerOutput> | HandlerOutput; 21 21 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -15

services/appview/lexicon/types/chat/bsky/convo/acceptConvo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 convoId: string; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -1

services/appview/lexicon/types/chat/bsky/convo/defs.ts

reviewed

··· 110 110 $type: string; 111 111 }; 112 112 muted: boolean; 113 113 - status?: "request" | "accepted" | (string & { __brand?: never }); 113 113 + status?: 114 114 + | "request" 115 115 + | "accepted" 116 116 + | (string & globalThis.Record<PropertyKey, never>); 114 117 unreadCount: number; 115 118 } 116 119

+2 -14

services/appview/lexicon/types/chat/bsky/convo/deleteMessageForSelf.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 convoId: string; ··· 30 28 message?: string; 31 29 } 32 30 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/chat/bsky/convo/getConvo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 convoId: string; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 convo: ChatBskyConvoDefs.ConvoView; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/chat/bsky/convo/getConvoAvailability.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 members: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { ··· 16 13 convo?: ChatBskyConvoDefs.ConvoView; 17 14 } 18 15 19 19 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 20 17 21 18 export interface HandlerSuccess { 22 19 encoding: "application/json"; ··· 29 26 message?: string; 30 27 } 31 28 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/chat/bsky/convo/getConvoForMembers.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 members: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 convo: ChatBskyConvoDefs.ConvoView; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/chat/bsky/convo/getLog.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ChatBskyConvoDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 24 21 )[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 37 34 message?: string; 38 35 } 39 36 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: HonoRequest; 46 46 - resetRouteRateLimits: () => Promise<void>; 47 47 - }; 48 48 - export type Handler<HA extends HandlerAuth = never> = ( 49 49 - ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/chat/bsky/convo/getMessages.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ChatBskyConvoDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 convoId: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 23 20 )[]; 24 21 } 25 22 26 26 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 27 24 28 25 export interface HandlerSuccess { 29 26 encoding: "application/json"; ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -15

services/appview/lexicon/types/chat/bsky/convo/leaveConvo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 convoId: string; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+9 -19

services/appview/lexicon/types/chat/bsky/convo/listConvos.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - readState?: "unread" | (string & { __brand?: never }); 12 12 - status?: "request" | "accepted" | (string & { __brand?: never }); 13 13 - } 14 14 - 9 9 + readState?: "unread" | (string & globalThis.Record<PropertyKey, never>); 10 10 + status?: 11 11 + | "request" 12 12 + | "accepted" 13 13 + | (string & globalThis.Record<PropertyKey, never>); 14 14 + }; 15 15 export type InputSchema = undefined; 16 16 17 17 export interface OutputSchema { ··· 19 19 convos: (ChatBskyConvoDefs.ConvoView)[]; 20 20 } 21 21 22 22 - export type HandlerInput = undefined; 22 22 + export type HandlerInput = void; 23 23 24 24 export interface HandlerSuccess { 25 25 encoding: "application/json"; ··· 32 32 message?: string; 33 33 } 34 34 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 35 35 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/chat/bsky/convo/muteConvo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 convoId: string; ··· 31 29 message?: string; 32 30 } 33 31 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/chat/bsky/convo/sendMessage.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 convoId: string; ··· 30 28 message?: string; 31 29 } 32 30 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/chat/bsky/convo/sendMessageBatch.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 import type * as ChatBskyConvoDefs from "./defs.ts"; 9 7 10 8 const is$typed = _is$typed, validate = _validate; 11 9 const id = "chat.bsky.convo.sendMessageBatch"; 12 10 13 13 - export type QueryParams = Record<never, never>; 11 11 + export type QueryParams = globalThis.Record<PropertyKey, never>; 14 12 15 13 export interface InputSchema { 16 14 items: (BatchItem)[]; ··· 36 34 message?: string; 37 35 } 38 36 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess; 50 38 51 39 export interface BatchItem { 52 40 $type?: "chat.bsky.convo.sendMessageBatch#batchItem";

+2 -14

services/appview/lexicon/types/chat/bsky/convo/unmuteConvo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 convoId: string; ··· 31 29 message?: string; 32 30 } 33 31 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -16

services/appview/lexicon/types/chat/bsky/convo/updateAllRead.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 10 - status?: "request" | "accepted" | (string & { __brand?: never }); 7 7 + status?: 8 8 + | "request" 9 9 + | "accepted" 10 10 + | (string & globalThis.Record<PropertyKey, never>); 11 11 } 12 12 13 13 export interface OutputSchema { ··· 31 31 message?: string; 32 32 } 33 33 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/chat/bsky/convo/updateRead.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ChatBskyConvoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 convoId: string; ··· 32 30 message?: string; 33 31 } 34 32 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/chat/bsky/moderation/getActorMetadata.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "chat.bsky.moderation.getActorMetadata"; 11 9 12 12 - export interface QueryParams { 10 10 + export type QueryParams = { 13 11 actor: string; 14 14 - } 15 15 - 12 12 + }; 16 13 export type InputSchema = undefined; 17 14 18 15 export interface OutputSchema { ··· 21 18 all: Metadata; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess; 48 35 49 36 export interface Metadata { 50 37 $type?: "chat.bsky.moderation.getActorMetadata#metadata";

+4 -17

services/appview/lexicon/types/chat/bsky/moderation/getMessageContext.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ChatBskyConvoDefs from "../convo/defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 /** Conversation that the message is from. NOTE: this field will eventually be required. */ 11 9 convoId?: string; 12 10 messageId: string; 13 11 before: number; 14 12 after: number; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 24 21 )[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 37 34 message?: string; 38 35 } 39 36 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: HonoRequest; 46 46 - resetRouteRateLimits: () => Promise<void>; 47 47 - }; 48 48 - export type Handler<HA extends HandlerAuth = never> = ( 49 49 - ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/chat/bsky/moderation/updateActorAccess.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 actor: string; ··· 12 9 ref?: string; 13 10 } 14 11 15 15 - export type OutputSchema = undefined; 16 16 - 17 12 export interface HandlerInput { 18 13 encoding: "application/json"; 19 14 body: InputSchema; ··· 25 20 } 26 21 27 22 export type HandlerOutput = HandlerError | void; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/admin/deleteAccount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 did: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/admin/disableAccountInvites.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 account: string; ··· 12 9 note?: string; 13 10 } 14 11 15 15 - export type OutputSchema = undefined; 16 16 - 17 12 export interface HandlerInput { 18 13 encoding: "application/json"; 19 14 body: InputSchema; ··· 25 20 } 26 21 27 22 export type HandlerOutput = HandlerError | void; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/admin/disableInviteCodes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 codes?: (string)[]; 11 8 accounts?: (string)[]; 12 9 } 13 10 14 14 - export type OutputSchema = undefined; 15 15 - 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; 18 13 body: InputSchema; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/admin/enableAccountInvites.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 account: string; ··· 12 9 note?: string; 13 10 } 14 11 15 15 - export type OutputSchema = undefined; 16 16 - 17 12 export interface HandlerInput { 18 13 encoding: "application/json"; 19 14 body: InputSchema; ··· 25 20 } 26 21 27 22 export type HandlerOutput = HandlerError | void; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/com/atproto/admin/getAccountInfo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoAdminDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 did: string; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 export type OutputSchema = ComAtprotoAdminDefs.AccountView; 14 14 - export type HandlerInput = undefined; 11 11 + export type HandlerInput = void; 15 12 16 13 export interface HandlerSuccess { 17 14 encoding: "application/json"; ··· 24 21 message?: string; 25 22 } 26 23 27 27 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput; 24 24 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/com/atproto/admin/getAccountInfos.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoAdminDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 dids: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 infos: (ComAtprotoAdminDefs.AccountView)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/com/atproto/admin/getInviteCodes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoServerDefs from "../server/defs.ts"; 7 5 8 8 - export interface QueryParams { 9 9 - sort: "recent" | "usage" | (string & { __brand?: never }); 6 6 + export type QueryParams = { 7 7 + sort: "recent" | "usage" | (string & globalThis.Record<PropertyKey, never>); 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 codes: (ComAtprotoServerDefs.InviteCode)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/com/atproto/admin/getSubjectStatus.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ComAtprotoAdminDefs from "./defs.ts"; 8 6 import type * as ComAtprotoRepoStrongRef from "../repo/strongRef.ts"; 9 7 10 10 - export interface QueryParams { 8 8 + export type QueryParams = { 11 9 did?: string; 12 10 uri?: string; 13 11 blob?: string; 14 14 - } 15 15 - 12 12 + }; 16 13 export type InputSchema = undefined; 17 14 18 15 export interface OutputSchema { ··· 25 22 deactivated?: ComAtprotoAdminDefs.StatusAttr; 26 23 } 27 24 28 28 - export type HandlerInput = undefined; 25 25 + export type HandlerInput = void; 29 26 30 27 export interface HandlerSuccess { 31 28 encoding: "application/json"; ··· 38 35 message?: string; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/com/atproto/admin/searchAccounts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoAdminDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 email?: string; 10 8 cursor?: string; 11 9 limit: number; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 accounts: (ComAtprotoAdminDefs.AccountView)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -15

services/appview/lexicon/types/com/atproto/admin/sendEmail.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 recipientDid: string; ··· 35 32 message?: string; 36 33 } 37 34 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA; 41 41 - params: QueryParams; 42 42 - input: HandlerInput; 43 43 - req: HonoRequest; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 46 46 - export type Handler<HA extends HandlerAuth = never> = ( 47 47 - ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 35 35 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/com/atproto/admin/updateAccountEmail.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** The handle or DID of the repo. */ ··· 12 9 email: string; 13 10 } 14 11 15 15 - export type OutputSchema = undefined; 16 16 - 17 12 export interface HandlerInput { 18 13 encoding: "application/json"; 19 14 body: InputSchema; ··· 25 20 } 26 21 27 22 export type HandlerOutput = HandlerError | void; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/admin/updateAccountHandle.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 did: string; 11 8 handle: string; 12 9 } 13 10 14 14 - export type OutputSchema = undefined; 15 15 - 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; 18 13 body: InputSchema; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/admin/updateAccountPassword.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 did: string; 11 8 password: string; 12 9 } 13 10 14 14 - export type OutputSchema = undefined; 15 15 - 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; 18 13 body: InputSchema; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+2 -14

services/appview/lexicon/types/com/atproto/admin/updateSubjectStatus.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ComAtprotoAdminDefs from "./defs.ts"; 8 6 import type * as ComAtprotoRepoStrongRef from "../repo/strongRef.ts"; 9 7 10 10 - export type QueryParams = Record<never, never>; 8 8 + export type QueryParams = globalThis.Record<PropertyKey, never>; 11 9 12 10 export interface InputSchema { 13 11 subject: ··· 44 42 message?: string; 45 43 } 46 44 47 47 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 48 48 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 49 49 - auth: HA; 50 50 - params: QueryParams; 51 51 - input: HandlerInput; 52 52 - req: HonoRequest; 53 53 - resetRouteRateLimits: () => Promise<void>; 54 54 - }; 55 55 - export type Handler<HA extends HandlerAuth = never> = ( 56 56 - ctx: HandlerReqCtx<HA>, 57 57 - ) => Promise<HandlerOutput> | HandlerOutput; 45 45 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -16

services/appview/lexicon/types/com/atproto/identity/getRecommendedDidCredentials.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { ··· 15 12 services?: { [_ in string]: unknown }; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -16

services/appview/lexicon/types/com/atproto/identity/requestPlcOperationSignature.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 9 - export type OutputSchema = undefined; 10 10 - export type HandlerInput = undefined; 6 6 + export type HandlerInput = void; 11 7 12 8 export interface HandlerError { 13 9 status: number; ··· 15 11 } 16 12 17 13 export type HandlerOutput = HandlerError | void; 18 18 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 19 19 - auth: HA; 20 20 - params: QueryParams; 21 21 - input: HandlerInput; 22 22 - req: HonoRequest; 23 23 - resetRouteRateLimits: () => Promise<void>; 24 24 - }; 25 25 - export type Handler<HA extends HandlerAuth = never> = ( 26 26 - ctx: HandlerReqCtx<HA>, 27 27 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -18

services/appview/lexicon/types/com/atproto/identity/resolveHandle.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The handle to resolve. */ 9 6 handle: string; 10 10 - } 11 11 - 7 7 + }; 12 8 export type InputSchema = undefined; 13 9 14 10 export interface OutputSchema { 15 11 did: string; 16 12 } 17 13 18 18 - export type HandlerInput = undefined; 14 14 + export type HandlerInput = void; 19 15 20 16 export interface HandlerSuccess { 21 17 encoding: "application/json"; ··· 28 24 message?: string; 29 25 } 30 26 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 27 27 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -15

services/appview/lexicon/types/com/atproto/identity/signPlcOperation.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** A token received through com.atproto.identity.requestPlcOperationSignature */ ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/com/atproto/identity/submitPlcOperation.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 operation: { [_ in string]: unknown }; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/identity/updateHandle.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** The new handle. */ 11 8 handle: string; 12 9 } 13 10 14 14 - export type OutputSchema = undefined; 15 15 - 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; 18 13 body: InputSchema; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+16 -4

services/appview/lexicon/types/com/atproto/label/defs.ts

reviewed

··· 79 79 /** The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). */ 80 80 identifier: string; 81 81 /** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */ 82 82 - severity: "inform" | "alert" | "none" | (string & { __brand?: never }); 82 82 + severity: 83 83 + | "inform" 84 84 + | "alert" 85 85 + | "none" 86 86 + | (string & globalThis.Record<PropertyKey, never>); 83 87 /** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. */ 84 84 - blurs: "content" | "media" | "none" | (string & { __brand?: never }); 88 88 + blurs: 89 89 + | "content" 90 90 + | "media" 91 91 + | "none" 92 92 + | (string & globalThis.Record<PropertyKey, never>); 85 93 /** The default setting for this label. */ 86 86 - defaultSetting: "ignore" | "warn" | "hide" | (string & { __brand?: never }); 94 94 + defaultSetting: 95 95 + | "ignore" 96 96 + | "warn" 97 97 + | "hide" 98 98 + | (string & globalThis.Record<PropertyKey, never>); 87 99 /** Does the user need to have adult content enabled in order to configure this label? */ 88 100 adultOnly?: boolean; 89 101 locales: (LabelValueDefinitionStrings)[]; ··· 136 148 | "nudity" 137 149 | "nsfl" 138 150 | "gore" 139 139 - | (string & { __brand?: never }); 151 151 + | (string & globalThis.Record<PropertyKey, never>);

+4 -17

services/appview/lexicon/types/com/atproto/label/queryLabels.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoLabelDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI. */ 10 8 uriPatterns: string[]; 11 9 /** Optional list of label sources (DIDs) to filter on. */ 12 10 sources?: string[]; 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 21 18 labels: (ComAtprotoLabelDefs.Label)[]; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -15

services/appview/lexicon/types/com/atproto/label/subscribeLabels.ts

reviewed

··· 4 4 import { validate as _validate } from "../../../../lexicons.ts"; 5 5 import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 import { type $Typed } from "../../../../util.ts"; 7 7 - import { ErrorFrame, HandlerAuth } from "@sprk/xrpc-server"; 8 8 - import { IncomingMessage } from "node:http"; 7 7 + import { ErrorFrame } from "@sprk/xrpc-server"; 9 8 import type * as ComAtprotoLabelDefs from "./defs.ts"; 10 9 11 10 const is$typed = _is$typed, validate = _validate; 12 11 const id = "com.atproto.label.subscribeLabels"; 13 12 14 14 - export interface QueryParams { 13 13 + export type QueryParams = { 15 14 /** The last known event seq number to backfill from. */ 16 15 cursor?: number; 17 17 - } 18 18 - 16 16 + }; 19 17 export type OutputSchema = $Typed<Labels> | $Typed<Info> | { $type: string }; 20 18 export type HandlerError = ErrorFrame<"FutureCursor">; 21 19 export type HandlerOutput = HandlerError | OutputSchema; 22 22 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 23 23 - auth: HA; 24 24 - params: QueryParams; 25 25 - req: IncomingMessage; 26 26 - signal: AbortSignal; 27 27 - }; 28 28 - export type Handler<HA extends HandlerAuth = never> = ( 29 29 - ctx: HandlerReqCtx<HA>, 30 30 - ) => AsyncIterable<HandlerOutput>; 31 20 32 21 export interface Labels { 33 22 $type?: "com.atproto.label.subscribeLabels#labels"; ··· 47 36 48 37 export interface Info { 49 38 $type?: "com.atproto.label.subscribeLabels#info"; 50 50 - name: "OutdatedCursor" | (string & { __brand?: never }); 39 39 + name: "OutdatedCursor" | (string & globalThis.Record<PropertyKey, never>); 51 40 message?: string; 52 41 } 53 42

+6 -8

services/appview/lexicon/types/com/atproto/lexicon/schema.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "com.atproto.lexicon.schema"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "com.atproto.lexicon.schema"; 12 12 /** Indicates the 'version' of the Lexicon language. Must be '1' for the current atproto/Lexicon schema system. */ 13 13 lexicon: number; 14 14 [k: string]: unknown; 15 15 } 16 16 17 17 - export type Record = MainRecord; 17 17 + const hashRecord = "main"; 18 18 19 19 - const hashMainRecord = "main"; 20 20 - 21 21 - export function isMainRecord<V>(v: V) { 22 22 - return is$typed(v, id, hashMainRecord); 19 19 + export function isRecord<V>(v: V) { 20 20 + return is$typed(v, id, hashRecord); 23 21 } 24 22 25 25 - export function validateMainRecord<V>(v: V) { 26 26 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 23 23 + export function validateRecord<V>(v: V) { 24 24 + return validate<Record & V>(v, id, hashRecord, true); 27 25 }

+2 -14

services/appview/lexicon/types/com/atproto/moderation/createReport.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ComAtprotoModerationDefs from "./defs.ts"; 8 6 import type * as ComAtprotoAdminDefs from "../admin/defs.ts"; 9 7 import type * as ComAtprotoRepoStrongRef from "../repo/strongRef.ts"; 10 8 11 11 - export type QueryParams = Record<never, never>; 9 9 + export type QueryParams = globalThis.Record<PropertyKey, never>; 12 10 13 11 export interface InputSchema { 14 12 reasonType: ComAtprotoModerationDefs.ReasonType; ··· 48 46 message?: string; 49 47 } 50 48 51 51 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 52 52 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 53 53 - auth: HA; 54 54 - params: QueryParams; 55 55 - input: HandlerInput; 56 56 - req: HonoRequest; 57 57 - resetRouteRateLimits: () => Promise<void>; 58 58 - }; 59 59 - export type Handler<HA extends HandlerAuth = never> = ( 60 60 - ctx: HandlerReqCtx<HA>, 61 61 - ) => Promise<HandlerOutput> | HandlerOutput; 49 49 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -2

services/appview/lexicon/types/com/atproto/moderation/defs.ts

reviewed

··· 11 11 | "com.atproto.moderation.defs#reasonRude" 12 12 | "com.atproto.moderation.defs#reasonOther" 13 13 | "com.atproto.moderation.defs#reasonAppeal" 14 14 - | (string & { __brand?: never }); 14 14 + | (string & globalThis.Record<PropertyKey, never>); 15 15 16 16 /** Spam: frequent unwanted promotion, replies, mentions */ 17 17 export const REASONSPAM = `${id}#reasonSpam`; ··· 33 33 | "account" 34 34 | "record" 35 35 | "chat" 36 36 - | (string & { __brand?: never }); 36 36 + | (string & globalThis.Record<PropertyKey, never>);

+10 -16

services/appview/lexicon/types/com/atproto/repo/applyWrites.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 6 import { type $Typed } from "../../../../util.ts"; 8 8 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 9 7 import type * as ComAtprotoRepoDefs from "./defs.ts"; 10 8 11 9 const is$typed = _is$typed, validate = _validate; 12 10 const id = "com.atproto.repo.applyWrites"; 13 11 14 14 - export type QueryParams = Record<never, never>; 12 12 + export type QueryParams = globalThis.Record<PropertyKey, never>; 15 13 16 14 export interface InputSchema { 17 15 /** The handle or DID of the repo (aka, current account). */ ··· 46 44 error?: "InvalidSwap"; 47 45 } 48 46 49 49 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 50 50 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 51 51 - auth: HA; 52 52 - params: QueryParams; 53 53 - input: HandlerInput; 54 54 - req: HonoRequest; 55 55 - resetRouteRateLimits: () => Promise<void>; 56 56 - }; 57 57 - export type Handler<HA extends HandlerAuth = never> = ( 58 58 - ctx: HandlerReqCtx<HA>, 59 59 - ) => Promise<HandlerOutput> | HandlerOutput; 47 47 + export type HandlerOutput = HandlerError | HandlerSuccess; 60 48 61 49 /** Operation which creates a new record. */ 62 50 export interface Create { ··· 115 103 $type?: "com.atproto.repo.applyWrites#createResult"; 116 104 uri: string; 117 105 cid: string; 118 118 - validationStatus?: "valid" | "unknown" | (string & { __brand?: never }); 106 106 + validationStatus?: 107 107 + | "valid" 108 108 + | "unknown" 109 109 + | (string & globalThis.Record<PropertyKey, never>); 119 110 } 120 111 121 112 const hashCreateResult = "createResult"; ··· 132 123 $type?: "com.atproto.repo.applyWrites#updateResult"; 133 124 uri: string; 134 125 cid: string; 135 135 - validationStatus?: "valid" | "unknown" | (string & { __brand?: never }); 126 126 + validationStatus?: 127 127 + | "valid" 128 128 + | "unknown" 129 129 + | (string & globalThis.Record<PropertyKey, never>); 136 130 } 137 131 138 132 const hashUpdateResult = "updateResult";

+6 -15

services/appview/lexicon/types/com/atproto/repo/createRecord.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoRepoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 /** The handle or DID of the repo (aka, current account). */ ··· 26 24 uri: string; 27 25 cid: string; 28 26 commit?: ComAtprotoRepoDefs.CommitMeta; 29 29 - validationStatus?: "valid" | "unknown" | (string & { __brand?: never }); 27 27 + validationStatus?: 28 28 + | "valid" 29 29 + | "unknown" 30 30 + | (string & globalThis.Record<PropertyKey, never>); 30 31 } 31 32 32 33 export interface HandlerInput { ··· 46 47 error?: "InvalidSwap"; 47 48 } 48 49 49 49 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 50 50 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 51 51 - auth: HA; 52 52 - params: QueryParams; 53 53 - input: HandlerInput; 54 54 - req: HonoRequest; 55 55 - resetRouteRateLimits: () => Promise<void>; 56 56 - }; 57 57 - export type Handler<HA extends HandlerAuth = never> = ( 58 58 - ctx: HandlerReqCtx<HA>, 59 59 - ) => Promise<HandlerOutput> | HandlerOutput; 50 50 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/com/atproto/repo/deleteRecord.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoRepoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 /** The handle or DID of the repo (aka, current account). */ ··· 41 39 error?: "InvalidSwap"; 42 40 } 43 41 44 44 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 45 45 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 46 46 - auth: HA; 47 47 - params: QueryParams; 48 48 - input: HandlerInput; 49 49 - req: HonoRequest; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 52 52 - export type Handler<HA extends HandlerAuth = never> = ( 53 53 - ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/repo/describeRepo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The handle or DID of the repo. */ 9 6 repo: string; 10 10 - } 11 11 - 7 7 + }; 12 8 export type InputSchema = undefined; 13 9 14 10 export interface OutputSchema { ··· 22 18 handleIsCorrect: boolean; 23 19 } 24 20 25 25 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 26 22 27 23 export interface HandlerSuccess { 28 24 encoding: "application/json"; ··· 35 31 message?: string; 36 32 } 37 33 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA; 41 41 - params: QueryParams; 42 42 - input: HandlerInput; 43 43 - req: HonoRequest; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 46 46 - export type Handler<HA extends HandlerAuth = never> = ( 47 47 - ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/repo/getRecord.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The handle or DID of the repo. */ 9 6 repo: string; 10 7 /** The NSID of the record collection. */ ··· 13 10 rkey: string; 14 11 /** The CID of the version of the record. If not specified, then return the most recent version. */ 15 12 cid?: string; 16 16 - } 17 17 - 13 13 + }; 18 14 export type InputSchema = undefined; 19 15 20 16 export interface OutputSchema { ··· 23 19 value: { [_ in string]: unknown }; 24 20 } 25 21 26 26 - export type HandlerInput = undefined; 22 22 + export type HandlerInput = void; 27 23 28 24 export interface HandlerSuccess { 29 25 encoding: "application/json"; ··· 37 33 error?: "RecordNotFound"; 38 34 } 39 35 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: HonoRequest; 46 46 - resetRouteRateLimits: () => Promise<void>; 47 47 - }; 48 48 - export type Handler<HA extends HandlerAuth = never> = ( 49 49 - ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -14

services/appview/lexicon/types/com/atproto/repo/importRepo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth } from "@sprk/xrpc-server"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 export type InputSchema = string | Uint8Array | Blob; 10 10 - export type OutputSchema = undefined; 11 8 12 9 export interface HandlerInput { 13 10 encoding: "application/vnd.ipld.car"; ··· 20 17 } 21 18 22 19 export type HandlerOutput = HandlerError | void; 23 23 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 24 24 - auth: HA; 25 25 - params: QueryParams; 26 26 - input: HandlerInput; 27 27 - req: HonoRequest; 28 28 - resetRouteRateLimits: () => Promise<void>; 29 29 - }; 30 30 - export type Handler<HA extends HandlerAuth = never> = ( 31 31 - ctx: HandlerReqCtx<HA>, 32 32 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/com/atproto/repo/listMissingBlobs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.repo.listMissingBlobs"; 11 9 12 12 - export interface QueryParams { 10 10 + export type QueryParams = { 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 21 18 blobs: (RecordBlob)[]; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess; 48 35 49 36 export interface RecordBlob { 50 37 $type?: "com.atproto.repo.listMissingBlobs#recordBlob";

+4 -17

services/appview/lexicon/types/com/atproto/repo/listRecords.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.repo.listRecords"; 11 9 12 12 - export interface QueryParams { 10 10 + export type QueryParams = { 13 11 /** The handle or DID of the repo. */ 14 12 repo: string; 15 13 /** The NSID of the record type. */ ··· 23 21 rkeyEnd?: string; 24 22 /** Flag to reverse the order of the returned records. */ 25 23 reverse?: boolean; 26 26 - } 27 27 - 24 24 + }; 28 25 export type InputSchema = undefined; 29 26 30 27 export interface OutputSchema { ··· 32 29 records: (Record)[]; 33 30 } 34 31 35 35 - export type HandlerInput = undefined; 32 32 + export type HandlerInput = void; 36 33 37 34 export interface HandlerSuccess { 38 35 encoding: "application/json"; ··· 45 42 message?: string; 46 43 } 47 44 48 48 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 49 49 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 50 50 - auth: HA; 51 51 - params: QueryParams; 52 52 - input: HandlerInput; 53 53 - req: HonoRequest; 54 54 - resetRouteRateLimits: () => Promise<void>; 55 55 - }; 56 56 - export type Handler<HA extends HandlerAuth = never> = ( 57 57 - ctx: HandlerReqCtx<HA>, 58 58 - ) => Promise<HandlerOutput> | HandlerOutput; 45 45 + export type HandlerOutput = HandlerError | HandlerSuccess; 59 46 60 47 export interface Record { 61 48 $type?: "com.atproto.repo.listRecords#record";

+6 -15

services/appview/lexicon/types/com/atproto/repo/putRecord.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoRepoDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 /** The handle or DID of the repo (aka, current account). */ ··· 28 26 uri: string; 29 27 cid: string; 30 28 commit?: ComAtprotoRepoDefs.CommitMeta; 31 31 - validationStatus?: "valid" | "unknown" | (string & { __brand?: never }); 29 29 + validationStatus?: 30 30 + | "valid" 31 31 + | "unknown" 32 32 + | (string & globalThis.Record<PropertyKey, never>); 32 33 } 33 34 34 35 export interface HandlerInput { ··· 48 49 error?: "InvalidSwap"; 49 50 } 50 51 51 51 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 52 52 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 53 53 - auth: HA; 54 54 - params: QueryParams; 55 55 - input: HandlerInput; 56 56 - req: HonoRequest; 57 57 - resetRouteRateLimits: () => Promise<void>; 58 58 - }; 59 59 - export type Handler<HA extends HandlerAuth = never> = ( 60 60 - ctx: HandlerReqCtx<HA>, 61 61 - ) => Promise<HandlerOutput> | HandlerOutput; 52 52 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/com/atproto/repo/uploadBlob.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 5 import { BlobRef } from "@atproto/lexicon"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 9 - export type QueryParams = Record<never, never>; 7 7 + export type QueryParams = globalThis.Record<PropertyKey, never>; 10 8 export type InputSchema = string | Uint8Array | Blob; 11 9 12 10 export interface OutputSchema { ··· 29 27 message?: string; 30 28 } 31 29 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -16

services/appview/lexicon/types/com/atproto/server/activateAccount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 9 - export type OutputSchema = undefined; 10 10 - export type HandlerInput = undefined; 6 6 + export type HandlerInput = void; 11 7 12 8 export interface HandlerError { 13 9 status: number; ··· 15 11 } 16 12 17 13 export type HandlerOutput = HandlerError | void; 18 18 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 19 19 - auth: HA; 20 20 - params: QueryParams; 21 21 - input: HandlerInput; 22 22 - req: HonoRequest; 23 23 - resetRouteRateLimits: () => Promise<void>; 24 24 - }; 25 25 - export type Handler<HA extends HandlerAuth = never> = ( 26 26 - ctx: HandlerReqCtx<HA>, 27 27 - ) => Promise<HandlerOutput> | HandlerOutput;

+3 -16

services/appview/lexicon/types/com/atproto/server/checkAccountStatus.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { ··· 19 16 importedBlobs: number; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/com/atproto/server/confirmEmail.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 email: string; 11 8 token: string; 12 9 } 13 13 - 14 14 - export type OutputSchema = undefined; 15 10 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; ··· 25 20 } 26 21 27 22 export type HandlerOutput = HandlerError | void; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput;

+2 -15

services/appview/lexicon/types/com/atproto/server/createAccount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 email?: string; ··· 58 55 | "IncompatibleDidDoc"; 59 56 } 60 57 61 61 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 62 62 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 63 63 - auth: HA; 64 64 - params: QueryParams; 65 65 - input: HandlerInput; 66 66 - req: HonoRequest; 67 67 - resetRouteRateLimits: () => Promise<void>; 68 68 - }; 69 69 - export type Handler<HA extends HandlerAuth = never> = ( 70 70 - ctx: HandlerReqCtx<HA>, 71 71 - ) => Promise<HandlerOutput> | HandlerOutput; 58 58 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/com/atproto/server/createAppPassword.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.server.createAppPassword"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 14 12 export interface InputSchema { 15 13 /** A short name for the App Password, to help distinguish them. */ ··· 37 35 error?: "AccountTakedown"; 38 36 } 39 37 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: HonoRequest; 46 46 - resetRouteRateLimits: () => Promise<void>; 47 47 - }; 48 48 - export type Handler<HA extends HandlerAuth = never> = ( 49 49 - ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess; 51 39 52 40 export interface AppPassword { 53 41 $type?: "com.atproto.server.createAppPassword#appPassword";

+2 -15

services/appview/lexicon/types/com/atproto/server/createInviteCode.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 useCount: number; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/com/atproto/server/createInviteCodes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.server.createInviteCodes"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 14 12 export interface InputSchema { 15 13 codeCount: number; ··· 37 35 message?: string; 38 36 } 39 37 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: HonoRequest; 46 46 - resetRouteRateLimits: () => Promise<void>; 47 47 - }; 48 48 - export type Handler<HA extends HandlerAuth = never> = ( 49 49 - ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess; 51 39 52 40 export interface AccountCodes { 53 41 $type?: "com.atproto.server.createInviteCodes#accountCodes";

+3 -16

services/appview/lexicon/types/com/atproto/server/createSession.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** Handle or other identifier supported by the server for the authenticating user. */ ··· 30 27 | "takendown" 31 28 | "suspended" 32 29 | "deactivated" 33 33 - | (string & { __brand?: never }); 30 30 + | (string & globalThis.Record<PropertyKey, never>); 34 31 } 35 32 36 33 export interface HandlerInput { ··· 50 47 error?: "AccountTakedown" | "AuthFactorTokenRequired"; 51 48 } 52 49 53 53 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 54 54 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 55 55 - auth: HA; 56 56 - params: QueryParams; 57 57 - input: HandlerInput; 58 58 - req: HonoRequest; 59 59 - resetRouteRateLimits: () => Promise<void>; 60 60 - }; 61 61 - export type Handler<HA extends HandlerAuth = never> = ( 62 62 - ctx: HandlerReqCtx<HA>, 63 63 - ) => Promise<HandlerOutput> | HandlerOutput; 50 50 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/com/atproto/server/deactivateAccount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** A recommendation to server as to how long they should hold onto the deactivated account before deleting. */ 11 8 deleteAfter?: string; 12 9 } 13 10 14 14 - export type OutputSchema = undefined; 15 15 - 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; 18 13 body: InputSchema; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/server/deleteAccount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 did: string; ··· 12 9 token: string; 13 10 } 14 11 15 15 - export type OutputSchema = undefined; 16 16 - 17 12 export interface HandlerInput { 18 13 encoding: "application/json"; 19 14 body: InputSchema; ··· 26 21 } 27 22 28 23 export type HandlerOutput = HandlerError | void; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput;

+2 -16

services/appview/lexicon/types/com/atproto/server/deleteSession.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 9 - export type OutputSchema = undefined; 10 10 - export type HandlerInput = undefined; 6 6 + export type HandlerInput = void; 11 7 12 8 export interface HandlerError { 13 9 status: number; ··· 15 11 } 16 12 17 13 export type HandlerOutput = HandlerError | void; 18 18 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 19 19 - auth: HA; 20 20 - params: QueryParams; 21 21 - input: HandlerInput; 22 22 - req: HonoRequest; 23 23 - resetRouteRateLimits: () => Promise<void>; 24 24 - }; 25 25 - export type Handler<HA extends HandlerAuth = never> = ( 26 26 - ctx: HandlerReqCtx<HA>, 27 27 - ) => Promise<HandlerOutput> | HandlerOutput;

+3 -15

services/appview/lexicon/types/com/atproto/server/describeServer.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.server.describeServer"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 export type InputSchema = undefined; 14 12 15 13 export interface OutputSchema { ··· 24 22 did: string; 25 23 } 26 24 27 27 - export type HandlerInput = undefined; 25 25 + export type HandlerInput = void; 28 26 29 27 export interface HandlerSuccess { 30 28 encoding: "application/json"; ··· 37 35 message?: string; 38 36 } 39 37 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: HonoRequest; 46 46 - resetRouteRateLimits: () => Promise<void>; 47 47 - }; 48 48 - export type Handler<HA extends HandlerAuth = never> = ( 49 49 - ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess; 51 39 52 40 export interface Links { 53 41 $type?: "com.atproto.server.describeServer#links";

+4 -17

services/appview/lexicon/types/com/atproto/server/getAccountInviteCodes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoServerDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 includeUsed: boolean; 10 8 /** Controls whether any new 'earned' but not 'created' invites should be created. */ 11 9 createAvailable: boolean; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { 17 14 codes: (ComAtprotoServerDefs.InviteCode)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 31 28 error?: "DuplicateCreate"; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/server/getServiceAuth.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The DID of the service that the token will be used to authenticate with */ 9 6 aud: string; 10 7 /** The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope. */ 11 8 exp?: number; 12 9 /** Lexicon (XRPC) method to bind the requested token to */ 13 10 lxm?: string; 14 14 - } 15 15 - 11 11 + }; 16 12 export type InputSchema = undefined; 17 13 18 14 export interface OutputSchema { 19 15 token: string; 20 16 } 21 17 22 22 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 23 19 24 20 export interface HandlerSuccess { 25 21 encoding: "application/json"; ··· 33 29 error?: "BadExpiration"; 34 30 } 35 31 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/com/atproto/server/getSession.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { ··· 20 17 | "takendown" 21 18 | "suspended" 22 19 | "deactivated" 23 23 - | (string & { __brand?: never }); 20 20 + | (string & globalThis.Record<PropertyKey, never>); 24 21 } 25 22 26 26 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 27 24 28 25 export interface HandlerSuccess { 29 26 encoding: "application/json"; ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -15

services/appview/lexicon/types/com/atproto/server/listAppPasswords.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.server.listAppPasswords"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 export type InputSchema = undefined; 14 12 15 13 export interface OutputSchema { 16 14 passwords: (AppPassword)[]; 17 15 } 18 16 19 19 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 20 18 21 19 export interface HandlerSuccess { 22 20 encoding: "application/json"; ··· 30 28 error?: "AccountTakedown"; 31 29 } 32 30 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess; 44 32 45 33 export interface AppPassword { 46 34 $type?: "com.atproto.server.listAppPasswords#appPassword";

+4 -17

services/appview/lexicon/types/com/atproto/server/refreshSession.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { ··· 19 16 | "takendown" 20 17 | "suspended" 21 18 | "deactivated" 22 22 - | (string & { __brand?: never }); 19 19 + | (string & globalThis.Record<PropertyKey, never>); 23 20 } 24 21 25 25 - export type HandlerInput = undefined; 22 22 + export type HandlerInput = void; 26 23 27 24 export interface HandlerSuccess { 28 25 encoding: "application/json"; ··· 36 33 error?: "AccountTakedown"; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -16

services/appview/lexicon/types/com/atproto/server/requestAccountDelete.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 9 - export type OutputSchema = undefined; 10 10 - export type HandlerInput = undefined; 6 6 + export type HandlerInput = void; 11 7 12 8 export interface HandlerError { 13 9 status: number; ··· 15 11 } 16 12 17 13 export type HandlerOutput = HandlerError | void; 18 18 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 19 19 - auth: HA; 20 20 - params: QueryParams; 21 21 - input: HandlerInput; 22 22 - req: HonoRequest; 23 23 - resetRouteRateLimits: () => Promise<void>; 24 24 - }; 25 25 - export type Handler<HA extends HandlerAuth = never> = ( 26 26 - ctx: HandlerReqCtx<HA>, 27 27 - ) => Promise<HandlerOutput> | HandlerOutput;

+2 -16

services/appview/lexicon/types/com/atproto/server/requestEmailConfirmation.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 9 - export type OutputSchema = undefined; 10 10 - export type HandlerInput = undefined; 6 6 + export type HandlerInput = void; 11 7 12 8 export interface HandlerError { 13 9 status: number; ··· 15 11 } 16 12 17 13 export type HandlerOutput = HandlerError | void; 18 18 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 19 19 - auth: HA; 20 20 - params: QueryParams; 21 21 - input: HandlerInput; 22 22 - req: HonoRequest; 23 23 - resetRouteRateLimits: () => Promise<void>; 24 24 - }; 25 25 - export type Handler<HA extends HandlerAuth = never> = ( 26 26 - ctx: HandlerReqCtx<HA>, 27 27 - ) => Promise<HandlerOutput> | HandlerOutput;

+3 -16

services/appview/lexicon/types/com/atproto/server/requestEmailUpdate.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { 11 8 tokenRequired: boolean; 12 9 } 13 10 14 14 - export type HandlerInput = undefined; 11 11 + export type HandlerInput = void; 15 12 16 13 export interface HandlerSuccess { 17 14 encoding: "application/json"; ··· 24 21 message?: string; 25 22 } 26 23 27 27 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput; 24 24 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/com/atproto/server/requestPasswordReset.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 email: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+2 -15

services/appview/lexicon/types/com/atproto/server/reserveSigningKey.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** The DID to reserve a key for. */ ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/com/atproto/server/resetPassword.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 token: string; 11 8 password: string; 12 9 } 13 13 - 14 14 - export type OutputSchema = undefined; 15 10 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; ··· 25 20 } 26 21 27 22 export type HandlerOutput = HandlerError | void; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/server/revokeAppPassword.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 name: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/server/updateEmail.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 email: string; ··· 13 10 token?: string; 14 11 } 15 12 16 16 - export type OutputSchema = undefined; 17 17 - 18 13 export interface HandlerInput { 19 14 encoding: "application/json"; 20 15 body: InputSchema; ··· 27 22 } 28 23 29 24 export type HandlerOutput = HandlerError | void; 30 30 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - input: HandlerInput; 34 34 - req: HonoRequest; 35 35 - resetRouteRateLimits: () => Promise<void>; 36 36 - }; 37 37 - export type Handler<HA extends HandlerAuth = never> = ( 38 38 - ctx: HandlerReqCtx<HA>, 39 39 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -18

services/appview/lexicon/types/com/atproto/sync/getBlob.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The DID of the account. */ 10 8 did: string; 11 9 /** The CID of the blob to fetch */ 12 10 cid: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 16 - export type OutputSchema = undefined; 17 17 - export type HandlerInput = undefined; 13 13 + export type HandlerInput = void; 18 14 19 15 export interface HandlerSuccess { 20 16 encoding: "*/*"; ··· 33 29 | "RepoDeactivated"; 34 30 } 35 31 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/sync/getBlocks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The DID of the repo. */ 10 8 did: string; 11 9 cids: string[]; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 15 - export type OutputSchema = undefined; 16 16 - export type HandlerInput = undefined; 12 12 + export type HandlerInput = void; 17 13 18 14 export interface HandlerSuccess { 19 15 encoding: "application/vnd.ipld.car"; ··· 32 28 | "RepoDeactivated"; 33 29 } 34 30 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/sync/getCheckout.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The DID of the repo. */ 10 8 did: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 14 - export type OutputSchema = undefined; 15 15 - export type HandlerInput = undefined; 11 11 + export type HandlerInput = void; 16 12 17 13 export interface HandlerSuccess { 18 14 encoding: "application/vnd.ipld.car"; ··· 25 21 message?: string; 26 22 } 27 23 28 28 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput; 24 24 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/sync/getHead.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The DID of the repo. */ 9 6 did: string; 10 10 - } 11 11 - 7 7 + }; 12 8 export type InputSchema = undefined; 13 9 14 10 export interface OutputSchema { 15 11 root: string; 16 12 } 17 13 18 18 - export type HandlerInput = undefined; 14 14 + export type HandlerInput = void; 19 15 20 16 export interface HandlerSuccess { 21 17 encoding: "application/json"; ··· 29 25 error?: "HeadNotFound"; 30 26 } 31 27 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/sync/getLatestCommit.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The DID of the repo. */ 9 6 did: string; 10 10 - } 11 11 - 7 7 + }; 12 8 export type InputSchema = undefined; 13 9 14 10 export interface OutputSchema { ··· 16 12 rev: string; 17 13 } 18 14 19 19 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 20 16 21 17 export interface HandlerSuccess { 22 18 encoding: "application/json"; ··· 34 30 | "RepoDeactivated"; 35 31 } 36 32 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/sync/getRecord.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The DID of the repo. */ 10 8 did: string; 11 9 collection: string; ··· 13 11 rkey: string; 14 12 /** DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit */ 15 13 commit?: string; 16 16 - } 17 17 - 14 14 + }; 18 15 export type InputSchema = undefined; 19 19 - export type OutputSchema = undefined; 20 20 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 21 17 22 18 export interface HandlerSuccess { 23 19 encoding: "application/vnd.ipld.car"; ··· 36 32 | "RepoDeactivated"; 37 33 } 38 34 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 35 35 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/sync/getRepo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The DID of the repo. */ 10 8 did: string; 11 9 /** The revision ('rev') of the repo to create a diff from. */ 12 10 since?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 16 - export type OutputSchema = undefined; 17 17 - export type HandlerInput = undefined; 13 13 + export type HandlerInput = void; 18 14 19 15 export interface HandlerSuccess { 20 16 encoding: "application/vnd.ipld.car"; ··· 32 28 | "RepoDeactivated"; 33 29 } 34 30 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -19

services/appview/lexicon/types/com/atproto/sync/getRepoStatus.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The DID of the repo. */ 9 6 did: string; 10 10 - } 11 11 - 7 7 + }; 12 8 export type InputSchema = undefined; 13 9 14 10 export interface OutputSchema { ··· 19 15 | "takendown" 20 16 | "suspended" 21 17 | "deactivated" 22 22 - | (string & { __brand?: never }); 18 18 + | (string & globalThis.Record<PropertyKey, never>); 23 19 /** Optional field, the current rev of the repo, if active=true */ 24 20 rev?: string; 25 21 } 26 22 27 27 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 28 24 29 25 export interface HandlerSuccess { 30 26 encoding: "application/json"; ··· 38 34 error?: "RepoNotFound"; 39 35 } 40 36 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -18

services/appview/lexicon/types/com/atproto/sync/listBlobs.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 /** The DID of the repo. */ 9 6 did: string; 10 7 /** Optional revision of the repo to list blobs since. */ 11 8 since?: string; 12 9 limit: number; 13 10 cursor?: string; 14 14 - } 15 15 - 11 11 + }; 16 12 export type InputSchema = undefined; 17 13 18 14 export interface OutputSchema { ··· 20 16 cids: (string)[]; 21 17 } 22 18 23 23 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 24 20 25 21 export interface HandlerSuccess { 26 22 encoding: "application/json"; ··· 38 34 | "RepoDeactivated"; 39 35 } 40 36 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/com/atproto/sync/listRepos.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.sync.listRepos"; 11 9 12 12 - export interface QueryParams { 10 10 + export type QueryParams = { 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 21 18 repos: (Repo)[]; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess; 48 35 49 36 export interface Repo { 50 37 $type?: "com.atproto.sync.listRepos#repo"; ··· 58 45 | "takendown" 59 46 | "suspended" 60 47 | "deactivated" 61 61 - | (string & { __brand?: never }); 48 48 + | (string & globalThis.Record<PropertyKey, never>); 62 49 } 63 50 64 51 const hashRepo = "repo";

+4 -17

services/appview/lexicon/types/com/atproto/sync/listReposByCollection.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "com.atproto.sync.listReposByCollection"; 11 9 12 12 - export interface QueryParams { 10 10 + export type QueryParams = { 13 11 collection: string; 14 12 /** Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists. */ 15 13 limit: number; 16 14 cursor?: string; 17 17 - } 18 18 - 15 15 + }; 19 16 export type InputSchema = undefined; 20 17 21 18 export interface OutputSchema { ··· 23 20 repos: (Repo)[]; 24 21 } 25 22 26 26 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 27 24 28 25 export interface HandlerSuccess { 29 26 encoding: "application/json"; ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess; 50 37 51 38 export interface Repo { 52 39 $type?: "com.atproto.sync.listReposByCollection#repo";

+1 -16

services/appview/lexicon/types/com/atproto/sync/notifyOfUpdate.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** Hostname of the current service (usually a PDS) that is notifying of update. */ 11 8 hostname: string; 12 9 } 13 10 14 14 - export type OutputSchema = undefined; 15 15 - 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; 18 13 body: InputSchema; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/com/atproto/sync/requestCrawl.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** Hostname of the current service (eg, PDS) that is requesting to be crawled. */ 11 8 hostname: string; 12 9 } 13 10 14 14 - export type OutputSchema = undefined; 15 15 - 16 11 export interface HandlerInput { 17 12 encoding: "application/json"; 18 13 body: InputSchema; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+10 -17

services/appview/lexicon/types/com/atproto/sync/subscribeRepos.ts

reviewed

··· 5 5 import { validate as _validate } from "../../../../lexicons.ts"; 6 6 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 import { type $Typed } from "../../../../util.ts"; 8 8 - import { ErrorFrame, HandlerAuth } from "@sprk/xrpc-server"; 9 9 - import { IncomingMessage } from "node:http"; 8 8 + import { ErrorFrame } from "@sprk/xrpc-server"; 10 9 11 10 const is$typed = _is$typed, validate = _validate; 12 11 const id = "com.atproto.sync.subscribeRepos"; 13 12 14 14 - export interface QueryParams { 13 13 + export type QueryParams = { 15 14 /** The last known event seq number to backfill from. */ 16 15 cursor?: number; 17 17 - } 18 18 - 16 16 + }; 19 17 export type OutputSchema = 20 18 | $Typed<Commit> 21 19 | $Typed<Identity> ··· 27 25 | { $type: string }; 28 26 export type HandlerError = ErrorFrame<"FutureCursor" | "ConsumerTooSlow">; 29 27 export type HandlerOutput = HandlerError | OutputSchema; 30 30 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - req: IncomingMessage; 34 34 - signal: AbortSignal; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => AsyncIterable<HandlerOutput>; 39 28 40 29 /** Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature. */ 41 30 export interface Commit { ··· 108 97 | "suspended" 109 98 | "deleted" 110 99 | "deactivated" 111 111 - | (string & { __brand?: never }); 100 100 + | (string & globalThis.Record<PropertyKey, never>); 112 101 } 113 102 114 103 const hashAccount = "account"; ··· 179 168 180 169 export interface Info { 181 170 $type?: "com.atproto.sync.subscribeRepos#info"; 182 182 - name: "OutdatedCursor" | (string & { __brand?: never }); 171 171 + name: "OutdatedCursor" | (string & globalThis.Record<PropertyKey, never>); 183 172 message?: string; 184 173 } 185 174 ··· 196 185 /** A repo operation, ie a mutation of a single record. */ 197 186 export interface RepoOp { 198 187 $type?: "com.atproto.sync.subscribeRepos#repoOp"; 199 199 - action: "create" | "update" | "delete" | (string & { __brand?: never }); 188 188 + action: 189 189 + | "create" 190 190 + | "update" 191 191 + | "delete" 192 192 + | (string & globalThis.Record<PropertyKey, never>); 200 193 path: string; 201 194 /** For creates and updates, the new record CID. For deletions, null. */ 202 195 cid: CID | null;

+3 -16

services/appview/lexicon/types/com/atproto/temp/addReservedHandle.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 handle: string; 11 8 } 12 9 13 13 - export type OutputSchema = Record<never, never>; 10 10 + export type OutputSchema = globalThis.Record<PropertyKey, never>; 14 11 15 12 export interface HandlerInput { 16 13 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -16

services/appview/lexicon/types/com/atproto/temp/checkSignupQueue.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { ··· 13 10 estimatedTimeMs?: number; 14 11 } 15 12 16 16 - export type HandlerInput = undefined; 13 13 + export type HandlerInput = void; 17 14 18 15 export interface HandlerSuccess { 19 16 encoding: "application/json"; ··· 26 23 message?: string; 27 24 } 28 25 29 29 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 30 30 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - input: HandlerInput; 34 34 - req: HonoRequest; 35 35 - resetRouteRateLimits: () => Promise<void>; 36 36 - }; 37 37 - export type Handler<HA extends HandlerAuth = never> = ( 38 38 - ctx: HandlerReqCtx<HA>, 39 39 - ) => Promise<HandlerOutput> | HandlerOutput; 26 26 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/com/atproto/temp/fetchLabels.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoLabelDefs from "../label/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 since?: number; 10 8 limit: number; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { 16 13 labels: (ComAtprotoLabelDefs.Label)[]; 17 14 } 18 15 19 19 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 20 17 21 18 export interface HandlerSuccess { 22 19 encoding: "application/json"; ··· 29 26 message?: string; 30 27 } 31 28 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/com/atproto/temp/requestPhoneVerification.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 phoneNumber: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+17 -6

services/appview/lexicon/types/so/sprk/actor/defs.ts

reviewed

··· 113 113 114 114 export interface ProfileAssociatedChat { 115 115 $type?: "so.sprk.actor.defs#profileAssociatedChat"; 116 116 - allowIncoming: "all" | "none" | "following" | (string & { __brand?: never }); 116 116 + allowIncoming: 117 117 + | "all" 118 118 + | "none" 119 119 + | "following" 120 120 + | (string & globalThis.Record<PropertyKey, never>); 117 121 } 118 122 119 123 const hashProfileAssociatedChat = "profileAssociatedChat"; ··· 207 211 | "show" 208 212 | "warn" 209 213 | "hide" 210 210 - | (string & { __brand?: never }); 214 214 + | (string & globalThis.Record<PropertyKey, never>); 211 215 } 212 216 213 217 const hashContentLabelPref = "contentLabelPref"; ··· 223 227 export interface SavedFeed { 224 228 $type?: "so.sprk.actor.defs#savedFeed"; 225 229 id: string; 226 226 - type: "feed" | "list" | "timeline" | (string & { __brand?: never }); 230 230 + type: 231 231 + | "feed" 232 232 + | "list" 233 233 + | "timeline" 234 234 + | (string & globalThis.Record<PropertyKey, never>); 227 235 value: string; 228 236 pinned: boolean; 229 237 } ··· 324 332 | "most-looks" 325 333 | "random" 326 334 | "hotness" 327 327 - | (string & { __brand?: never }); 335 335 + | (string & globalThis.Record<PropertyKey, never>); 328 336 /** Show followed users at the top of all replies. */ 329 337 prioritizeFollowedUsers?: boolean; 330 338 } ··· 358 366 export type MutedWordTarget = 359 367 | "content" 360 368 | "tag" 361 361 - | (string & { __brand?: never }); 369 369 + | (string & globalThis.Record<PropertyKey, never>); 362 370 363 371 /** A word that the account owner has muted. */ 364 372 export interface MutedWord { ··· 369 377 /** The intended targets of the muted word. */ 370 378 targets: (MutedWordTarget)[]; 371 379 /** Groups of users to apply the muted word to. If undefined, applies to all users. */ 372 372 - actorTarget: "all" | "exclude-following" | (string & { __brand?: never }); 380 380 + actorTarget: 381 381 + | "all" 382 382 + | "exclude-following" 383 383 + | (string & globalThis.Record<PropertyKey, never>); 373 384 /** The date and time at which the muted word will expire and no longer be applied. */ 374 385 expiresAt?: string; 375 386 }

+7 -17

services/appview/lexicon/types/so/sprk/actor/getPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { 11 11 - followMode?: "bsky" | "sprk" | (string & { __brand?: never }); 8 8 + followMode?: 9 9 + | "bsky" 10 10 + | "sprk" 11 11 + | (string & globalThis.Record<PropertyKey, never>); 12 12 } 13 13 14 14 - export type HandlerInput = undefined; 14 14 + export type HandlerInput = void; 15 15 16 16 export interface HandlerSuccess { 17 17 encoding: "application/json"; ··· 24 24 message?: string; 25 25 } 26 26 27 27 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput; 27 27 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/actor/getProfile.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Handle or DID of account to fetch profile of. */ 10 8 actor: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 export type OutputSchema = SoSprkActorDefs.ProfileViewDetailed; 15 15 - export type HandlerInput = undefined; 12 12 + export type HandlerInput = void; 16 13 17 14 export interface HandlerSuccess { 18 15 encoding: "application/json"; ··· 25 22 message?: string; 26 23 } 27 24 28 28 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput; 25 25 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/actor/getProfiles.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actors: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 profiles: (SoSprkActorDefs.ProfileViewDetailed)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/actor/getSuggestions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 19 16 recId?: number; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/so/sprk/actor/profile.ts

reviewed

··· 11 11 const is$typed = _is$typed, validate = _validate; 12 12 const id = "so.sprk.actor.profile"; 13 13 14 14 - export interface MainRecord { 14 14 + export interface Record { 15 15 $type: "so.sprk.actor.profile"; 16 16 displayName?: string; 17 17 /** Free-form profile description text. */ ··· 27 27 [k: string]: unknown; 28 28 } 29 29 30 30 - export type Record = MainRecord; 31 31 - 32 32 - const hashMainRecord = "main"; 30 30 + const hashRecord = "main"; 33 31 34 34 - export function isMainRecord<V>(v: V) { 35 35 - return is$typed(v, id, hashMainRecord); 32 32 + export function isRecord<V>(v: V) { 33 33 + return is$typed(v, id, hashRecord); 36 34 } 37 35 38 38 - export function validateMainRecord<V>(v: V) { 39 39 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 36 36 + export function validateRecord<V>(v: V) { 37 37 + return validate<Record & V>(v, id, hashRecord, true); 40 38 }

+5 -17

services/appview/lexicon/types/so/sprk/actor/putPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 10 - followMode?: "bsky" | "sprk" | (string & { __brand?: never }); 7 7 + followMode?: 8 8 + | "bsky" 9 9 + | "sprk" 10 10 + | (string & globalThis.Record<PropertyKey, never>); 11 11 } 12 12 13 13 - export type OutputSchema = undefined; 14 14 - 15 13 export interface HandlerInput { 16 14 encoding: "application/json"; 17 15 body: InputSchema; ··· 23 21 } 24 22 25 23 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/so/sprk/actor/searchActors.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q?: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 actors: (SoSprkActorDefs.ProfileView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/actor/searchActorsTypeahead.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query prefix; not a full query string. */ 10 8 q?: string; 11 9 limit: number; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { 17 14 actors: (SoSprkActorDefs.ProfileViewBasic)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/so/sprk/feed/audio.ts

reviewed

··· 11 11 const is$typed = _is$typed, validate = _validate; 12 12 const id = "so.sprk.feed.audio"; 13 13 14 14 - export interface MainRecord { 14 14 + export interface Record { 15 15 $type: "so.sprk.feed.audio"; 16 16 sound: BlobRef; 17 17 origin: ComAtprotoRepoStrongRef.Main; ··· 25 25 [k: string]: unknown; 26 26 } 27 27 28 28 - export type Record = MainRecord; 29 29 - 30 30 - const hashMainRecord = "main"; 28 28 + const hashRecord = "main"; 31 29 32 32 - export function isMainRecord<V>(v: V) { 33 33 - return is$typed(v, id, hashMainRecord); 30 30 + export function isRecord<V>(v: V) { 31 31 + return is$typed(v, id, hashRecord); 34 32 } 35 33 36 36 - export function validateMainRecord<V>(v: V) { 37 37 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 34 34 + export function validateRecord<V>(v: V) { 35 35 + return validate<Record & V>(v, id, hashRecord, true); 38 36 }

+2 -2

services/appview/lexicon/types/so/sprk/feed/defs.ts

reviewed

··· 319 319 contentMode?: 320 320 | "so.sprk.feed.defs#contentModeUnspecified" 321 321 | "so.sprk.feed.defs#contentModeVideo" 322 322 - | (string & { __brand?: never }); 322 322 + | (string & globalThis.Record<PropertyKey, never>); 323 323 indexedAt: string; 324 324 } 325 325 ··· 432 432 | "so.sprk.feed.defs#interactionReply" 433 433 | "so.sprk.feed.defs#interactionQuote" 434 434 | "so.sprk.feed.defs#interactionShare" 435 435 - | (string & { __brand?: never }); 435 435 + | (string & globalThis.Record<PropertyKey, never>); 436 436 /** Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton. */ 437 437 feedContext?: string; 438 438 }

+3 -15

services/appview/lexicon/types/so/sprk/feed/describeFeedGenerator.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "so.sprk.feed.describeFeedGenerator"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 export type InputSchema = undefined; 14 12 15 13 export interface OutputSchema { ··· 18 16 links?: Links; 19 17 } 20 18 21 21 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 22 20 23 21 export interface HandlerSuccess { 24 22 encoding: "application/json"; ··· 31 29 message?: string; 32 30 } 33 31 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess; 45 33 46 34 export interface Feed { 47 35 $type?: "so.sprk.feed.describeFeedGenerator#feed";

+7 -9

services/appview/lexicon/types/so/sprk/feed/generator.ts

reviewed

··· 11 11 const is$typed = _is$typed, validate = _validate; 12 12 const id = "so.sprk.feed.generator"; 13 13 14 14 - export interface MainRecord { 14 14 + export interface Record { 15 15 $type: "so.sprk.feed.generator"; 16 16 did: string; 17 17 displayName: string; ··· 24 24 contentMode?: 25 25 | "so.sprk.feed.defs#contentModeUnspecified" 26 26 | "so.sprk.feed.defs#contentModeVideo" 27 27 - | (string & { __brand?: never }); 27 27 + | (string & globalThis.Record<PropertyKey, never>); 28 28 createdAt: string; 29 29 [k: string]: unknown; 30 30 } 31 31 32 32 - export type Record = MainRecord; 33 33 - 34 34 - const hashMainRecord = "main"; 32 32 + const hashRecord = "main"; 35 33 36 36 - export function isMainRecord<V>(v: V) { 37 37 - return is$typed(v, id, hashMainRecord); 34 34 + export function isRecord<V>(v: V) { 35 35 + return is$typed(v, id, hashRecord); 38 36 } 39 37 40 40 - export function validateMainRecord<V>(v: V) { 41 41 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 38 38 + export function validateRecord<V>(v: V) { 39 39 + return validate<Record & V>(v, id, hashRecord, true); 42 40 }

+4 -17

services/appview/lexicon/types/so/sprk/feed/getActorFeeds.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feeds: (SoSprkFeedDefs.GeneratorView)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getActorLikes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feed: (SoSprkFeedDefs.FeedViewPost)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 32 29 error?: "BlockedActor" | "BlockedByActor"; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getActorLooks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feed: (SoSprkFeedDefs.FeedViewPost)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 32 29 error?: "BlockedActor" | "BlockedByActor"; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/so/sprk/feed/getAuthorFeed.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; ··· 16 14 | "posts_with_media" 17 15 | "posts_and_author_threads" 18 16 | "posts_with_video" 19 19 - | (string & { __brand?: never }); 17 17 + | (string & globalThis.Record<PropertyKey, never>); 20 18 includePins: boolean; 21 21 - } 22 22 - 19 19 + }; 23 20 export type InputSchema = undefined; 24 21 25 22 export interface OutputSchema { ··· 27 24 feed: (SoSprkFeedDefs.FeedViewPost)[]; 28 25 } 29 26 30 30 - export type HandlerInput = undefined; 27 27 + export type HandlerInput = void; 31 28 32 29 export interface HandlerSuccess { 33 30 encoding: "application/json"; ··· 41 38 error?: "BlockedActor" | "BlockedByActor"; 42 39 } 43 40 44 44 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 45 45 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 46 46 - auth: HA; 47 47 - params: QueryParams; 48 48 - input: HandlerInput; 49 49 - req: HonoRequest; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 52 52 - export type Handler<HA extends HandlerAuth = never> = ( 53 53 - ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getFeed.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 feed: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feed: (SoSprkFeedDefs.FeedViewPost)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 32 29 error?: "UnknownFeed"; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getFeedGenerator.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** AT-URI of the feed generator record. */ 10 8 feed: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 20 17 isValid: boolean; 21 18 } 22 19 23 23 - export type HandlerInput = undefined; 20 20 + export type HandlerInput = void; 24 21 25 22 export interface HandlerSuccess { 26 23 encoding: "application/json"; ··· 33 30 message?: string; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getFeedGenerators.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 feeds: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 feeds: (SoSprkFeedDefs.GeneratorView)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getFeedSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference to feed generator record describing the specific feed being requested. */ 10 8 feed: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 feed: (SoSprkFeedDefs.SkeletonFeedPost)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 33 30 error?: "UnknownFeed"; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getLikes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 import type * as SoSprkActorDefs from "../actor/defs.ts"; 9 7 10 8 const is$typed = _is$typed, validate = _validate; 11 9 const id = "so.sprk.feed.getLikes"; 12 10 13 13 - export interface QueryParams { 11 11 + export type QueryParams = { 14 12 /** AT-URI of the subject (eg, a post record). */ 15 13 uri: string; 16 14 /** CID of the subject record (aka, specific version of record), to filter likes. */ 17 15 cid?: string; 18 16 limit: number; 19 17 cursor?: string; 20 20 - } 21 21 - 18 18 + }; 22 19 export type InputSchema = undefined; 23 20 24 21 export interface OutputSchema { ··· 28 25 likes: (Like)[]; 29 26 } 30 27 31 31 - export type HandlerInput = undefined; 28 28 + export type HandlerInput = void; 32 29 33 30 export interface HandlerSuccess { 34 31 encoding: "application/json"; ··· 41 38 message?: string; 42 39 } 43 40 44 44 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 45 45 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 46 46 - auth: HA; 47 47 - params: QueryParams; 48 48 - input: HandlerInput; 49 49 - req: HonoRequest; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 52 52 - export type Handler<HA extends HandlerAuth = never> = ( 53 53 - ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess; 55 42 56 43 export interface Like { 57 44 $type?: "so.sprk.feed.getLikes#like";

+4 -17

services/appview/lexicon/types/so/sprk/feed/getListFeed.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) to the list record. */ 10 8 list: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 feed: (SoSprkFeedDefs.FeedViewPost)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 33 30 error?: "UnknownList"; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getLooks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 import type * as SoSprkActorDefs from "../actor/defs.ts"; 9 7 10 8 const is$typed = _is$typed, validate = _validate; 11 9 const id = "so.sprk.feed.getLooks"; 12 10 13 13 - export interface QueryParams { 11 11 + export type QueryParams = { 14 12 /** AT-URI of the subject (eg, a post record). */ 15 13 uri: string; 16 14 /** CID of the subject record (aka, specific version of record), to filter looks. */ 17 15 cid?: string; 18 16 limit: number; 19 17 cursor?: string; 20 20 - } 21 21 - 18 18 + }; 22 19 export type InputSchema = undefined; 23 20 24 21 export interface OutputSchema { ··· 28 25 looks: (Look)[]; 29 26 } 30 27 31 31 - export type HandlerInput = undefined; 28 28 + export type HandlerInput = void; 32 29 33 30 export interface HandlerSuccess { 34 31 encoding: "application/json"; ··· 41 38 message?: string; 42 39 } 43 40 44 44 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 45 45 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 46 46 - auth: HA; 47 47 - params: QueryParams; 48 48 - input: HandlerInput; 49 49 - req: HonoRequest; 50 50 - resetRouteRateLimits: () => Promise<void>; 51 51 - }; 52 52 - export type Handler<HA extends HandlerAuth = never> = ( 53 53 - ctx: HandlerReqCtx<HA>, 54 54 - ) => Promise<HandlerOutput> | HandlerOutput; 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess; 55 42 56 43 export interface Look { 57 44 $type?: "so.sprk.feed.getLooks#look";

+4 -17

services/appview/lexicon/types/so/sprk/feed/getPostThread.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as SoSprkFeedDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 /** Reference (AT-URI) to post record. */ 11 9 uri: string; 12 10 /** How many levels of reply depth should be included in response. */ 13 11 depth: number; 14 12 /** How many levels of parent (and grandparent, etc) post to include. */ 15 13 parentHeight: number; 16 16 - } 17 17 - 14 14 + }; 18 15 export type InputSchema = undefined; 19 16 20 17 export interface OutputSchema { ··· 26 23 threadgate?: SoSprkFeedDefs.ThreadgateView; 27 24 } 28 25 29 29 - export type HandlerInput = undefined; 26 26 + export type HandlerInput = void; 30 27 31 28 export interface HandlerSuccess { 32 29 encoding: "application/json"; ··· 40 37 error?: "NotFound"; 41 38 } 42 39 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 44 44 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: HonoRequest; 49 49 - resetRouteRateLimits: () => Promise<void>; 50 50 - }; 51 51 - export type Handler<HA extends HandlerAuth = never> = ( 52 52 - ctx: HandlerReqCtx<HA>, 53 53 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getPosts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** List of post AT-URIs to return hydrated views for. */ 10 8 uris: string[]; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { 16 13 posts: (SoSprkFeedDefs.PostView)[]; 17 14 } 18 15 19 19 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 20 17 21 18 export interface HandlerSuccess { 22 19 encoding: "application/json"; ··· 29 26 message?: string; 30 27 } 31 28 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getQuotes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of post record */ 10 8 uri: string; 11 9 /** If supplied, filters to quotes of specific version (by CID) of the post record. */ 12 10 cid?: string; 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 23 20 posts: (SoSprkFeedDefs.PostView)[]; 24 21 } 25 22 26 26 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 27 24 28 25 export interface HandlerSuccess { 29 26 encoding: "application/json"; ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getRepostedBy.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of post record */ 10 8 uri: string; 11 9 /** If supplied, filters to reposts of specific version (by CID) of the post record. */ 12 10 cid?: string; 13 11 limit: number; 14 12 cursor?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 23 20 repostedBy: (SoSprkActorDefs.ProfileView)[]; 24 21 } 25 22 26 26 - export type HandlerInput = undefined; 23 23 + export type HandlerInput = void; 27 24 28 25 export interface HandlerSuccess { 29 26 encoding: "application/json"; ··· 36 33 message?: string; 37 34 } 38 35 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getStories.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** List of story AT-URIs to return hydrated views for. */ 10 8 uris: string[]; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { 16 13 stories: (SoSprkFeedDefs.StoryView)[]; 17 14 } 18 15 19 19 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 20 17 21 18 export interface HandlerSuccess { 22 19 encoding: "application/json"; ··· 29 26 message?: string; 30 27 } 31 28 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getStoriesTimeline.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 storiesByAuthor: (SoSprkFeedDefs.StoriesByAuthor)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getSuggestedFeeds.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 feeds: (SoSprkFeedDefs.GeneratorView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/feed/getTimeline.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Variant 'algorithm' for timeline. Implementation-specific. NOTE: most feed flexibility has been moved to feed generator mechanism. */ 10 8 algorithm?: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 feed: (SoSprkFeedDefs.FeedViewPost)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/so/sprk/feed/like.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "so.sprk.feed.like"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "so.sprk.feed.like"; 13 13 subject: ComAtprotoRepoStrongRef.Main; 14 14 createdAt: string; 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+6 -8

services/appview/lexicon/types/so/sprk/feed/look.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "so.sprk.feed.look"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "so.sprk.feed.look"; 13 13 subject: ComAtprotoRepoStrongRef.Main; 14 14 createdAt: string; 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+6 -8

services/appview/lexicon/types/so/sprk/feed/music.ts

reviewed

··· 11 11 const is$typed = _is$typed, validate = _validate; 12 12 const id = "so.sprk.feed.music"; 13 13 14 14 - export interface MainRecord { 14 14 + export interface Record { 15 15 $type: "so.sprk.feed.music"; 16 16 sound: BlobRef; 17 17 /** The music's title. */ ··· 38 38 [k: string]: unknown; 39 39 } 40 40 41 41 - export type Record = MainRecord; 42 42 - 43 43 - const hashMainRecord = "main"; 41 41 + const hashRecord = "main"; 44 42 45 45 - export function isMainRecord<V>(v: V) { 46 46 - return is$typed(v, id, hashMainRecord); 43 43 + export function isRecord<V>(v: V) { 44 44 + return is$typed(v, id, hashRecord); 47 45 } 48 46 49 49 - export function validateMainRecord<V>(v: V) { 50 50 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 47 47 + export function validateRecord<V>(v: V) { 48 48 + return validate<Record & V>(v, id, hashRecord, true); 51 49 }

+6 -8

services/appview/lexicon/types/so/sprk/feed/post.ts

reviewed

··· 13 13 const is$typed = _is$typed, validate = _validate; 14 14 const id = "so.sprk.feed.post"; 15 15 16 16 - export interface MainRecord { 16 16 + export interface Record { 17 17 $type: "so.sprk.feed.post"; 18 18 /** The post description. */ 19 19 text?: string; ··· 34 34 [k: string]: unknown; 35 35 } 36 36 37 37 - export type Record = MainRecord; 38 38 - 39 39 - const hashMainRecord = "main"; 37 37 + const hashRecord = "main"; 40 38 41 41 - export function isMainRecord<V>(v: V) { 42 42 - return is$typed(v, id, hashMainRecord); 39 39 + export function isRecord<V>(v: V) { 40 40 + return is$typed(v, id, hashRecord); 43 41 } 44 42 45 45 - export function validateMainRecord<V>(v: V) { 46 46 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 43 43 + export function validateRecord<V>(v: V) { 44 44 + return validate<Record & V>(v, id, hashRecord, true); 47 45 } 48 46 49 47 export interface ReplyRef {

+6 -8

services/appview/lexicon/types/so/sprk/feed/postgate.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "so.sprk.feed.postgate"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "so.sprk.feed.postgate"; 13 13 createdAt: string; 14 14 /** Reference (AT-URI) to the post record. */ ··· 20 20 [k: string]: unknown; 21 21 } 22 22 23 23 - export type Record = MainRecord; 24 24 - 25 25 - const hashMainRecord = "main"; 23 23 + const hashRecord = "main"; 26 24 27 27 - export function isMainRecord<V>(v: V) { 28 28 - return is$typed(v, id, hashMainRecord); 25 25 + export function isRecord<V>(v: V) { 26 26 + return is$typed(v, id, hashRecord); 29 27 } 30 28 31 31 - export function validateMainRecord<V>(v: V) { 32 32 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 29 29 + export function validateRecord<V>(v: V) { 30 30 + return validate<Record & V>(v, id, hashRecord, true); 33 31 } 34 32 35 33 /** Disables embedding of this post. */

+6 -8

services/appview/lexicon/types/so/sprk/feed/repost.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "so.sprk.feed.repost"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "so.sprk.feed.repost"; 13 13 subject: ComAtprotoRepoStrongRef.Main; 14 14 createdAt: string; 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+5 -18

services/appview/lexicon/types/so/sprk/feed/searchPosts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; to match against post descriptions and such. */ 10 8 q: string; 11 9 /** Specifies the ranking order of results. */ 12 12 - sort: "top" | "latest" | (string & { __brand?: never }); 10 10 + sort: "top" | "latest" | (string & globalThis.Record<PropertyKey, never>); 13 11 limit: number; 14 12 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 15 13 cursor?: string; 16 16 - } 17 17 - 14 14 + }; 18 15 export type InputSchema = undefined; 19 16 20 17 export interface OutputSchema { ··· 24 21 posts: (SoSprkFeedDefs.PostView)[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 38 35 error?: "BadQueryString"; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -15

services/appview/lexicon/types/so/sprk/feed/sendInteractions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 interactions: (SoSprkFeedDefs.Interaction)[]; 12 10 } 13 11 14 14 - export type OutputSchema = Record<never, never>; 12 12 + export type OutputSchema = globalThis.Record<PropertyKey, never>; 15 13 16 14 export interface HandlerInput { 17 15 encoding: "application/json"; ··· 29 27 message?: string; 30 28 } 31 29 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/so/sprk/feed/story.ts

reviewed

··· 12 12 const is$typed = _is$typed, validate = _validate; 13 13 const id = "so.sprk.feed.story"; 14 14 15 15 - export interface MainRecord { 15 15 + export interface Record { 16 16 $type: "so.sprk.feed.story"; 17 17 media: $Typed<SoSprkEmbedImages.Main> | $Typed<SoSprkEmbedVideo.Main> | { 18 18 $type: string; ··· 26 26 [k: string]: unknown; 27 27 } 28 28 29 29 - export type Record = MainRecord; 30 30 - 31 31 - const hashMainRecord = "main"; 29 29 + const hashRecord = "main"; 32 30 33 33 - export function isMainRecord<V>(v: V) { 34 34 - return is$typed(v, id, hashMainRecord); 31 31 + export function isRecord<V>(v: V) { 32 32 + return is$typed(v, id, hashRecord); 35 33 } 36 34 37 37 - export function validateMainRecord<V>(v: V) { 38 38 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 35 35 + export function validateRecord<V>(v: V) { 36 36 + return validate<Record & V>(v, id, hashRecord, true); 39 37 }

+6 -8

services/appview/lexicon/types/so/sprk/feed/threadgate.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "so.sprk.feed.threadgate"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "so.sprk.feed.threadgate"; 13 13 /** Reference (AT-URI) to the post record. */ 14 14 post: string; ··· 26 26 [k: string]: unknown; 27 27 } 28 28 29 29 - export type Record = MainRecord; 30 30 - 31 31 - const hashMainRecord = "main"; 29 29 + const hashRecord = "main"; 32 30 33 33 - export function isMainRecord<V>(v: V) { 34 34 - return is$typed(v, id, hashMainRecord); 31 31 + export function isRecord<V>(v: V) { 32 32 + return is$typed(v, id, hashRecord); 35 33 } 36 34 37 37 - export function validateMainRecord<V>(v: V) { 38 38 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 35 35 + export function validateRecord<V>(v: V) { 36 36 + return validate<Record & V>(v, id, hashRecord, true); 39 37 } 40 38 41 39 /** Allow replies from actors mentioned in your post. */

+6 -8

services/appview/lexicon/types/so/sprk/graph/block.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "so.sprk.graph.block"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "so.sprk.graph.block"; 12 12 /** DID of the account to be blocked. */ 13 13 subject: string; ··· 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+1 -1

services/appview/lexicon/types/so/sprk/graph/defs.ts

reviewed

··· 128 128 | "so.sprk.graph.defs#modlist" 129 129 | "so.sprk.graph.defs#curatelist" 130 130 | "so.sprk.graph.defs#referencelist" 131 131 - | (string & { __brand?: never }); 131 131 + | (string & globalThis.Record<PropertyKey, never>); 132 132 133 133 /** A list of actors to apply an aggregate moderation action (mute/block) on. */ 134 134 export const MODLIST = `${id}#modlist`;

+6 -8

services/appview/lexicon/types/so/sprk/graph/follow.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "so.sprk.graph.follow"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "so.sprk.graph.follow"; 12 12 subject: string; 13 13 createdAt: string; 14 14 [k: string]: unknown; 15 15 } 16 16 17 17 - export type Record = MainRecord; 17 17 + const hashRecord = "main"; 18 18 19 19 - const hashMainRecord = "main"; 20 20 - 21 21 - export function isMainRecord<V>(v: V) { 22 22 - return is$typed(v, id, hashMainRecord); 19 19 + export function isRecord<V>(v: V) { 20 20 + return is$typed(v, id, hashRecord); 23 21 } 24 22 25 25 - export function validateMainRecord<V>(v: V) { 26 26 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 23 23 + export function validateRecord<V>(v: V) { 24 24 + return validate<Record & V>(v, id, hashRecord, true); 27 25 }

+4 -17

services/appview/lexicon/types/so/sprk/graph/getActorStarterPacks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 starterPacks: (SoSprkGraphDefs.StarterPackViewBasic)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getBlocks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 blocks: (SoSprkActorDefs.ProfileView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getFollowers.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 19 16 followers: (SoSprkActorDefs.ProfileView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getFollows.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 19 16 follows: (SoSprkActorDefs.ProfileView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getKnownFollowers.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 19 16 followers: (SoSprkActorDefs.ProfileView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getList.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of the list record to hydrate. */ 10 8 list: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 20 17 items: (SoSprkGraphDefs.ListItemView)[]; 21 18 } 22 19 23 23 - export type HandlerInput = undefined; 20 20 + export type HandlerInput = void; 24 21 25 22 export interface HandlerSuccess { 26 23 encoding: "application/json"; ··· 33 30 message?: string; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getListBlocks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 lists: (SoSprkGraphDefs.ListView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getListMutes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 lists: (SoSprkGraphDefs.ListView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getLists.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The account (actor) to enumerate lists from. */ 10 8 actor: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 lists: (SoSprkGraphDefs.ListView)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getMutes.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 17 14 mutes: (SoSprkActorDefs.ProfileView)[]; 18 15 } 19 16 20 20 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 21 18 22 19 export interface HandlerSuccess { 23 20 encoding: "application/json"; ··· 30 27 message?: string; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getRelationships.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as SoSprkGraphDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 /** Primary account requesting relationships for. */ 11 9 actor: string; 12 10 /** List of 'other' accounts to be related back to the primary. */ 13 11 others?: string[]; 14 14 - } 15 15 - 12 12 + }; 16 13 export type InputSchema = undefined; 17 14 18 15 export interface OutputSchema { ··· 24 21 )[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 38 35 error?: "ActorNotFound"; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getStarterPack.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Reference (AT-URI) of the starter pack record. */ 10 8 starterPack: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { 16 13 starterPack: SoSprkGraphDefs.StarterPackView; 17 14 } 18 15 19 19 - export type HandlerInput = undefined; 16 16 + export type HandlerInput = void; 20 17 21 18 export interface HandlerSuccess { 22 19 encoding: "application/json"; ··· 29 26 message?: string; 30 27 } 31 28 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getStarterPacks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 uris: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 starterPacks: (SoSprkGraphDefs.StarterPackViewBasic)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/graph/getSuggestedFollowsByActor.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkActorDefs from "../actor/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 actor: string; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { ··· 19 16 recId?: number; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/so/sprk/graph/list.ts

reviewed

··· 12 12 const is$typed = _is$typed, validate = _validate; 13 13 const id = "so.sprk.graph.list"; 14 14 15 15 - export interface MainRecord { 15 15 + export interface Record { 16 16 $type: "so.sprk.graph.list"; 17 17 purpose: SoSprkGraphDefs.ListPurpose; 18 18 /** Display name for list; can not be empty. */ ··· 25 25 [k: string]: unknown; 26 26 } 27 27 28 28 - export type Record = MainRecord; 29 29 - 30 30 - const hashMainRecord = "main"; 28 28 + const hashRecord = "main"; 31 29 32 32 - export function isMainRecord<V>(v: V) { 33 33 - return is$typed(v, id, hashMainRecord); 30 30 + export function isRecord<V>(v: V) { 31 31 + return is$typed(v, id, hashRecord); 34 32 } 35 33 36 36 - export function validateMainRecord<V>(v: V) { 37 37 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 34 34 + export function validateRecord<V>(v: V) { 35 35 + return validate<Record & V>(v, id, hashRecord, true); 38 36 }

+6 -8

services/appview/lexicon/types/so/sprk/graph/listblock.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "so.sprk.graph.listblock"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "so.sprk.graph.listblock"; 12 12 /** Reference (AT-URI) to the mod list record. */ 13 13 subject: string; ··· 15 15 [k: string]: unknown; 16 16 } 17 17 18 18 - export type Record = MainRecord; 18 18 + const hashRecord = "main"; 19 19 20 20 - const hashMainRecord = "main"; 21 21 - 22 22 - export function isMainRecord<V>(v: V) { 23 23 - return is$typed(v, id, hashMainRecord); 20 20 + export function isRecord<V>(v: V) { 21 21 + return is$typed(v, id, hashRecord); 24 22 } 25 23 26 26 - export function validateMainRecord<V>(v: V) { 27 27 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 24 24 + export function validateRecord<V>(v: V) { 25 25 + return validate<Record & V>(v, id, hashRecord, true); 28 26 }

+6 -8

services/appview/lexicon/types/so/sprk/graph/listitem.ts

reviewed

··· 7 7 const is$typed = _is$typed, validate = _validate; 8 8 const id = "so.sprk.graph.listitem"; 9 9 10 10 - export interface MainRecord { 10 10 + export interface Record { 11 11 $type: "so.sprk.graph.listitem"; 12 12 /** The account which is included on the list. */ 13 13 subject: string; ··· 17 17 [k: string]: unknown; 18 18 } 19 19 20 20 - export type Record = MainRecord; 20 20 + const hashRecord = "main"; 21 21 22 22 - const hashMainRecord = "main"; 23 23 - 24 24 - export function isMainRecord<V>(v: V) { 25 25 - return is$typed(v, id, hashMainRecord); 22 22 + export function isRecord<V>(v: V) { 23 23 + return is$typed(v, id, hashRecord); 26 24 } 27 25 28 28 - export function validateMainRecord<V>(v: V) { 29 29 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 26 26 + export function validateRecord<V>(v: V) { 27 27 + return validate<Record & V>(v, id, hashRecord, true); 30 28 }

+1 -16

services/appview/lexicon/types/so/sprk/graph/muteActor.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 actor: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/so/sprk/graph/muteActorList.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 list: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/so/sprk/graph/muteThread.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 root: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/so/sprk/graph/searchStarterPacks.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkGraphDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q: string; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 starterPacks: (SoSprkGraphDefs.StarterPackViewBasic)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/so/sprk/graph/starterpack.ts

reviewed

··· 8 8 const is$typed = _is$typed, validate = _validate; 9 9 const id = "so.sprk.graph.starterpack"; 10 10 11 11 - export interface MainRecord { 11 11 + export interface Record { 12 12 $type: "so.sprk.graph.starterpack"; 13 13 /** Display name for starter pack; can not be empty. */ 14 14 name: string; ··· 21 21 [k: string]: unknown; 22 22 } 23 23 24 24 - export type Record = MainRecord; 25 25 - 26 26 - const hashMainRecord = "main"; 24 24 + const hashRecord = "main"; 27 25 28 28 - export function isMainRecord<V>(v: V) { 29 29 - return is$typed(v, id, hashMainRecord); 26 26 + export function isRecord<V>(v: V) { 27 27 + return is$typed(v, id, hashRecord); 30 28 } 31 29 32 32 - export function validateMainRecord<V>(v: V) { 33 33 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 30 30 + export function validateRecord<V>(v: V) { 31 31 + return validate<Record & V>(v, id, hashRecord, true); 34 32 } 35 33 36 34 export interface FeedItem {

+1 -16

services/appview/lexicon/types/so/sprk/graph/unmuteActor.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 actor: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/so/sprk/graph/unmuteActorList.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 list: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/so/sprk/graph/unmuteThread.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 root: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/so/sprk/labeler/getServices.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as SoSprkLabelerDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 dids: string[]; 11 9 detailed: boolean; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 21 18 )[]; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -8

services/appview/lexicon/types/so/sprk/labeler/service.ts

reviewed

··· 10 10 const is$typed = _is$typed, validate = _validate; 11 11 const id = "so.sprk.labeler.service"; 12 12 13 13 - export interface MainRecord { 13 13 + export interface Record { 14 14 $type: "so.sprk.labeler.service"; 15 15 policies: SoSprkLabelerDefs.LabelerPolicies; 16 16 labels?: $Typed<ComAtprotoLabelDefs.SelfLabels> | { $type: string }; ··· 18 18 [k: string]: unknown; 19 19 } 20 20 21 21 - export type Record = MainRecord; 21 21 + const hashRecord = "main"; 22 22 23 23 - const hashMainRecord = "main"; 24 24 - 25 25 - export function isMainRecord<V>(v: V) { 26 26 - return is$typed(v, id, hashMainRecord); 23 23 + export function isRecord<V>(v: V) { 24 24 + return is$typed(v, id, hashRecord); 27 25 } 28 26 29 29 - export function validateMainRecord<V>(v: V) { 30 30 - return validate<MainRecord & V>(v, id, hashMainRecord, true); 27 27 + export function validateRecord<V>(v: V) { 28 28 + return validate<Record & V>(v, id, hashRecord, true); 31 29 }

+4 -18

services/appview/lexicon/types/so/sprk/notification/getUnreadCount.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export interface QueryParams { 4 4 + export type QueryParams = { 8 5 priority?: boolean; 9 6 seenAt?: string; 10 10 - } 11 11 - 7 7 + }; 12 8 export type InputSchema = undefined; 13 9 14 10 export interface OutputSchema { 15 11 count: number; 16 12 } 17 13 18 18 - export type HandlerInput = undefined; 14 14 + export type HandlerInput = void; 19 15 20 16 export interface HandlerSuccess { 21 17 encoding: "application/json"; ··· 28 24 message?: string; 29 25 } 30 26 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 27 27 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/so/sprk/notification/listNotifications.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 import type * as SoSprkActorDefs from "../actor/defs.ts"; 9 7 import type * as ComAtprotoLabelDefs from "../../../com/atproto/label/defs.ts"; 10 8 11 9 const is$typed = _is$typed, validate = _validate; 12 10 const id = "so.sprk.notification.listNotifications"; 13 11 14 14 - export interface QueryParams { 12 12 + export type QueryParams = { 15 13 /** Notification reasons to include in response. */ 16 14 reasons?: string[]; 17 15 limit: number; 18 16 priority?: boolean; 19 17 cursor?: string; 20 18 seenAt?: string; 21 21 - } 22 22 - 19 19 + }; 23 20 export type InputSchema = undefined; 24 21 25 22 export interface OutputSchema { ··· 29 26 seenAt?: string; 30 27 } 31 28 32 32 - export type HandlerInput = undefined; 29 29 + export type HandlerInput = void; 33 30 34 31 export interface HandlerSuccess { 35 32 encoding: "application/json"; ··· 42 39 message?: string; 43 40 } 44 41 45 45 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 46 46 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 47 47 - auth: HA; 48 48 - params: QueryParams; 49 49 - input: HandlerInput; 50 50 - req: HonoRequest; 51 51 - resetRouteRateLimits: () => Promise<void>; 52 52 - }; 53 53 - export type Handler<HA extends HandlerAuth = never> = ( 54 54 - ctx: HandlerReqCtx<HA>, 55 55 - ) => Promise<HandlerOutput> | HandlerOutput; 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess; 56 43 57 44 export interface Notification { 58 45 $type?: "so.sprk.notification.listNotifications#notification"; ··· 68 55 | "reply" 69 56 | "quote" 70 57 | "starterpack-joined" 71 71 - | (string & { __brand?: never }); 58 58 + | (string & globalThis.Record<PropertyKey, never>); 72 59 reasonSubject?: string; 73 60 record: { [_ in string]: unknown }; 74 61 isRead: boolean;

+1 -16

services/appview/lexicon/types/so/sprk/notification/putPreferences.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 priority: boolean; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+6 -17

services/appview/lexicon/types/so/sprk/notification/registerPush.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 serviceDid: string; 11 8 token: string; 12 12 - platform: "ios" | "android" | "web" | (string & { __brand?: never }); 9 9 + platform: 10 10 + | "ios" 11 11 + | "android" 12 12 + | "web" 13 13 + | (string & globalThis.Record<PropertyKey, never>); 13 14 appId: string; 14 15 } 15 16 16 16 - export type OutputSchema = undefined; 17 17 - 18 17 export interface HandlerInput { 19 18 encoding: "application/json"; 20 19 body: InputSchema; ··· 26 25 } 27 26 28 27 export type HandlerOutput = HandlerError | void; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput;

+1 -16

services/appview/lexicon/types/so/sprk/notification/updateSeen.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 seenAt: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+3 -16

services/appview/lexicon/types/so/sprk/unspecced/getConfig.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { 11 8 checkEmailConfirmed?: boolean; 12 9 } 13 10 14 14 - export type HandlerInput = undefined; 11 11 + export type HandlerInput = void; 15 12 16 13 export interface HandlerSuccess { 17 14 encoding: "application/json"; ··· 24 21 message?: string; 25 22 } 26 23 27 27 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput; 24 24 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/unspecced/getPopularFeedGenerators.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkFeedDefs from "../feed/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 9 query?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 feeds: (SoSprkFeedDefs.GeneratorView)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/unspecced/getSuggestionsSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. */ 10 8 viewer?: string; 11 9 limit: number; 12 10 cursor?: string; 13 11 /** DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer. */ 14 12 relativeToDid?: string; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 25 22 recId?: number; 26 23 } 27 24 28 28 - export type HandlerInput = undefined; 25 25 + export type HandlerInput = void; 29 26 30 27 export interface HandlerSuccess { 31 28 encoding: "application/json"; ··· 38 35 message?: string; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+7 -16

services/appview/lexicon/types/so/sprk/unspecced/getTaggedSuggestions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "so.sprk.unspecced.getTaggedSuggestions"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 export type InputSchema = undefined; 14 12 15 13 export interface OutputSchema { 16 14 suggestions: (Suggestion)[]; 17 15 } 18 16 19 19 - export type HandlerInput = undefined; 17 17 + export type HandlerInput = void; 20 18 21 19 export interface HandlerSuccess { 22 20 encoding: "application/json"; ··· 29 27 message?: string; 30 28 } 31 29 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess; 43 31 44 32 export interface Suggestion { 45 33 $type?: "so.sprk.unspecced.getTaggedSuggestions#suggestion"; 46 34 tag: string; 47 47 - subjectType: "actor" | "feed" | (string & { __brand?: never }); 35 35 + subjectType: 36 36 + | "actor" 37 37 + | "feed" 38 38 + | (string & globalThis.Record<PropertyKey, never>); 48 39 subject: string; 49 40 } 50 41

+4 -17

services/appview/lexicon/types/so/sprk/unspecced/getTrendingTopics.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. */ 10 8 viewer?: string; 11 9 limit: number; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 suggested: (SoSprkUnspeccedDefs.TrendingTopic)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/unspecced/searchActorsSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax. */ 10 8 q: string; 11 9 /** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. */ ··· 15 13 limit: number; 16 14 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 17 15 cursor?: string; 18 18 - } 19 19 - 16 16 + }; 20 17 export type InputSchema = undefined; 21 18 22 19 export interface OutputSchema { ··· 26 23 actors: (SoSprkUnspeccedDefs.SkeletonSearchActor)[]; 27 24 } 28 25 29 29 - export type HandlerInput = undefined; 26 26 + export type HandlerInput = void; 30 27 31 28 export interface HandlerSuccess { 32 29 encoding: "application/json"; ··· 40 37 error?: "BadQueryString"; 41 38 } 42 39 43 43 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 44 44 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 45 45 - auth: HA; 46 46 - params: QueryParams; 47 47 - input: HandlerInput; 48 48 - req: HonoRequest; 49 49 - resetRouteRateLimits: () => Promise<void>; 50 50 - }; 51 51 - export type Handler<HA extends HandlerAuth = never> = ( 52 52 - ctx: HandlerReqCtx<HA>, 53 53 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -18

services/appview/lexicon/types/so/sprk/unspecced/searchPostsSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q: string; 11 9 /** Specifies the ranking order of results. */ 12 12 - sort: "top" | "latest" | (string & { __brand?: never }); 10 10 + sort: "top" | "latest" | (string & globalThis.Record<PropertyKey, never>); 13 11 /** Filter results for posts after the indicated datetime (inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYYY-MM-DD). */ 14 12 since?: string; 15 13 /** Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD). */ ··· 31 29 limit: number; 32 30 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 33 31 cursor?: string; 34 34 - } 35 35 - 32 32 + }; 36 33 export type InputSchema = undefined; 37 34 38 35 export interface OutputSchema { ··· 42 39 posts: (SoSprkUnspeccedDefs.SkeletonSearchPost)[]; 43 40 } 44 41 45 45 - export type HandlerInput = undefined; 42 42 + export type HandlerInput = void; 46 43 47 44 export interface HandlerSuccess { 48 45 encoding: "application/json"; ··· 56 53 error?: "BadQueryString"; 57 54 } 58 55 59 59 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 60 60 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 61 61 - auth: HA; 62 62 - params: QueryParams; 63 63 - input: HandlerInput; 64 64 - req: HonoRequest; 65 65 - resetRouteRateLimits: () => Promise<void>; 66 66 - }; 67 67 - export type Handler<HA extends HandlerAuth = never> = ( 68 68 - ctx: HandlerReqCtx<HA>, 69 69 - ) => Promise<HandlerOutput> | HandlerOutput; 56 56 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/so/sprk/unspecced/searchStarterPacksSkeleton.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkUnspeccedDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. */ 10 8 q: string; 11 9 /** DID of the account making the request (not included for public/unauthenticated queries). */ ··· 13 11 limit: number; 14 12 /** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. */ 15 13 cursor?: string; 16 16 - } 17 17 - 14 14 + }; 18 15 export type InputSchema = undefined; 19 16 20 17 export interface OutputSchema { ··· 24 21 starterPacks: (SoSprkUnspeccedDefs.SkeletonSearchStarterPack)[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 38 35 error?: "BadQueryString"; 39 36 } 40 37 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA; 44 44 - params: QueryParams; 45 45 - input: HandlerInput; 46 46 - req: HonoRequest; 47 47 - resetRouteRateLimits: () => Promise<void>; 48 48 - }; 49 49 - export type Handler<HA extends HandlerAuth = never> = ( 50 50 - ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -1

services/appview/lexicon/types/so/sprk/video/defs.ts

reviewed

··· 16 16 state: 17 17 | "JOB_STATE_COMPLETED" 18 18 | "JOB_STATE_FAILED" 19 19 - | (string & { __brand?: never }); 19 19 + | (string & globalThis.Record<PropertyKey, never>); 20 20 /** Progress within the current processing state. */ 21 21 progress?: number; 22 22 blob?: BlobRef;

+4 -17

services/appview/lexicon/types/so/sprk/video/getJobStatus.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as SoSprkVideoDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 jobId: string; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 jobStatus: SoSprkVideoDefs.JobStatus; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -16

services/appview/lexicon/types/so/sprk/video/getUploadLimits.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 export type InputSchema = undefined; 9 6 10 7 export interface OutputSchema { ··· 15 12 error?: string; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/so/sprk/video/uploadVideo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import stream from "node:stream"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as SoSprkVideoDefs from "./defs.ts"; 8 6 9 9 - export type QueryParams = Record<never, never>; 7 7 + export type QueryParams = globalThis.Record<PropertyKey, never>; 10 8 export type InputSchema = string | Uint8Array | Blob; 11 9 12 10 export interface OutputSchema { ··· 29 27 message?: string; 30 28 } 31 29 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/tools/ozone/communication/createTemplate.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneCommunicationDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 /** Name of the template. */ ··· 39 37 error?: "DuplicateTemplateName"; 40 38 } 41 39 42 42 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 44 44 - auth: HA; 45 45 - params: QueryParams; 46 46 - input: HandlerInput; 47 47 - req: HonoRequest; 48 48 - resetRouteRateLimits: () => Promise<void>; 49 49 - }; 50 50 - export type Handler<HA extends HandlerAuth = never> = ( 51 51 - ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput; 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/tools/ozone/communication/deleteTemplate.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 id: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 23 18 } 24 19 25 20 export type HandlerOutput = HandlerError | void; 26 26 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA; 28 28 - params: QueryParams; 29 29 - input: HandlerInput; 30 30 - req: HonoRequest; 31 31 - resetRouteRateLimits: () => Promise<void>; 32 32 - }; 33 33 - export type Handler<HA extends HandlerAuth = never> = ( 34 34 - ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput;

+3 -15

services/appview/lexicon/types/tools/ozone/communication/listTemplates.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneCommunicationDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 export type InputSchema = undefined; 10 8 11 9 export interface OutputSchema { 12 10 communicationTemplates: (ToolsOzoneCommunicationDefs.TemplateView)[]; 13 11 } 14 12 15 15 - export type HandlerInput = undefined; 13 13 + export type HandlerInput = void; 16 14 17 15 export interface HandlerSuccess { 18 16 encoding: "application/json"; ··· 25 23 message?: string; 26 24 } 27 25 28 28 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput; 26 26 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/tools/ozone/communication/updateTemplate.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneCommunicationDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 /** ID of the template to be updated. */ ··· 42 40 error?: "DuplicateTemplateName"; 43 41 } 44 42 45 45 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 46 46 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 47 47 - auth: HA; 48 48 - params: QueryParams; 49 49 - input: HandlerInput; 50 50 - req: HonoRequest; 51 51 - resetRouteRateLimits: () => Promise<void>; 52 52 - }; 53 53 - export type Handler<HA extends HandlerAuth = never> = ( 54 54 - ctx: HandlerReqCtx<HA>, 55 55 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess;

+12 -5

services/appview/lexicon/types/tools/ozone/moderation/defs.ts

reviewed

··· 211 211 | "lex:tools.ozone.moderation.defs#reviewEscalated" 212 212 | "lex:tools.ozone.moderation.defs#reviewClosed" 213 213 | "lex:tools.ozone.moderation.defs#reviewNone" 214 214 - | (string & { __brand?: never }); 214 214 + | (string & globalThis.Record<PropertyKey, never>); 215 215 216 216 /** Moderator review status of a subject: Open. Indicates that the subject needs to be reviewed by a moderator */ 217 217 export const REVIEWOPEN = `${id}#reviewOpen`; ··· 533 533 | "takendown" 534 534 | "suspended" 535 535 | "tombstoned" 536 536 - | (string & { __brand?: never }); 536 536 + | (string & globalThis.Record<PropertyKey, never>); 537 537 timestamp: string; 538 538 } 539 539 ··· 571 571 export interface RecordEvent { 572 572 $type?: "tools.ozone.moderation.defs#recordEvent"; 573 573 comment?: string; 574 574 - op: "create" | "update" | "delete" | (string & { __brand?: never }); 574 574 + op: 575 575 + | "create" 576 576 + | "update" 577 577 + | "delete" 578 578 + | (string & globalThis.Record<PropertyKey, never>); 575 579 cid?: string; 576 580 timestamp: string; 577 581 } ··· 803 807 | "deleted" 804 808 | "deactivated" 805 809 | "unknown" 806 806 - | (string & { __brand?: never }); 810 810 + | (string & globalThis.Record<PropertyKey, never>); 807 811 updatedAt?: string; 808 812 createdAt?: string; 809 813 deletedAt?: string; ··· 823 827 824 828 export interface RecordHosting { 825 829 $type?: "tools.ozone.moderation.defs#recordHosting"; 826 826 - status: "deleted" | "unknown" | (string & { __brand?: never }); 830 830 + status: 831 831 + | "deleted" 832 832 + | "unknown" 833 833 + | (string & globalThis.Record<PropertyKey, never>); 827 834 updatedAt?: string; 828 835 createdAt?: string; 829 836 deletedAt?: string;

+2 -14

services/appview/lexicon/types/tools/ozone/moderation/emitEvent.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 8 6 import type * as ComAtprotoAdminDefs from "../../../com/atproto/admin/defs.ts"; 9 7 import type * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef.ts"; 10 8 11 11 - export type QueryParams = Record<never, never>; 9 9 + export type QueryParams = globalThis.Record<PropertyKey, never>; 12 10 13 11 export interface InputSchema { 14 12 event: ··· 59 57 error?: "SubjectHasAction"; 60 58 } 61 59 62 62 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 63 63 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 64 64 - auth: HA; 65 65 - params: QueryParams; 66 66 - input: HandlerInput; 67 67 - req: HonoRequest; 68 68 - resetRouteRateLimits: () => Promise<void>; 69 69 - }; 70 70 - export type Handler<HA extends HandlerAuth = never> = ( 71 71 - ctx: HandlerReqCtx<HA>, 72 72 - ) => Promise<HandlerOutput> | HandlerOutput; 60 60 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/moderation/getEvent.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 id: number; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 export type OutputSchema = ToolsOzoneModerationDefs.ModEventViewDetail; 14 14 - export type HandlerInput = undefined; 11 11 + export type HandlerInput = void; 15 12 16 13 export interface HandlerSuccess { 17 14 encoding: "application/json"; ··· 24 21 message?: string; 25 22 } 26 23 27 27 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 28 28 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA; 30 30 - params: QueryParams; 31 31 - input: HandlerInput; 32 32 - req: HonoRequest; 33 33 - resetRouteRateLimits: () => Promise<void>; 34 34 - }; 35 35 - export type Handler<HA extends HandlerAuth = never> = ( 36 36 - ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput; 24 24 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/moderation/getRecord.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 uri: string; 10 8 cid?: string; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 export type OutputSchema = ToolsOzoneModerationDefs.RecordViewDetail; 15 15 - export type HandlerInput = undefined; 12 12 + export type HandlerInput = void; 16 13 17 14 export interface HandlerSuccess { 18 15 encoding: "application/json"; ··· 26 23 error?: "RecordNotFound"; 27 24 } 28 25 29 29 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 30 30 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - input: HandlerInput; 34 34 - req: HonoRequest; 35 35 - resetRouteRateLimits: () => Promise<void>; 36 36 - }; 37 37 - export type Handler<HA extends HandlerAuth = never> = ( 38 38 - ctx: HandlerReqCtx<HA>, 39 39 - ) => Promise<HandlerOutput> | HandlerOutput; 26 26 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/moderation/getRecords.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 uris: string[]; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 20 17 )[]; 21 18 } 22 19 23 23 - export type HandlerInput = undefined; 20 20 + export type HandlerInput = void; 24 21 25 22 export interface HandlerSuccess { 26 23 encoding: "application/json"; ··· 33 30 message?: string; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/moderation/getRepo.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 did: string; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 export type OutputSchema = ToolsOzoneModerationDefs.RepoViewDetail; 14 14 - export type HandlerInput = undefined; 11 11 + export type HandlerInput = void; 15 12 16 13 export interface HandlerSuccess { 17 14 encoding: "application/json"; ··· 25 22 error?: "RepoNotFound"; 26 23 } 27 24 28 28 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput; 25 25 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/moderation/getReporterStats.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 dids: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 stats: (ToolsOzoneModerationDefs.ReporterStats)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/moderation/getRepos.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { type $Typed } from "../../../../util.ts"; 6 6 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 7 5 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 8 6 9 9 - export interface QueryParams { 7 7 + export type QueryParams = { 10 8 dids: string[]; 11 11 - } 12 12 - 9 9 + }; 13 10 export type InputSchema = undefined; 14 11 15 12 export interface OutputSchema { ··· 20 17 )[]; 21 18 } 22 19 23 23 - export type HandlerInput = undefined; 20 20 + export type HandlerInput = void; 24 21 25 22 export interface HandlerSuccess { 26 23 encoding: "application/json"; ··· 33 30 message?: string; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+8 -18

services/appview/lexicon/types/tools/ozone/moderation/queryEvents.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** The types of events (fully qualified string in the format of tools.ozone.moderation.defs#modEvent<name>) to filter by. If not specified, all events are returned. */ 10 8 types?: string[]; 11 9 createdBy?: string; ··· 19 17 /** If specified, only events where the subject belongs to the given collections will be returned. When subjectType is set to 'account', this will be ignored. */ 20 18 collections?: string[]; 21 19 /** If specified, only events where the subject is of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored. */ 22 22 - subjectType?: "account" | "record" | (string & { __brand?: never }); 20 20 + subjectType?: 21 21 + | "account" 22 22 + | "record" 23 23 + | (string & globalThis.Record<PropertyKey, never>); 23 24 /** If true, events on all record types (posts, lists, profile etc.) or records from given 'collections' param, owned by the did are returned. */ 24 25 includeAllUserRecords: boolean; 25 26 limit: number; ··· 38 39 reportTypes?: string[]; 39 40 policies?: string[]; 40 41 cursor?: string; 41 41 - } 42 42 - 42 42 + }; 43 43 export type InputSchema = undefined; 44 44 45 45 export interface OutputSchema { ··· 47 47 events: (ToolsOzoneModerationDefs.ModEventView)[]; 48 48 } 49 49 50 50 - export type HandlerInput = undefined; 50 50 + export type HandlerInput = void; 51 51 52 52 export interface HandlerSuccess { 53 53 encoding: "application/json"; ··· 60 60 message?: string; 61 61 } 62 62 63 63 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 64 64 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 65 65 - auth: HA; 66 66 - params: QueryParams; 67 67 - input: HandlerInput; 68 68 - req: HonoRequest; 69 69 - resetRouteRateLimits: () => Promise<void>; 70 70 - }; 71 71 - export type Handler<HA extends HandlerAuth = never> = ( 72 72 - ctx: HandlerReqCtx<HA>, 73 73 - ) => Promise<HandlerOutput> | HandlerOutput; 63 63 + export type HandlerOutput = HandlerError | HandlerSuccess;

+8 -18

services/appview/lexicon/types/tools/ozone/moderation/queryStatuses.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** Number of queues being used by moderators. Subjects will be split among all queues. */ 10 8 queueCount?: number; 11 9 /** Index of the queue to fetch subjects from. Works only when queueCount value is specified. */ ··· 63 61 /** If specified, subjects belonging to the given collections will be returned. When subjectType is set to 'account', this will be ignored. */ 64 62 collections?: string[]; 65 63 /** If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored. */ 66 66 - subjectType?: "account" | "record" | (string & { __brand?: never }); 64 64 + subjectType?: 65 65 + | "account" 66 66 + | "record" 67 67 + | (string & globalThis.Record<PropertyKey, never>); 67 68 /** If specified, only subjects that belong to an account that has at least this many suspensions will be returned. */ 68 69 minAccountSuspendCount?: number; 69 70 /** If specified, only subjects that belong to an account that has at least this many reported records will be returned. */ ··· 72 73 minTakendownRecordsCount?: number; 73 74 /** If specified, only subjects that have priority score value above the given value will be returned. */ 74 75 minPriorityScore?: number; 75 75 - } 76 76 - 76 76 + }; 77 77 export type InputSchema = undefined; 78 78 79 79 export interface OutputSchema { ··· 81 81 subjectStatuses: (ToolsOzoneModerationDefs.SubjectStatusView)[]; 82 82 } 83 83 84 84 - export type HandlerInput = undefined; 84 84 + export type HandlerInput = void; 85 85 86 86 export interface HandlerSuccess { 87 87 encoding: "application/json"; ··· 94 94 message?: string; 95 95 } 96 96 97 97 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 98 98 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 99 99 - auth: HA; 100 100 - params: QueryParams; 101 101 - input: HandlerInput; 102 102 - req: HonoRequest; 103 103 - resetRouteRateLimits: () => Promise<void>; 104 104 - }; 105 105 - export type Handler<HA extends HandlerAuth = never> = ( 106 106 - ctx: HandlerReqCtx<HA>, 107 107 - ) => Promise<HandlerOutput> | HandlerOutput; 97 97 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/moderation/searchRepos.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneModerationDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 /** DEPRECATED: use 'q' instead */ 10 8 term?: string; 11 9 q?: string; 12 10 limit: number; 13 11 cursor?: string; 14 14 - } 15 15 - 12 12 + }; 16 13 export type InputSchema = undefined; 17 14 18 15 export interface OutputSchema { ··· 20 17 repos: (ToolsOzoneModerationDefs.RepoView)[]; 21 18 } 22 19 23 23 - export type HandlerInput = undefined; 20 20 + export type HandlerInput = void; 24 21 25 22 export interface HandlerSuccess { 26 23 encoding: "application/json"; ··· 33 30 message?: string; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -16

services/appview/lexicon/types/tools/ozone/server/getConfig.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 9 7 const is$typed = _is$typed, validate = _validate; 10 8 const id = "tools.ozone.server.getConfig"; 11 9 12 12 - export type QueryParams = Record<never, never>; 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 11 export type InputSchema = undefined; 14 12 15 13 export interface OutputSchema { ··· 20 18 viewer?: ViewerConfig; 21 19 } 22 20 23 23 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 24 22 25 23 export interface HandlerSuccess { 26 24 encoding: "application/json"; ··· 33 31 message?: string; 34 32 } 35 33 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess; 47 35 48 36 export interface ServiceConfig { 49 37 $type?: "tools.ozone.server.getConfig#serviceConfig"; ··· 66 54 | "tools.ozone.team.defs#roleAdmin" 67 55 | "tools.ozone.team.defs#roleModerator" 68 56 | "tools.ozone.team.defs#roleTriage" 69 69 - | (string & { __brand?: never }); 57 57 + | (string & globalThis.Record<PropertyKey, never>); 70 58 } 71 59 72 60 const hashViewerConfig = "viewerConfig";

+1 -16

services/appview/lexicon/types/tools/ozone/set/addValues.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** Name of the set to add values to */ ··· 13 10 values: (string)[]; 14 11 } 15 12 16 16 - export type OutputSchema = undefined; 17 17 - 18 13 export interface HandlerInput { 19 14 encoding: "application/json"; 20 15 body: InputSchema; ··· 26 21 } 27 22 28 23 export type HandlerOutput = HandlerError | void; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput;

+3 -16

services/appview/lexicon/types/tools/ozone/set/deleteSet.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** Name of the set to delete */ 11 8 name: string; 12 9 } 13 10 14 14 - export type OutputSchema = Record<never, never>; 11 11 + export type OutputSchema = globalThis.Record<PropertyKey, never>; 15 12 16 13 export interface HandlerInput { 17 14 encoding: "application/json"; ··· 30 27 error?: "SetNotFound"; 31 28 } 32 29 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA; 36 36 - params: QueryParams; 37 37 - input: HandlerInput; 38 38 - req: HonoRequest; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput; 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -16

services/appview/lexicon/types/tools/ozone/set/deleteValues.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 /** Name of the set to delete values from */ ··· 13 10 values: (string)[]; 14 11 } 15 12 16 16 - export type OutputSchema = undefined; 17 17 - 18 13 export interface HandlerInput { 19 14 encoding: "application/json"; 20 15 body: InputSchema; ··· 27 22 } 28 23 29 24 export type HandlerOutput = HandlerError | void; 30 30 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA; 32 32 - params: QueryParams; 33 33 - input: HandlerInput; 34 34 - req: HonoRequest; 35 35 - resetRouteRateLimits: () => Promise<void>; 36 36 - }; 37 37 - export type Handler<HA extends HandlerAuth = never> = ( 38 38 - ctx: HandlerReqCtx<HA>, 39 39 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/tools/ozone/set/getValues.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneSetDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 name: string; 10 8 limit: number; 11 9 cursor?: string; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 19 16 cursor?: string; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 33 30 error?: "SetNotFound"; 34 31 } 35 32 36 36 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 37 37 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 38 38 - auth: HA; 39 39 - params: QueryParams; 40 40 - input: HandlerInput; 41 41 - req: HonoRequest; 42 42 - resetRouteRateLimits: () => Promise<void>; 43 43 - }; 44 44 - export type Handler<HA extends HandlerAuth = never> = ( 45 45 - ctx: HandlerReqCtx<HA>, 46 46 - ) => Promise<HandlerOutput> | HandlerOutput; 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/set/querySets.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneSetDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 9 namePrefix?: string; 12 10 sortBy: "name" | "createdAt" | "updatedAt"; 13 11 /** Defaults to ascending order of name field. */ 14 12 sortDirection: "asc" | "desc"; 15 15 - } 16 16 - 13 13 + }; 17 14 export type InputSchema = undefined; 18 15 19 16 export interface OutputSchema { ··· 21 18 cursor?: string; 22 19 } 23 20 24 24 - export type HandlerInput = undefined; 21 21 + export type HandlerInput = void; 25 22 26 23 export interface HandlerSuccess { 27 24 encoding: "application/json"; ··· 34 31 message?: string; 35 32 } 36 33 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA; 40 40 - params: QueryParams; 41 41 - input: HandlerInput; 42 42 - req: HonoRequest; 43 43 - resetRouteRateLimits: () => Promise<void>; 44 44 - }; 45 45 - export type Handler<HA extends HandlerAuth = never> = ( 46 46 - ctx: HandlerReqCtx<HA>, 47 47 - ) => Promise<HandlerOutput> | HandlerOutput; 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -14

services/appview/lexicon/types/tools/ozone/set/upsertSet.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneSetDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 export type InputSchema = ToolsOzoneSetDefs.Set; 10 8 export type OutputSchema = ToolsOzoneSetDefs.SetView; 11 9 ··· 25 23 message?: string; 26 24 } 27 25 28 28 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 29 29 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA; 31 31 - params: QueryParams; 32 32 - input: HandlerInput; 33 33 - req: HonoRequest; 34 34 - resetRouteRateLimits: () => Promise<void>; 35 35 - }; 36 36 - export type Handler<HA extends HandlerAuth = never> = ( 37 37 - ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput; 26 26 + export type HandlerOutput = HandlerError | HandlerSuccess;

+5 -2

services/appview/lexicon/types/tools/ozone/setting/defs.ts

reviewed

··· 19 19 | "tools.ozone.team.defs#roleModerator" 20 20 | "tools.ozone.team.defs#roleTriage" 21 21 | "tools.ozone.team.defs#roleAdmin" 22 22 - | (string & { __brand?: never }); 23 23 - scope: "instance" | "personal" | (string & { __brand?: never }); 22 22 + | (string & globalThis.Record<PropertyKey, never>); 23 23 + scope: 24 24 + | "instance" 25 25 + | "personal" 26 26 + | (string & globalThis.Record<PropertyKey, never>); 24 27 createdBy: string; 25 28 lastUpdatedBy: string; 26 29 }

+8 -18

services/appview/lexicon/types/tools/ozone/setting/listOptions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneSettingDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 limit: number; 10 8 cursor?: string; 11 11 - scope: "instance" | "personal" | (string & { __brand?: never }); 9 9 + scope: 10 10 + | "instance" 11 11 + | "personal" 12 12 + | (string & globalThis.Record<PropertyKey, never>); 12 13 /** Filter keys by prefix */ 13 14 prefix?: string; 14 15 /** Filter for only the specified keys. Ignored if prefix is provided */ 15 16 keys?: string[]; 16 16 - } 17 17 - 17 17 + }; 18 18 export type InputSchema = undefined; 19 19 20 20 export interface OutputSchema { ··· 22 22 options: (ToolsOzoneSettingDefs.Option)[]; 23 23 } 24 24 25 25 - export type HandlerInput = undefined; 25 25 + export type HandlerInput = void; 26 26 27 27 export interface HandlerSuccess { 28 28 encoding: "application/json"; ··· 35 35 message?: string; 36 36 } 37 37 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA; 41 41 - params: QueryParams; 42 42 - input: HandlerInput; 43 43 - req: HonoRequest; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 46 46 - export type Handler<HA extends HandlerAuth = never> = ( 47 47 - ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+7 -17

services/appview/lexicon/types/tools/ozone/setting/removeOptions.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 keys: (string)[]; 11 11 - scope: "instance" | "personal" | (string & { __brand?: never }); 8 8 + scope: 9 9 + | "instance" 10 10 + | "personal" 11 11 + | (string & globalThis.Record<PropertyKey, never>); 12 12 } 13 13 14 14 - export type OutputSchema = Record<never, never>; 14 14 + export type OutputSchema = globalThis.Record<PropertyKey, never>; 15 15 16 16 export interface HandlerInput { 17 17 encoding: "application/json"; ··· 29 29 message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: HonoRequest; 38 38 - resetRouteRateLimits: () => Promise<void>; 39 39 - }; 40 40 - export type Handler<HA extends HandlerAuth = never> = ( 41 41 - ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+7 -16

services/appview/lexicon/types/tools/ozone/setting/upsertOption.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneSettingDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 key: string; 12 12 - scope: "instance" | "personal" | (string & { __brand?: never }); 10 10 + scope: 11 11 + | "instance" 12 12 + | "personal" 13 13 + | (string & globalThis.Record<PropertyKey, never>); 13 14 value: { [_ in string]: unknown }; 14 15 description?: string; 15 16 managerRole?: 16 17 | "tools.ozone.team.defs#roleModerator" 17 18 | "tools.ozone.team.defs#roleTriage" 18 19 | "tools.ozone.team.defs#roleAdmin" 19 19 - | (string & { __brand?: never }); 20 20 + | (string & globalThis.Record<PropertyKey, never>); 20 21 } 21 22 22 23 export interface OutputSchema { ··· 39 40 message?: string; 40 41 } 41 42 42 42 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 44 44 - auth: HA; 45 45 - params: QueryParams; 46 46 - input: HandlerInput; 47 47 - req: HonoRequest; 48 48 - resetRouteRateLimits: () => Promise<void>; 49 49 - }; 50 50 - export type Handler<HA extends HandlerAuth = never> = ( 51 51 - ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput; 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/signature/findCorrelation.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneSignatureDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 dids: string[]; 10 10 - } 11 11 - 8 8 + }; 12 9 export type InputSchema = undefined; 13 10 14 11 export interface OutputSchema { 15 12 details: (ToolsOzoneSignatureDefs.SigDetail)[]; 16 13 } 17 14 18 18 - export type HandlerInput = undefined; 15 15 + export type HandlerInput = void; 19 16 20 17 export interface HandlerSuccess { 21 18 encoding: "application/json"; ··· 28 25 message?: string; 29 26 } 30 27 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA; 34 34 - params: QueryParams; 35 35 - input: HandlerInput; 36 36 - req: HonoRequest; 37 37 - resetRouteRateLimits: () => Promise<void>; 38 38 - }; 39 39 - export type Handler<HA extends HandlerAuth = never> = ( 40 40 - ctx: HandlerReqCtx<HA>, 41 41 - ) => Promise<HandlerOutput> | HandlerOutput; 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+4 -17

services/appview/lexicon/types/tools/ozone/signature/findRelatedAccounts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 4 import { validate as _validate } from "../../../../lexicons.ts"; 6 5 import { is$typed as _is$typed } from "../../../../util.ts"; 7 7 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 8 6 import type * as ComAtprotoAdminDefs from "../../../com/atproto/admin/defs.ts"; 9 7 import type * as ToolsOzoneSignatureDefs from "./defs.ts"; 10 8 11 9 const is$typed = _is$typed, validate = _validate; 12 10 const id = "tools.ozone.signature.findRelatedAccounts"; 13 11 14 14 - export interface QueryParams { 12 12 + export type QueryParams = { 15 13 did: string; 16 14 cursor?: string; 17 15 limit: number; 18 18 - } 19 19 - 16 16 + }; 20 17 export type InputSchema = undefined; 21 18 22 19 export interface OutputSchema { ··· 24 21 accounts: (RelatedAccount)[]; 25 22 } 26 23 27 27 - export type HandlerInput = undefined; 24 24 + export type HandlerInput = void; 28 25 29 26 export interface HandlerSuccess { 30 27 encoding: "application/json"; ··· 37 34 message?: string; 38 35 } 39 36 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA; 43 43 - params: QueryParams; 44 44 - input: HandlerInput; 45 45 - req: HonoRequest; 46 46 - resetRouteRateLimits: () => Promise<void>; 47 47 - }; 48 48 - export type Handler<HA extends HandlerAuth = never> = ( 49 49 - ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess; 51 38 52 39 export interface RelatedAccount { 53 40 $type?: "tools.ozone.signature.findRelatedAccounts#relatedAccount";

+4 -17

services/appview/lexicon/types/tools/ozone/signature/searchAccounts.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ComAtprotoAdminDefs from "../../../com/atproto/admin/defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 values: string[]; 10 8 cursor?: string; 11 9 limit: number; 12 12 - } 13 13 - 10 10 + }; 14 11 export type InputSchema = undefined; 15 12 16 13 export interface OutputSchema { ··· 18 15 accounts: (ComAtprotoAdminDefs.AccountView)[]; 19 16 } 20 17 21 21 - export type HandlerInput = undefined; 18 18 + export type HandlerInput = void; 22 19 23 20 export interface HandlerSuccess { 24 21 encoding: "application/json"; ··· 31 28 message?: string; 32 29 } 33 30 34 34 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 35 35 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 36 36 - auth: HA; 37 37 - params: QueryParams; 38 38 - input: HandlerInput; 39 39 - req: HonoRequest; 40 40 - resetRouteRateLimits: () => Promise<void>; 41 41 - }; 42 42 - export type Handler<HA extends HandlerAuth = never> = ( 43 43 - ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput; 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -15

services/appview/lexicon/types/tools/ozone/team/addMember.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneTeamDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 did: string; ··· 13 11 | "tools.ozone.team.defs#roleAdmin" 14 12 | "tools.ozone.team.defs#roleModerator" 15 13 | "tools.ozone.team.defs#roleTriage" 16 16 - | (string & { __brand?: never }); 14 14 + | (string & globalThis.Record<PropertyKey, never>); 17 15 } 18 16 19 17 export type OutputSchema = ToolsOzoneTeamDefs.Member; ··· 35 33 error?: "MemberAlreadyExists"; 36 34 } 37 35 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA; 41 41 - params: QueryParams; 42 42 - input: HandlerInput; 43 43 - req: HonoRequest; 44 44 - resetRouteRateLimits: () => Promise<void>; 45 45 - }; 46 46 - export type Handler<HA extends HandlerAuth = never> = ( 47 47 - ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput; 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -1

services/appview/lexicon/types/tools/ozone/team/defs.ts

reviewed

··· 20 20 | "lex:tools.ozone.team.defs#roleAdmin" 21 21 | "lex:tools.ozone.team.defs#roleModerator" 22 22 | "lex:tools.ozone.team.defs#roleTriage" 23 23 - | (string & { __brand?: never }); 23 23 + | (string & globalThis.Record<PropertyKey, never>); 24 24 } 25 25 26 26 const hashMember = "member";

+1 -16

services/appview/lexicon/types/tools/ozone/team/deleteMember.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth } from "@sprk/xrpc-server"; 6 6 - 7 7 - export type QueryParams = Record<never, never>; 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 8 5 9 6 export interface InputSchema { 10 7 did: string; 11 8 } 12 12 - 13 13 - export type OutputSchema = undefined; 14 9 15 10 export interface HandlerInput { 16 11 encoding: "application/json"; ··· 24 19 } 25 20 26 21 export type HandlerOutput = HandlerError | void; 27 27 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA; 29 29 - params: QueryParams; 30 30 - input: HandlerInput; 31 31 - req: HonoRequest; 32 32 - resetRouteRateLimits: () => Promise<void>; 33 33 - }; 34 34 - export type Handler<HA extends HandlerAuth = never> = ( 35 35 - ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput;

+4 -17

services/appview/lexicon/types/tools/ozone/team/listMembers.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneTeamDefs from "./defs.ts"; 7 5 8 8 - export interface QueryParams { 6 6 + export type QueryParams = { 9 7 disabled?: boolean; 10 8 roles?: string[]; 11 9 limit: number; 12 10 cursor?: string; 13 13 - } 14 14 - 11 11 + }; 15 12 export type InputSchema = undefined; 16 13 17 14 export interface OutputSchema { ··· 19 16 members: (ToolsOzoneTeamDefs.Member)[]; 20 17 } 21 18 22 22 - export type HandlerInput = undefined; 19 19 + export type HandlerInput = void; 23 20 24 21 export interface HandlerSuccess { 25 22 encoding: "application/json"; ··· 32 29 message?: string; 33 30 } 34 31 35 35 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 36 36 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 37 37 - auth: HA; 38 38 - params: QueryParams; 39 39 - input: HandlerInput; 40 40 - req: HonoRequest; 41 41 - resetRouteRateLimits: () => Promise<void>; 42 42 - }; 43 43 - export type Handler<HA extends HandlerAuth = never> = ( 44 44 - ctx: HandlerReqCtx<HA>, 45 45 - ) => Promise<HandlerOutput> | HandlerOutput; 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3 -15

services/appview/lexicon/types/tools/ozone/team/updateMember.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type HonoRequest } from "hono"; 5 5 - import { HandlerAuth, HandlerPipeThrough } from "@sprk/xrpc-server"; 6 4 import type * as ToolsOzoneTeamDefs from "./defs.ts"; 7 5 8 8 - export type QueryParams = Record<never, never>; 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 9 7 10 8 export interface InputSchema { 11 9 did: string; ··· 14 12 | "tools.ozone.team.defs#roleAdmin" 15 13 | "tools.ozone.team.defs#roleModerator" 16 14 | "tools.ozone.team.defs#roleTriage" 17 17 - | (string & { __brand?: never }); 15 15 + | (string & globalThis.Record<PropertyKey, never>); 18 16 } 19 17 20 18 export type OutputSchema = ToolsOzoneTeamDefs.Member; ··· 36 34 error?: "MemberNotFound"; 37 35 } 38 36 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA; 42 42 - params: QueryParams; 43 43 - input: HandlerInput; 44 44 - req: HonoRequest; 45 45 - resetRouteRateLimits: () => Promise<void>; 46 46 - }; 47 47 - export type Handler<HA extends HandlerAuth = never> = ( 48 48 - ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput; 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1 -1

services/appview/main.ts

reviewed

··· 92 92 API(lexServer, ctx); 93 93 94 94 app.route("/", wellKnownRouter()); 95 95 - app.route("/", lexServer.xrpc.routes); 95 95 + app.route("/", lexServer.xrpc.app); 96 96 97 97 // Root route 98 98 app.get("/", (c) => {

+37 -40

services/appview/services/auth-verifier.ts

reviewed

··· 1 1 import { KeyObject } from "node:crypto"; 2 2 import { IncomingHttpHeaders } from "node:http"; 3 3 import * as ui8 from "npm:uint8arrays"; 4 4 - import * as jose from "npm:jose"; 4 4 + import * as jose from "jose"; 5 5 import { 6 6 - AuthOutput, 7 6 AuthRequiredError, 8 8 - AuthVerifierContext, 7 7 + AuthResult, 8 8 + MethodAuthContext, 9 9 parseReqNsid, 10 10 verifyJwt, 11 11 } from "@sprk/xrpc-server"; ··· 17 17 isDataplaneError, 18 18 unpackIdentityKeys, 19 19 } from "../data-plane/client/index.ts"; 20 20 - import { HonoRequest } from "hono"; 21 20 22 21 interface MinimalRequest { 23 22 url?: string; ··· 88 87 89 88 export interface ExtendedAuthVerifier { 90 89 optionalStandardOrRole: ( 91 91 - ctx: AuthVerifierContext, 90 90 + ctx: MethodAuthContext, 92 91 ) => Promise<StandardOutput | RoleOutput | NullOutput>; 93 92 standardOrRole: ( 94 94 - ctx: AuthVerifierContext, 93 93 + ctx: MethodAuthContext, 95 94 ) => Promise<StandardOutput | RoleOutput>; 96 96 - standard: (ctx: AuthVerifierContext) => Promise<StandardOutput>; 97 97 - role: (ctx: AuthVerifierContext) => RoleOutput; 98 98 - modService: (ctx: AuthVerifierContext) => Promise<ModServiceOutput>; 95 95 + standard: (ctx: MethodAuthContext) => Promise<StandardOutput>; 96 96 + role: (ctx: MethodAuthContext) => RoleOutput; 97 97 + modService: (ctx: MethodAuthContext) => Promise<ModServiceOutput>; 99 98 roleOrModService: ( 100 100 - ctx: AuthVerifierContext, 99 99 + ctx: MethodAuthContext, 101 100 ) => Promise<RoleOutput | ModServiceOutput>; 102 101 parseCreds: ( 103 102 auth: StandardOutput | RoleOutput | NullOutput | ModServiceOutput, ··· 108 107 canPerformTakedown: boolean; 109 108 }; 110 109 standardOptional: ( 111 111 - ctx: AuthVerifierContext, 110 110 + ctx: MethodAuthContext, 112 111 ) => Promise<StandardOutput | NullOutput>; 113 112 standardOptionalParameterized: (opts: StandardAuthOpts) => ( 114 114 - ctx: AuthVerifierContext, 113 113 + ctx: MethodAuthContext, 115 114 ) => Promise<StandardOutput | NullOutput>; 116 116 - entrywaySession: (reqCtx: AuthVerifierContext) => Promise<StandardOutput>; 117 117 - parseRoleCreds: (req: MinimalRequest) => { 115 115 + entrywaySession: (reqCtx: MethodAuthContext) => Promise<StandardOutput>; 116 116 + parseRoleCreds: (req: Request) => { 118 117 status: RoleStatus; 119 118 admin: boolean; 120 119 type?: "role"; 121 120 }; 122 121 verifyServiceJwt: ( 123 123 - reqCtx: AuthVerifierContext, 122 122 + reqCtx: MethodAuthContext, 124 123 opts: { 125 124 iss: string[] | null; 126 125 aud: string | null; ··· 132 131 } 133 132 134 133 export interface AuthVerifier extends ExtendedAuthVerifier { 135 135 - (ctx: AuthVerifierContext): Promise<AuthOutput>; 134 134 + (ctx: MethodAuthContext): Promise<AuthResult>; 136 135 ownDid: string; 137 136 standardAudienceDids: Set<string>; 138 137 modServiceDid: string; ··· 147 146 const impl = new AuthVerifierImpl(dataplane, opts); 148 147 149 148 // Create the callable function 150 150 - const verifier = (( 151 151 - ctx: AuthVerifierContext, 152 152 - ): Promise<StandardOutput | RoleOutput | NullOutput> => { 149 149 + const verifier = ((ctx: MethodAuthContext): Promise<AuthResult> => { 153 150 return impl.optionalStandardOrRole(ctx); 154 151 }) as unknown as AuthVerifier; 155 152 ··· 164 161 verifier.entrywayJwtPublicKey = opts.entrywayJwtPublicKey; 165 162 166 163 // Add all methods from impl 167 167 - verifier.optionalStandardOrRole = (ctx: AuthVerifierContext) => { 164 164 + verifier.optionalStandardOrRole = (ctx: MethodAuthContext) => { 168 165 if ("c" in ctx) { 169 166 return impl.optionalStandardOrRole(ctx); 170 167 } 171 171 - return impl.optionalStandardOrRole(ctx as AuthVerifierContext); 168 168 + return impl.optionalStandardOrRole(ctx as MethodAuthContext); 172 169 }; 173 170 verifier.standardOrRole = impl.standardOrRole; 174 171 verifier.standard = impl.standard; ··· 212 209 // verifiers (arrow fns to preserve scope) 213 210 standardOptionalParameterized = 214 211 (opts: StandardAuthOpts) => 215 215 - async (ctx: AuthVerifierContext): Promise<StandardOutput | NullOutput> => { 212 212 + async (ctx: MethodAuthContext): Promise<StandardOutput | NullOutput> => { 216 213 if (isBasicToken(ctx.req)) { 217 214 const aud = this.ownDid; 218 218 - const iss = ctx.req.header("appview-as-did"); 215 215 + const iss = ctx.req.headers.get("appview-as-did"); 219 216 if (typeof iss !== "string" || !iss.startsWith("did:")) { 220 217 throw new AuthRequiredError("bad issuer"); 221 218 } ··· 261 258 }; 262 259 263 260 standardOptional: ( 264 264 - ctx: AuthVerifierContext, 261 261 + ctx: MethodAuthContext, 265 262 ) => Promise<StandardOutput | NullOutput> = this 266 263 .standardOptionalParameterized({}); 267 264 268 268 - standard = async (ctx: AuthVerifierContext): Promise<StandardOutput> => { 265 265 + standard = async (ctx: MethodAuthContext): Promise<StandardOutput> => { 269 266 const output = await this.standardOptional(ctx); 270 267 if (output.credentials.type === "none") { 271 268 throw new AuthRequiredError(undefined, "AuthMissing"); ··· 273 270 return output as StandardOutput; 274 271 }; 275 272 276 276 - role = (ctx: AuthVerifierContext): RoleOutput => { 273 273 + role = (ctx: MethodAuthContext): RoleOutput => { 277 274 const creds = this.parseRoleCreds(ctx.req); 278 275 if (creds.status !== RoleStatus.Valid) { 279 276 throw new AuthRequiredError(); ··· 288 285 }; 289 286 290 287 standardOrRole = async ( 291 291 - ctx: AuthVerifierContext, 288 288 + ctx: MethodAuthContext, 292 289 ): Promise<StandardOutput | RoleOutput> => { 293 290 if (isBearerToken(ctx.req)) { 294 291 return await this.standard(ctx); ··· 308 305 }; 309 306 310 307 optionalStandardOrRole = async ( 311 311 - ctx: AuthVerifierContext, 308 308 + ctx: MethodAuthContext, 312 309 ): Promise<StandardOutput | RoleOutput | NullOutput> => { 313 310 if (isBearerToken(ctx.req)) { 314 311 return await this.standard(ctx); ··· 334 331 // this is a short term fix to remove proxy load from Bluesky's PDS and in line with possible 335 332 // future plans to have the client talk directly with the appview 336 333 entrywaySession = async ( 337 337 - ctx: AuthVerifierContext, 334 334 + ctx: MethodAuthContext, 338 335 ): Promise<StandardOutput> => { 339 336 const token = bearerTokenFromReq(ctx.req); 340 337 if (!token) { ··· 380 377 }; 381 378 }; 382 379 383 383 - modService = async (ctx: AuthVerifierContext): Promise<ModServiceOutput> => { 380 380 + modService = async (ctx: MethodAuthContext): Promise<ModServiceOutput> => { 384 381 const { iss, aud } = await this.verifyServiceJwt(ctx, { 385 382 aud: this.ownDid, 386 383 iss: [this.modServiceDid, `${this.modServiceDid}#atproto_labeler`], ··· 392 389 }; 393 390 394 391 roleOrModService = async ( 395 395 - reqCtx: AuthVerifierContext, 392 392 + reqCtx: MethodAuthContext, 396 393 ): Promise<RoleOutput | ModServiceOutput> => { 397 394 if (isBearerToken(reqCtx.req)) { 398 395 return await this.modService(reqCtx); ··· 412 409 }; 413 410 414 411 parseRoleCreds( 415 415 - req: MinimalRequest | HonoRequest, 412 412 + req: Request, 416 413 ): { status: RoleStatus; admin: boolean; type?: "role" } { 417 417 - const parsed = parseBasicAuth(req.header("Authorization") || ""); 414 414 + const parsed = parseBasicAuth(req.headers.get("Authorization") || ""); 418 415 const { Missing, Valid, Invalid } = RoleStatus; 419 416 if (!parsed) { 420 417 return { status: Missing, admin: false }; ··· 429 426 // @NOTE this is not currently used, but is here for future use when we support mod services in future 430 427 // and potentially for payment providers 431 428 async verifyServiceJwt( 432 432 - reqCtx: AuthVerifierContext, 429 429 + reqCtx: MethodAuthContext, 433 430 opts: { 434 431 iss: string[] | null; 435 432 aud: string | null; ··· 541 538 const BEARER = "Bearer "; 542 539 const BASIC = "Basic "; 543 540 544 544 - const isBearerToken = (req: MinimalRequest | HonoRequest): boolean => { 545 545 - return req.header("Authorization")?.startsWith(BEARER) ?? false; 541 541 + const isBearerToken = (req: Request): boolean => { 542 542 + return req.headers.get("Authorization")?.startsWith(BEARER) ?? false; 546 543 }; 547 544 548 548 - const isBasicToken = (req: MinimalRequest | HonoRequest): boolean => { 549 549 - return req.header("Authorization")?.startsWith(BASIC) ?? false; 545 545 + const isBasicToken = (req: Request): boolean => { 546 546 + return req.headers.get("Authorization")?.startsWith(BASIC) ?? false; 550 547 }; 551 548 552 552 - const bearerTokenFromReq = (req: MinimalRequest | HonoRequest) => { 553 553 - const header = req.header("Authorization") || ""; 549 549 + const bearerTokenFromReq = (req: Request) => { 550 550 + const header = req.headers.get("Authorization") || ""; 554 551 if (!header.startsWith(BEARER)) return null; 555 552 return header.slice(BEARER.length).trim(); 556 553 };

+2 -2

services/appview/utils/post-transformer.ts

reviewed

··· 132 132 record: { 133 133 $type: "so.sprk.feed.post", 134 134 text: post.text, 135 135 - embed: post.embed as SoSprkFeedPost.MainRecord["embed"], 135 135 + embed: post.embed as SoSprkFeedPost.Record["embed"], 136 136 facets: post.facets, 137 137 langs: post.langs, 138 138 tags: post.tags, 139 139 createdAt: post.createdAt, 140 140 - } satisfies SoSprkFeedPost.MainRecord, 140 140 + } satisfies SoSprkFeedPost.Record, 141 141 embed: embed, 142 142 viewer, 143 143 replyCount: replyCountsMap.get(post.uri) || 0,