Repository: modiimedia/arri (language: rust)

Issue:
[arri-codegen-dart] Dart client causes 400 when params are undefined
Dart client will cause an error when RPC looks like this:

```ts
export default defineRpc({
  params: undefined, // dart client causes error here
  response: a.object({
    message: a.string(),
  }),
  handle() {
    // whatever
  }

```


Discussion / hints:

Fix patch:
diff --git a/packages/arri-client-dart/lib/request.dart b/packages/arri-client-dart/lib/request.dart
index 47140048..5a22f8e7 100644
--- a/packages/arri-client-dart/lib/request.dart
+++ b/packages/arri-client-dart/lib/request.dart
@@ -33,8 +33,10 @@ Future<http.Response> arriRequest(
   /// manually specify a specific encoding
   Encoding? encoding,
 }) async {
+  String defaultErrorMsg =
+      "Placeholder request. If you see this that means a request was never sent to the server.";
   http.Response result = http.Response(
-    "Placeholder request. If you see this that means a request was never sent to the server.",
+    """{"statusCode": 400,"statusMessage":"$defaultErrorMsg"}""",
     400,
   );
   final finalHeaders = {...headers ?? {}};
@@ -57,7 +59,10 @@ Future<http.Response> arriRequest(
           uri,
           headers: finalHeaders,
         );
+        break;
       }
+      final uri = Uri.parse(url);
+      result = await client.get(uri, headers: finalHeaders);
       break;
     case HttpMethod.patch:
       result = await client.patch(
diff --git a/packages/arri-codegen/dart-reference/pubspec.lock b/packages/arri-codegen/dart-reference/pubspec.lock
index f9d13bfe..1a426016 100644
--- a/packages/arri-codegen/dart-reference/pubspec.lock
+++ b/packages/arri-codegen/dart-reference/pubspec.lock
@@ -31,7 +31,7 @@ packages:
       path: "../../arri-client-dart"
       relative: true
     source: path
-    version: "0.30.0"
+    version: "0.33.0"
   async:
     dependency: transitive
     description:
diff --git a/tsconfig.base.json b/tsconfig.base.json
index e29abb3a..015c317a 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -2,10 +2,11 @@
   "compilerOptions": {
     "baseUrl": ".",
     "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "Node",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
     "strict": true,
     "skipLibCheck": true
   }


Test patch:
diff --git a/tests/clients/client-dart/lib/test_client.rpc.dart b/tests/clients/client-dart/lib/test_client.rpc.dart
index 23f5f81c..5acbd310 100644
--- a/tests/clients/client-dart/lib/test_client.rpc.dart
+++ b/tests/clients/client-dart/lib/test_client.rpc.dart
@@ -17,8 +17,8 @@ class TestClient {
     _headers = {"client-version": "10", ...headers};
   }
 
-  TestClientAuthorsService get authors {
-    return TestClientAuthorsService(
+  TestClientTestsService get tests {
+    return TestClientTestsService(
       httpClient: _httpClient,
       baseUrl: _baseUrl,
       headers: _headers,
@@ -32,21 +32,13 @@ class TestClient {
       headers: _headers,
     );
   }
-
-  TestClientMiscTestsService get miscTests {
-    return TestClientMiscTestsService(
-      httpClient: _httpClient,
-      baseUrl: _baseUrl,
-      headers: _headers,
-    );
-  }
 }
 
-class TestClientAuthorsService {
+class TestClientTestsService {
   final http.Client? _httpClient;
   final String _baseUrl;
   late final Map<String, String> _headers;
-  TestClientAuthorsService({
+  TestClientTestsService({
     http.Client? httpClient,
     String baseUrl = "",
     Map<String, String> headers = const {},
@@ -55,65 +47,59 @@ class TestClientAuthorsService {
     _headers = {"client-version": "10", ...headers};
   }
 
-  Future<Author> updateAuthor(AuthorsUpdateAuthorParams params) {
+  Future<DefaultPayload> emptyParamsGetRequest() {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/authors/update-author",
+      "$_baseUrl/rpcs/tests/empty-params-get-request",
       httpClient: _httpClient,
-      method: HttpMethod.post,
+      method: HttpMethod.get,
       headers: _headers,
-      params: params.toJson(),
-      parser: (body) => Author.fromJson(
+      params: null,
+      parser: (body) => DefaultPayload.fromJson(
         json.decode(body),
       ),
     );
   }
-}
-
-class TestClientAdaptersService {
-  final http.Client? _httpClient;
-  final String _baseUrl;
-  late final Map<String, String> _headers;
-  TestClientAdaptersService({
-    http.Client? httpClient,
-    String baseUrl = "",
-    Map<String, String> headers = const {},
-  })  : _httpClient = httpClient,
-        _baseUrl = baseUrl {
-    _headers = {"client-version": "10", ...headers};
-  }
 
-  Future<TypeBoxObject> typebox(TypeBoxObject params) {
+  Future<DefaultPayload> emptyParamsPostRequest() {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/adapters/typebox",
+      "$_baseUrl/rpcs/tests/empty-params-post-request",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
-      params: params.toJson(),
-      parser: (body) => TypeBoxObject.fromJson(
+      params: null,
+      parser: (body) => DefaultPayload.fromJson(
         json.decode(body),
       ),
     );
   }
-}
 
-class TestClientMiscTestsService {
-  final http.Client? _httpClient;
-  final String _baseUrl;
-  late final Map<String, String> _headers;
-  TestClientMiscTestsService({
-    http.Client? httpClient,
-    String baseUrl = "",
-    Map<String, String> headers = const {},
-  })  : _httpClient = httpClient,
-        _baseUrl = baseUrl {
-    _headers = {"client-version": "10", ...headers};
+  Future<void> emptyResponseGetRequest(DefaultPayload params) {
+    return parsedArriRequest(
+      "$_baseUrl/rpcs/tests/empty-response-get-request",
+      httpClient: _httpClient,
+      method: HttpMethod.get,
+      headers: _headers,
+      params: params.toJson(),
+      parser: (body) {},
+    );
+  }
+
+  Future<void> emptyResponsePostRequest(DefaultPayload params) {
+    return parsedArriRequest(
+      "$_baseUrl/rpcs/tests/empty-response-post-request",
+      httpClient: _httpClient,
+      method: HttpMethod.post,
+      headers: _headers,
+      params: params.toJson(),
+      parser: (body) {},
+    );
   }
 
-  /// This RPC is no longer supported
+  /// If the target language supports it. Generated code should mark this procedure as deprecated.
   @deprecated
   Future<void> deprecatedRpc(DeprecatedRpcParams params) {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/misc-tests/deprecated-rpc",
+      "$_baseUrl/rpcs/tests/deprecated-rpc",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
@@ -124,7 +110,7 @@ class TestClientMiscTestsService {
 
   Future<ObjectWithEveryType> sendObject(ObjectWithEveryType params) {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/misc-tests/send-object",
+      "$_baseUrl/rpcs/tests/send-object",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
@@ -138,7 +124,7 @@ class TestClientMiscTestsService {
   Future<ObjectWithEveryNullableType> sendObjectWithNullableFields(
       ObjectWithEveryNullableType params) {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/misc-tests/send-object-with-nullable-fields",
+      "$_baseUrl/rpcs/tests/send-object-with-nullable-fields",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
@@ -152,7 +138,7 @@ class TestClientMiscTestsService {
   Future<ObjectWithEveryOptionalType> sendPartialObject(
       ObjectWithEveryOptionalType params) {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/misc-tests/send-partial-object",
+      "$_baseUrl/rpcs/tests/send-partial-object",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
@@ -165,7 +151,7 @@ class TestClientMiscTestsService {
 
   Future<RecursiveObject> sendRecursiveObject(RecursiveObject params) {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/misc-tests/send-recursive-object",
+      "$_baseUrl/rpcs/tests/send-recursive-object",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
@@ -178,7 +164,7 @@ class TestClientMiscTestsService {
 
   Future<RecursiveUnion> sendRecursiveUnion(RecursiveUnion params) {
     return parsedArriRequest(
-      "$_baseUrl/rpcs/misc-tests/send-recursive-union",
+      "$_baseUrl/rpcs/tests/send-recursive-union",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
@@ -199,7 +185,7 @@ class TestClientMiscTestsService {
     String? lastEventId,
   }) {
     return parsedArriSseRequest<AutoReconnectResponse>(
-      "$_baseUrl/rpcs/misc-tests/stream-auto-reconnect",
+      "$_baseUrl/rpcs/tests/stream-auto-reconnect",
       httpClient: _httpClient,
       method: HttpMethod.get,
       headers: _headers,
@@ -216,6 +202,7 @@ class TestClientMiscTestsService {
     );
   }
 
+  /// This route will always return an error. The client should automatically retry with exponential backoff.
   EventSource<StreamConnectionErrorTestResponse> streamConnectionErrorTest(
     StreamConnectionErrorTestParams params, {
     SseHookOnData<StreamConnectionErrorTestResponse>? onData,
@@ -227,7 +214,7 @@ class TestClientMiscTestsService {
     String? lastEventId,
   }) {
     return parsedArriSseRequest<StreamConnectionErrorTestResponse>(
-      "$_baseUrl/rpcs/misc-tests/stream-connection-error-test",
+      "$_baseUrl/rpcs/tests/stream-connection-error-test",
       httpClient: _httpClient,
       method: HttpMethod.get,
       headers: _headers,
@@ -244,6 +231,7 @@ class TestClientMiscTestsService {
     );
   }
 
+  /// Test to ensure that the client can handle receiving streams of large objects. When objects are large messages will sometimes get sent in chunks. Meaning you have to handle receiving a partial message
   EventSource<StreamLargeObjectsResponse> streamLargeObjects({
     SseHookOnData<StreamLargeObjectsResponse>? onData,
     SseHookOnError<StreamLargeObjectsResponse>? onError,
@@ -253,7 +241,7 @@ class TestClientMiscTestsService {
     String? lastEventId,
   }) {
     return parsedArriSseRequest<StreamLargeObjectsResponse>(
-      "$_baseUrl/rpcs/misc-tests/stream-large-objects",
+      "$_baseUrl/rpcs/tests/stream-large-objects",
       httpClient: _httpClient,
       method: HttpMethod.get,
       headers: _headers,
@@ -280,7 +268,7 @@ class TestClientMiscTestsService {
     String? lastEventId,
   }) {
     return parsedArriSseRequest<ChatMessage>(
-      "$_baseUrl/rpcs/misc-tests/stream-messages",
+      "$_baseUrl/rpcs/tests/stream-messages",
       httpClient: _httpClient,
       method: HttpMethod.get,
       headers: _headers,
@@ -297,6 +285,7 @@ class TestClientMiscTestsService {
     );
   }
 
+  /// When the client receives the 'done' event, it should close the connection and NOT reconnect
   EventSource<ChatMessage> streamTenEventsThenEnd({
     SseHookOnData<ChatMessage>? onData,
     SseHookOnError<ChatMessage>? onError,
@@ -306,7 +295,7 @@ class TestClientMiscTestsService {
     String? lastEventId,
   }) {
     return parsedArriSseRequest<ChatMessage>(
-      "$_baseUrl/rpcs/misc-tests/stream-ten-events-then-end",
+      "$_baseUrl/rpcs/tests/stream-ten-events-then-end",
       httpClient: _httpClient,
       method: HttpMethod.get,
       headers: _headers,
@@ -332,7 +321,7 @@ class TestClientMiscTestsService {
     String? lastEventId,
   }) {
     return parsedArriSseRequest<ChatMessage>(
-      "$_baseUrl/rpcs/misc-tests/stream-ten-events-then-error",
+      "$_baseUrl/rpcs/tests/stream-ten-events-then-error",
       httpClient: _httpClient,
       method: HttpMethod.post,
       headers: _headers,
@@ -350,6 +339,33 @@ class TestClientMiscTestsService {
   }
 }
 
+class TestClientAdaptersService {
+  final http.Client? _httpClient;
+  final String _baseUrl;
+  late final Map<String, String> _headers;
+  TestClientAdaptersService({
+    http.Client? httpClient,
+    String baseUrl = "",
+    Map<String, String> headers = const {},
+  })  : _httpClient = httpClient,
+        _baseUrl = baseUrl {
+    _headers = {"client-version": "10", ...headers};
+  }
+
+  Future<TypeBoxObject> typebox(TypeBoxObject params) {
+    return parsedArriRequest(
+      "$_baseUrl/rpcs/adapters/typebox",
+      httpClient: _httpClient,
+      method: HttpMethod.post,
+      headers: _headers,
+      params: params.toJson(),
+      parser: (body) => TypeBoxObject.fromJson(
+        json.decode(body),
+      ),
+    );
+  }
+}
+
 class ManuallyAddedModel {
   final String hello;
   const ManuallyAddedModel({
@@ -378,146 +394,30 @@ class ManuallyAddedModel {
   }
 }
 
-class AuthorsUpdateAuthorParams {
-  final String authorId;
-  final UpdateAuthorData data;
-  const AuthorsUpdateAuthorParams({
-    required this.authorId,
-    required this.data,
-  });
-  factory AuthorsUpdateAuthorParams.fromJson(Map<String, dynamic> json) {
-    return AuthorsUpdateAuthorParams(
-      authorId: typeFromDynamic<String>(json["authorId"], ""),
-      data: UpdateAuthorData.fromJson(json["data"]),
-    );
-  }
-
-  Map<String, dynamic> toJson() {
-    final __result = <String, dynamic>{
-      "authorId": authorId,
-      "data": data.toJson(),
-    };
-
-    return __result;
-  }
-
-  AuthorsUpdateAuthorParams copyWith({
-    String? authorId,
-    UpdateAuthorData? data,
-  }) {
-    return AuthorsUpdateAuthorParams(
-      authorId: authorId ?? this.authorId,
-      data: data ?? this.data,
-    );
-  }
-}
-
-class UpdateAuthorData {
-  final String? name;
-  final String? bio;
-  final DateTime? createdAt;
-  final DateTime? updatedAt;
-  const UpdateAuthorData({
-    this.name,
-    this.bio,
-    this.createdAt,
-    this.updatedAt,
-  });
-  factory UpdateAuthorData.fromJson(Map<String, dynamic> json) {
-    return UpdateAuthorData(
-      name: nullableTypeFromDynamic<String>(json["name"]),
-      bio: nullableTypeFromDynamic<String>(json["bio"]),
-      createdAt: nullableDateTimeFromDynamic(json["createdAt"]),
-      updatedAt: nullableDateTimeFromDynamic(json["updatedAt"]),
-    );
-  }
-
-  Map<String, dynamic> toJson() {
-    final __result = <String, dynamic>{};
-    if (name != null) {
-      __result["name"] = name;
-    }
-    if (bio != null) {
-      __result["bio"] = bio;
-    }
-    if (createdAt != null) {
-      __result["createdAt"] = createdAt?.toUtc().toIso8601String();
-    }
-    if (updatedAt != null) {
-      __result["updatedAt"] = updatedAt?.toUtc().toIso8601String();
-    }
-    return __result;
-  }
-
-  UpdateAuthorData copyWith({
-    String? name,
-    String? bio,
-    DateTime? createdAt,
-    DateTime? updatedAt,
-  }) {
-    return UpdateAuthorData(
-      name: name ?? this.name,
-      bio: bio ?? this.bio,
-      createdAt: createdAt ?? this.createdAt,
-      updatedAt: updatedAt ?? this.updatedAt,
-    );
-  }
-}
-
-class Author {
-  final String id;
-  final String name;
-  final String? bio;
-  final DateTime createdAt;
-  final DateTime updatedAt;
-  const Author({
-    required this.id,
-    required this.name,
-    required this.bio,
-    required this.createdAt,
-    required this.updatedAt,
+class DefaultPayload {
+  final String message;
+  const DefaultPayload({
+    required this.message,
   });
-  factory Author.fromJson(Map<String, dynamic> json) {
-    return Author(
-      id: typeFromDynamic<String>(json["id"], ""),
-      name: typeFromDynamic<String>(json["name"], ""),
-      bio: nullableTypeFromDynamic<String>(json["bio"]),
-      createdAt: dateTimeFromDynamic(
-        json["createdAt"],
-        DateTime.fromMillisecondsSinceEpoch(0),
-      ),
-      updatedAt: dateTimeFromDynamic(
-        json["updatedAt"],
-        DateTime.fromMillisecondsSinceEpoch(0),
-      ),
+  factory DefaultPayload.fromJson(Map<String, dynamic> json) {
+    return DefaultPayload(
+      message: typeFromDynamic<String>(json["message"], ""),
     );
   }
 
   Map<String, dynamic> toJson() {
     final __result = <String, dynamic>{
-      "id": id,
-      "name": name,
-      "bio": bio,
-      "createdAt": createdAt.toUtc().toIso8601String(),
-      "updatedAt": updatedAt.toUtc().toIso8601String(),
+      "message": message,
     };
 
     return __result;
   }
 
-  Author copyWith({
-    String? id,
-    String? name,
-    String? bio,
-    DateTime? createdAt,
-    DateTime? updatedAt,
+  DefaultPayload copyWith({
+    String? message,
   }) {
-    return Author(
-      id: id ?? this.id,
-      name: name ?? this.name,
-      bio: bio ?? this.bio,
-      createdAt: createdAt ?? this.createdAt,
-      updatedAt: updatedAt ?? this.updatedAt,
+    return DefaultPayload(
+      message: message ?? this.message,
     );
   }
 }
diff --git a/tests/clients/client-dart/test/test_client_test.dart b/tests/clients/client-dart/test/test_client_test.dart
index eea11e27..e30446b2 100644
--- a/tests/clients/client-dart/test/test_client_test.dart
+++ b/tests/clients/client-dart/test/test_client_test.dart
@@ -3,6 +3,7 @@ import 'dart:io';
 import 'package:arri_client/arri_client.dart';
 import "package:test/test.dart";
 import 'package:test_client_dart/test_client.rpc.dart';
+// ignore: depend_on_referenced_packages
 import 'package:http/io_client.dart';
 
 Future<void> main() async {
@@ -18,374 +19,393 @@ Future<void> main() async {
     headers: {"x-test-header": 'test'},
   );
 
-  group("miscTests", () {
-    final input = ObjectWithEveryType(
-        any: {"hello": "world", "goodbye": "world"},
-        boolean: true,
-        string: "",
+  test("supports RPCs with no params", () async {
+    try {
+      await client.tests.emptyParamsGetRequest();
+      await client.tests.emptyParamsPostRequest();
+    } catch (err) {
+      print("ERROR: ${err.toString()}");
+      expect(false, equals(true));
+    }
+  });
+  test("supports RPCs with no response", () async {
+    try {
+      await client.tests.emptyResponseGetRequest(
+        DefaultPayload(message: "ok"),
+      );
+      await client.tests.emptyResponsePostRequest(
+        DefaultPayload(message: "ok"),
+      );
+    } catch (err) {
+      print("ERROR ${err.toString()}");
+      expect(false, equals(true));
+    }
+  });
+
+  final input = ObjectWithEveryType(
+      any: {"hello": "world", "goodbye": "world"},
+      boolean: true,
+      string: "",
+      timestamp: DateTime.now(),
+      float32: 1,
+      float64: 1,
+      int8: 1,
+      uint8: 1,
+      int16: 1,
+      uint16: 1,
+      int32: 1,
+      uint32: 1,
+      int64: BigInt.from(1),
+      uint64: BigInt.from(1),
+      enumerator: ObjectWithEveryTypeEnumerator.a,
+      array: [true, false],
+      object: ObjectWithEveryTypeObject(
+          boolean: true, string: "", timestamp: DateTime.now()),
+      record: {
+        "A": true,
+        "B": false,
+      },
+      discriminator: ObjectWithEveryTypeDiscriminatorA(title: "Hello World"),
+      nestedObject: ObjectWithEveryTypeNestedObject(
+        id: "",
         timestamp: DateTime.now(),
-        float32: 1,
-        float64: 1,
-        int8: 1,
-        uint8: 1,
-        int16: 1,
-        uint16: 1,
-        int32: 1,
-        uint32: 1,
-        int64: BigInt.from(1),
-        uint64: BigInt.from(1),
-        enumerator: ObjectWithEveryTypeEnumerator.a,
-        array: [true, false],
-        object: ObjectWithEveryTypeObject(
-            boolean: true, string: "", timestamp: DateTime.now()),
-        record: {
-          "A": true,
-          "B": false,
-        },
-        discriminator: ObjectWithEveryTypeDiscriminatorA(title: "Hello World"),
-        nestedObject: ObjectWithEveryTypeNestedObject(
-          id: "",
-          timestamp: DateTime.now(),
-          data: ObjectWithEveryTypeNestedObjectData(
+        data: ObjectWithEveryTypeNestedObjectData(
+            id: "",
+            timestamp: DateTime.now(),
+            data: ObjectWithEveryTypeNestedObjectDataData(
               id: "",
               timestamp: DateTime.now(),
-              data: ObjectWithEveryTypeNestedObjectDataData(
-                id: "",
-                timestamp: DateTime.now(),
-              )),
-        ),
-        nestedArray: [
-          [
-            ObjectWithEveryTypeNestedArrayItemItem(
-                id: "", timestamp: DateTime.now())
-          ]
-        ]);
-    test("sendObject()", () async {
-      final result = await client.miscTests.sendObject(input);
-      expect(result.any["hello"], equals(input.any["hello"]));
-      expect(result.array.length, equals(input.array.length));
-      expect(result.array[0], equals(input.array[0]));
-      expect(result.boolean, equals(input.boolean));
-      expect(result.discriminator.type, equals(input.discriminator.type));
-      expect(result.enumerator.value, equals(input.enumerator.value));
-      expect(result.float32, equals(input.float32));
-      expect(result.float64, equals(input.float64));
-      expect(result.int16, equals(input.int16));
-      expect(result.int64, equals(input.int64));
-      expect(result.object.boolean, equals(input.object.boolean));
-      expect(result.record["A"], equals(input.record["A"]));
-      expect(
-        result.nestedObject.data.data.timestamp.microsecond,
-        equals(result.nestedObject.data.data.timestamp.microsecond),
-      );
-      final input2 = input.copyWith(int16: 999);
-      final result2 = await client.miscTests.sendObject(input2);
-      expect(result2.int16, equals(999));
-    });
-    test("sendObject() with custom http client", () async {
-      final result = await clientWCustomHttpClient.miscTests.sendObject(input);
-      expect(result.array.length, equals(input.array.length));
-      expect(result.int64, equals(input.int64));
-      expect(result.uint64, equals(input.uint64));
-    });
-    test("sendObject() with unauthenticated client", () async {
-      try {
-        await unauthenticatedClient.miscTests.sendObject(input);
-        expect(false, equals(true));
-      } catch (err) {
-        if (err is ArriRequestError) {
-          expect(err.statusCode, equals(401));
-          return;
-        }
-        expect(false, equals(true));
+            )),
+      ),
+      nestedArray: [
+        [
+          ObjectWithEveryTypeNestedArrayItemItem(
+              id: "", timestamp: DateTime.now())
+        ]
+      ]);
+  test("can send/receive objects with every field type", () async {
+    final result = await client.tests.sendObject(input);
+    expect(result.any["hello"], equals(input.any["hello"]));
+    expect(result.array.length, equals(input.array.length));
+    expect(result.array[0], equals(input.array[0]));
+    expect(result.boolean, equals(input.boolean));
+    expect(result.discriminator.type, equals(input.discriminator.type));
+    expect(result.enumerator.value, equals(input.enumerator.value));
+    expect(result.float32, equals(input.float32));
+    expect(result.float64, equals(input.float64));
+    expect(result.int16, equals(input.int16));
+    expect(result.int64, equals(input.int64));
+    expect(result.object.boolean, equals(input.object.boolean));
+    expect(result.record["A"], equals(input.record["A"]));
+    expect(
+      result.nestedObject.data.data.timestamp.microsecond,
+      equals(result.nestedObject.data.data.timestamp.microsecond),
+    );
+    final input2 = input.copyWith(int16: 999);
+    final result2 = await client.tests.sendObject(input2);
+    expect(result2.int16, equals(999));
+  });
+  test("supports injecting custom http clients", () async {
+    final result = await clientWCustomHttpClient.tests.sendObject(input);
+    expect(result.array.length, equals(input.array.length));
+    expect(result.int64, equals(input.int64));
+    expect(result.uint64, equals(input.uint64));
+  });
+  test("unauthenticated RPC requests return a 401 error", () async {
+    try {
+      await unauthenticatedClient.tests.sendObject(input);
+      expect(false, equals(true));
+    } catch (err) {
+      if (err is ArriRequestError) {
+        expect(err.statusCode, equals(401));
+        return;
       }
-    });
-    test("sendPartialObject()", () async {
-      final input = ObjectWithEveryOptionalType(
-        int16: 0,
-        int64: BigInt.zero,
-        nestedArray: [
-          [
-            ObjectWithEveryOptionalTypeNestedArrayItemItem(
-                id: "", timestamp: DateTime.now())
-          ]
-        ],
-      );
-      final result = await client.miscTests.sendPartialObject(input);
-      expect(result.string, equals(null));
-      expect(result.int16, equals(0));
-      expect(result.int64, equals(BigInt.zero));
-      expect(result.nestedArray?[0][0].id, equals(""));
-    });
-    test("sendObjectWithNullableFields()", () async {
-      final input = ObjectWithEveryNullableType(
-        any: null,
-        boolean: null,
-        string: null,
+      expect(false, equals(true));
+    }
+  });
+  test("can send/receive objects with partial fields", () async {
+    final input = ObjectWithEveryOptionalType(
+      int16: 0,
+      int64: BigInt.zero,
+      nestedArray: [
+        [
+          ObjectWithEveryOptionalTypeNestedArrayItemItem(
+              id: "", timestamp: DateTime.now())
+        ]
+      ],
+    );
+    final result = await client.tests.sendPartialObject(input);
+    expect(result.string, equals(null));
+    expect(result.int16, equals(0));
+    expect(result.int64, equals(BigInt.zero));
+    expect(result.nestedArray?[0][0].id, equals(""));
+  });
+  test("can send/receive objects with nullable fields", () async {
+    final input = ObjectWithEveryNullableType(
+      any: null,
+      boolean: null,
+      string: null,
+      timestamp: null,
+      float32: null,
+      float64: null,
+      int8: null,
+      uint8: null,
+      int16: null,
+      uint16: null,
+      int32: null,
+      uint32: null,
+      int64: null,
+      uint64: null,
+      enumerator: null,
+      array: null,
+      object: null,
+      record: null,
+      discriminator: null,
+      nestedObject: null,
+      nestedArray: null,
+    );
+    final result = await client.tests.sendObjectWithNullableFields(input);
+    expect(result.string, equals(null));
+    expect(result.array, equals(null));
+    final input2 = input.copyWith(
+      int64: BigInt.zero,
+      discriminator: ObjectWithEveryNullableTypeDiscriminatorA(title: null),
+      nestedObject: ObjectWithEveryNullableTypeNestedObject(
+        id: null,
         timestamp: null,
-        float32: null,
-        float64: null,
-        int8: null,
-        uint8: null,
-        int16: null,
-        uint16: null,
-        int32: null,
-        uint32: null,
-        int64: null,
-        uint64: null,
-        enumerator: null,
-        array: null,
-        object: null,
-        record: null,
-        discriminator: null,
-        nestedObject: null,
-        nestedArray: null,
-      );
-      final result = await client.miscTests.sendObjectWithNullableFields(input);
-      expect(result.string, equals(null));
-      expect(result.array, equals(null));
-      final input2 = input.copyWith(
-        int64: BigInt.zero,
-        discriminator: ObjectWithEveryNullableTypeDiscriminatorA(title: null),
-        nestedObject: ObjectWithEveryNullableTypeNestedObject(
-          id: null,
-          timestamp: null,
-          data: ObjectWithEveryNullableTypeNestedObjectData(
-              id: "", timestamp: null, data: null),
-        ),
-        nestedArray: [null],
-      );
-      final result2 =
-          await client.miscTests.sendObjectWithNullableFields(input2);
-      expect(result2.nestedArray?[0], equals(null));
-      expect(result2.nestedObject?.data?.id, equals(""));
-      expect(result2.int64, equals(BigInt.zero));
-      expect(
-        result2.discriminator is ObjectWithEveryNullableTypeDiscriminatorA,
-        equals(true),
-      );
-    });
-    test("sendRecursiveObject", () async {
-      final input = RecursiveObject(
+        data: ObjectWithEveryNullableTypeNestedObjectData(
+            id: "", timestamp: null, data: null),
+      ),
+      nestedArray: [null],
+    );
+    final result2 = await client.tests.sendObjectWithNullableFields(input2);
+    expect(result2.nestedArray?[0], equals(null));
+    expect(result2.nestedObject?.data?.id, equals(""));
+    expect(result2.int64, equals(BigInt.zero));
+    expect(
+      result2.discriminator is ObjectWithEveryNullableTypeDiscriminatorA,
+      equals(true),
+    );
+  });
+  test("can send/receive recursive objects", () async {
+    final input = RecursiveObject(
+      left: RecursiveObject(
         left: RecursiveObject(
-          left: RecursiveObject(
-            left: null,
-            right: null,
-            value: "depth2",
-          ),
-          right: null,
-          value: "depth1",
-        ),
-        right: RecursiveObject(
           left: null,
           right: null,
-          value: "depth1,",
+          value: "depth2",
         ),
-        value: "depth0",
-      );
-      final result = await client.miscTests.sendRecursiveObject(input);
-      expect(result.left?.left?.left, equals(null));
-      expect(result.left?.left?.value, equals("depth2"));
-    });
-    test("sendRecursiveUnion", () async {
-      final input = RecursiveUnionChildren(
-        data: [
-          RecursiveUnionChild(
-            data: RecursiveUnionText(
-              data: "hello world",
-            ),
+        right: null,
+        value: "depth1",
+      ),
+      right: RecursiveObject(
+        left: null,
+        right: null,
+        value: "depth1,",
+      ),
+      value: "depth0",
+    );
+    final result = await client.tests.sendRecursiveObject(input);
+    expect(result.left?.left?.left, equals(null));
+    expect(result.left?.left?.value, equals("depth2"));
+  });
+  test("can send/receive recursive unions", () async {
+    final input = RecursiveUnionChildren(
+      data: [
+        RecursiveUnionChild(
+          data: RecursiveUnionText(
+            data: "hello world",
           ),
-          RecursiveUnionShape(
-            data: RecursiveUnionShapeData(
-              width: 1,
-              height: 1,
-              color: "blue",
-            ),
+        ),
+        RecursiveUnionShape(
+          data: RecursiveUnionShapeData(
+            width: 1,
+            height: 1,
+            color: "blue",
           ),
-        ],
-      );
-      final result = await client.miscTests.sendRecursiveUnion(input);
-      expect(result is RecursiveUnionChildren, equals(true));
-      expect((result as RecursiveUnionChildren).data.length, equals(2));
-      expect((result.data[0] as RecursiveUnionChild).data is RecursiveUnionText,
-          equals(true));
-    });
+        ),
+      ],
+    );
+    final result = await client.tests.sendRecursiveUnion(input);
+    expect(result is RecursiveUnionChildren, equals(true));
+    expect((result as RecursiveUnionChildren).data.length, equals(2));
+    expect((result.data[0] as RecursiveUnionChild).data is RecursiveUnionText,
+        equals(true));
   });
 
-  group("stream requests", () {
-    test("basic subscription", () async {
-      int messageCount = 0;
-      final eventSource = client.miscTests.streamMessages(
-        ChatMessageParams(channelId: "12345"),
-        onData: (data, _) {
-          messageCount++;
-          switch (data) {
-            case ChatMessageText():
-              expect(data.channelId, equals('12345'));
-              expect(data.messageType, equals("TEXT"));
-              break;
-            case ChatMessageImage():
-              expect(data.channelId, equals("12345"));
-              expect(data.messageType, equals("IMAGE"));
-              break;
-            case ChatMessageUrl():
-              expect(data.channelId, equals("12345"));
-              expect(data.messageType, equals("URL"));
-              break;
-          }
-        },
-      );
-      await Future.delayed(Duration(milliseconds: 500));
-      eventSource.close();
-      expect(messageCount > 0, equals(true));
-      expect(eventSource.isClosed, equals(true));
-    });
-    test("basic subscription with dart streams", () async {
-      int messageCount = 0;
-      final eventSource = client.miscTests
-          .streamMessages(ChatMessageParams(channelId: "12345"));
-      final listener = eventSource.toStream().listen((message) {
+  test("[SSE] supports server sent events", () async {
+    int messageCount = 0;
+    final eventSource = client.tests.streamMessages(
+      ChatMessageParams(channelId: "12345"),
+      onData: (data, _) {
         messageCount++;
-        switch (message) {
+        switch (data) {
           case ChatMessageText():
-            expect(message.channelId, equals('12345'));
-            expect(message.messageType, equals("TEXT"));
+            expect(data.channelId, equals('12345'));
+            expect(data.messageType, equals("TEXT"));
             break;
           case ChatMessageImage():
-            expect(message.channelId, equals("12345"));
-            expect(message.messageType, equals("IMAGE"));
+            expect(data.channelId, equals("12345"));
+            expect(data.messageType, equals("IMAGE"));
             break;
           case ChatMessageUrl():
-            expect(message.channelId, equals("12345"));
-            expect(message.messageType, equals("URL"));
+            expect(data.channelId, equals("12345"));
+            expect(data.messageType, equals("URL"));
             break;
         }
-      });
-      await Future.delayed(Duration(milliseconds: 500));
-      await listener.cancel();
-      expect(messageCount >= 1, equals(true));
-      expect(eventSource.isClosed, equals(true));
-    });
-    test("subscription with errors", () async {
-      int messageCount = 0;
-      int errorCount = 0;
-      final eventSource = client.miscTests.streamTenEventsThenError(
-        onData: (data, connection) {
-          messageCount++;
-          expect(data.messageType.isNotEmpty, equals(true));
-        },
-        onError: (error, connection) {
-          errorCount++;
-          connection.close();
-        },
-      );
-      await Future.delayed(Duration(milliseconds: 500));
-      expect(messageCount, equals(10));
-      expect(errorCount, equals(1));
-      expect(eventSource.isClosed, equals(true));
-    });
-    test("subscription closed by server", () async {
-      int messageCount = 0;
-      int errorCount = 0;
-      final eventSource = client.miscTests.streamTenEventsThenEnd(
-        onData: (data, connection) {
-          messageCount++;
-        },
-        onError: (_, __) {
-          errorCount++;
-        },
-      );
-      await Future.delayed(Duration(milliseconds: 500));
-      expect(messageCount, equals(10));
-      expect(errorCount, equals(0));
-      expect(eventSource.isClosed, equals(true));
-    });
-    test("subscriptions auto-reconnect", () async {
-      int connectionCount = 0;
-      int messageCount = 0;
-      int errorCount = 0;
-      final eventSource = client.miscTests.streamAutoReconnect(
-        AutoReconnectParams(messageCount: 10),
-        onOpen: (_, __) {
-          connectionCount++;
-        },
-        onData: (data, _) {
-          messageCount++;
-          expect(data.count > 0, equals(true));
-        },
-        onError: (_, __) {
-          errorCount++;
-        },
-      );
-      await Future.delayed(Duration(milliseconds: 500));
-      eventSource.close();
-      expect(connectionCount > 0, equals(true));
-      expect(messageCount > 10, equals(true));
-      expect(errorCount, equals(0));
-    });
-    test("can stream large objects", () async {
-      var openCount = 0;
-      var msgCount = 0;
-      var errorCount = 0;
-      final eventSource = client.miscTests.streamLargeObjects(
-        onOpen: (_, __) {
-          openCount++;
-        },
-        onData: (data, _) {
-          msgCount++;
-        },
-        onError: (_, __) {
-          errorCount++;
-        },
-      );
-      await Future.delayed(Duration(milliseconds: 500));
-      eventSource.close();
-      expect(openCount, equals(1));
-      expect(msgCount > 2, equals(true));
-      expect(errorCount, equals(0));
+      },
+    );
+    await Future.delayed(Duration(milliseconds: 500));
+    eventSource.close();
+    expect(messageCount > 0, equals(true));
+    expect(eventSource.isClosed, equals(true));
+  });
+  test("[SSE] supports converting server sent events to a Dart 'Stream'",
+      () async {
+    int messageCount = 0;
+    final eventSource =
+        client.tests.streamMessages(ChatMessageParams(channelId: "12345"));
+    final listener = eventSource.toStream().listen((message) {
+      messageCount++;
+      switch (message) {
+        case ChatMessageText():
+          expect(message.channelId, equals('12345'));
+          expect(message.messageType, equals("TEXT"));
+          break;
+        case ChatMessageImage():
+          expect(message.channelId, equals("12345"));
+          expect(message.messageType, equals("IMAGE"));
+          break;
+        case ChatMessageUrl():
+          expect(message.channelId, equals("12345"));
+          expect(message.messageType, equals("URL"));
+          break;
+      }
     });
+    await Future.delayed(Duration(milliseconds: 500));
+    await listener.cancel();
+    expect(messageCount >= 1, equals(true));
+    expect(eventSource.isClosed, equals(true));
+  });
+  test("[SSE] parses both 'message' and 'error' events", () async {
+    int messageCount = 0;
+    int errorCount = 0;
+    final eventSource = client.tests.streamTenEventsThenError(
+      onData: (data, connection) {
+        messageCount++;
+        expect(data.messageType.isNotEmpty, equals(true));
+      },
+      onError: (error, connection) {
+        errorCount++;
+        connection.close();
+      },
+    );
+    await Future.delayed(Duration(milliseconds: 500));
+    expect(messageCount, equals(10));
+    expect(errorCount, equals(1));
+    expect(eventSource.isClosed, equals(true));
+  });
+  test("[SSE] closes connection when receiving 'done' event", () async {
+    int messageCount = 0;
+    int errorCount = 0;
+    final eventSource = client.tests.streamTenEventsThenEnd(
+      onData: (data, connection) {
+        messageCount++;
+      },
+      onError: (_, __) {
+        errorCount++;
+      },
+    );
+    await Future.delayed(Duration(milliseconds: 500));
+    expect(messageCount, equals(10));
+    expect(errorCount, equals(0));
+    expect(eventSource.isClosed, equals(true));
+  });
+  test("[SSE] auto-reconnects when connection is closed by server", () async {
+    int connectionCount = 0;
+    int messageCount = 0;
+    int errorCount = 0;
+    final eventSource = client.tests.streamAutoReconnect(
+      AutoReconnectParams(messageCount: 10),
+      onOpen: (_, __) {
+        connectionCount++;
+      },
+      onData: (data, _) {
+        messageCount++;
+        expect(data.count > 0, equals(true));
+      },
+      onError: (_, __) {
+        errorCount++;
+      },
+    );
+    await Future.delayed(Duration(milliseconds: 500));
+    eventSource.close();
+    expect(connectionCount > 0, equals(true));
+    expect(messageCount > 10, equals(true));
+    expect(errorCount, equals(0));
+  });
+  test("[SSE] can handle receiving large messages", () async {
+    var openCount = 0;
+    var msgCount = 0;
+    var errorCount = 0;
+    final eventSource = client.tests.streamLargeObjects(
+      onOpen: (_, __) {
+        openCount++;
+      },
+      onData: (data, _) {
+        msgCount++;
+      },
+      onError: (_, __) {
+        errorCount++;
+      },
+    );
+    await Future.delayed(Duration(milliseconds: 500));
+    eventSource.close();
+    expect(openCount, equals(1));
+    expect(msgCount > 2, equals(true));
+    expect(errorCount, equals(0));
+  });
 
-    test("stream error handling", () async {
-      var openCount = 0;
-      var errorCount = 0;
-      var connectionErrorCount = 0;
-      var msgCount = 0;
-      final List<ArriRequestError> errors = [];
-      final statusCode = 555;
-      final statusMessage = "test_message";
-      final eventSource = client.miscTests.streamConnectionErrorTest(
-        StreamConnectionErrorTestParams(
-          statusCode: statusCode,
-          statusMessage: statusMessage,
-        ),
-        onOpen: (_, __) {
-          openCount++;
-        },
-        onData: (data, _) {
-          msgCount++;
-        },
-        onError: (err, _) {
-          errorCount++;
-        },
-        onConnectionError: (err, _) {
-          connectionErrorCount++;
-          errors.add(err);
-        },
-      );
-      await Future.delayed(Duration(milliseconds: 500));
-      eventSource.close();
-      expect(openCount > 0, equals(true));
-      expect(errorCount, equals(0));
-      expect(msgCount, equals(0));
-      expect(connectionErrorCount > 0, equals(true));
-      expect(
-        errors.every(
-          (element) =>
-              element.statusCode == statusCode &&
-              element.statusMessage == statusMessage,
-        ),
-        equals(true),
-      );
-    });
+  test("[SSE] auto-retry when initial connection fails", () async {
+    var openCount = 0;
+    var errorCount = 0;
+    var connectionErrorCount = 0;
+    var msgCount = 0;
+    final List<ArriRequestError> errors = [];
+    final statusCode = 555;
+    final statusMessage = "test_message";
+    final eventSource = client.tests.streamConnectionErrorTest(
+      StreamConnectionErrorTestParams(
+        statusCode: statusCode,
+        statusMessage: statusMessage,
+      ),
+      onOpen: (_, __) {
+        openCount++;
+      },
+      onData: (data, _) {
+        msgCount++;
+      },
+      onError: (err, _) {
+        errorCount++;
+      },
+      onConnectionError: (err, _) {
+        connectionErrorCount++;
+        errors.add(err);
+      },
+    );
+    await Future.delayed(Duration(milliseconds: 500));
+    eventSource.close();
+    expect(openCount > 0, equals(true));
+    expect(errorCount, equals(0));
+    expect(msgCount, equals(0));
+    expect(connectionErrorCount > 0, equals(true));
+    expect(
+      errors.every(
+        (element) =>
+            element.statusCode == statusCode &&
+            element.statusMessage == statusMessage,
+      ),
+      equals(true),
+    );
   });
 }
diff --git a/tests/clients/client-typescript/testClient.rpc.ts b/tests/clients/client-typescript/testClient.rpc.ts
index 3f85a208..50437f7a 100644
--- a/tests/clients/client-typescript/testClient.rpc.ts
+++ b/tests/clients/client-typescript/testClient.rpc.ts
@@ -11,20 +11,18 @@ interface TestClientOptions {
 export class TestClient {
     private readonly baseUrl: string;
     private readonly headers: Record<string, string>;
-    authors: TestClientAuthorsService;
+    tests: TestClientTestsService;
     adapters: TestClientAdaptersService;
-    miscTests: TestClientMiscTestsService;
 
     constructor(options: TestClientOptions = {}) {
         this.baseUrl = options.baseUrl ?? "";
         this.headers = { "client-version": "10", ...options.headers };
-        this.authors = new TestClientAuthorsService(options);
+        this.tests = new TestClientTestsService(options);
         this.adapters = new TestClientAdaptersService(options);
-        this.miscTests = new TestClientMiscTestsService(options);
     }
 }
 
-export class TestClientAuthorsService {
+export class TestClientTestsService {
     private readonly baseUrl: string;
     private readonly headers: Record<string, string>;
 
@@ -32,53 +30,53 @@ export class TestClientAuthorsService {
         this.baseUrl = options.baseUrl ?? "";
         this.headers = { "client-version": "10", ...options.headers };
     }
-    updateAuthor(params: AuthorsUpdateAuthorParams) {
-        return arriRequest<Author, AuthorsUpdateAuthorParams>({
-            url: `${this.baseUrl}/rpcs/authors/update-author`,
+    emptyParamsGetRequest() {
+        return arriRequest<DefaultPayload, undefined>({
+            url: `${this.baseUrl}/rpcs/tests/empty-params-get-request`,
+            method: "get",
+            headers: this.headers,
+            params: undefined,
+            parser: $$DefaultPayload.parse,
+            serializer: (_) => {},
+        });
+    }
+    emptyParamsPostRequest() {
+        return arriRequest<DefaultPayload, undefined>({
+            url: `${this.baseUrl}/rpcs/tests/empty-params-post-request`,
             method: "post",
             headers: this.headers,
-            params,
-            parser: $$Author.parse,
-            serializer: $$AuthorsUpdateAuthorParams.serialize,
+            params: undefined,
+            parser: $$DefaultPayload.parse,
+            serializer: (_) => {},
         });
     }
-}
-
-export class TestClientAdaptersService {
-    private readonly baseUrl: string;
-    private readonly headers: Record<string, string>;
-
-    constructor(options: TestClientOptions = {}) {
-        this.baseUrl = options.baseUrl ?? "";
-        this.headers = { "client-version": "10", ...options.headers };
+    emptyResponseGetRequest(params: DefaultPayload) {
+        return arriRequest<undefined, DefaultPayload>({
+            url: `${this.baseUrl}/rpcs/tests/empty-response-get-request`,
+            method: "get",
+            headers: this.headers,
+            params,
+            parser: (_) => {},
+            serializer: $$DefaultPayload.serialize,
+        });
     }
-    typebox(params: TypeBoxObject) {
-        return arriRequest<TypeBoxObject, TypeBoxObject>({
-            url: `${this.baseUrl}/rpcs/adapters/typebox`,
+    emptyResponsePostRequest(params: DefaultPayload) {
+        return arriRequest<undefined, DefaultPayload>({
+            url: `${this.baseUrl}/rpcs/tests/empty-response-post-request`,
             method: "post",
             headers: this.headers,
             params,
-            parser: $$TypeBoxObject.parse,
-            serializer: $$TypeBoxObject.serialize,
+            parser: (_) => {},
+            serializer: $$DefaultPayload.serialize,
         });
     }
-}
-
-export class TestClientMiscTestsService {
-    private readonly baseUrl: string;
-    private readonly headers: Record<string, string>;
-
-    constructor(options: TestClientOptions = {}) {
-        this.baseUrl = options.baseUrl ?? "";
-        this.headers = { "client-version": "10", ...options.headers };
-    }
     /**
-     * This RPC is no longer supported
+     * If the target language supports it. Generated code should mark this procedure as deprecated.
      * @deprecated
      */
     deprecatedRpc(params: DeprecatedRpcParams) {
         return arriRequest<undefined, DeprecatedRpcParams>({
-            url: `${this.baseUrl}/rpcs/misc-tests/deprecated-rpc`,
+            url: `${this.baseUrl}/rpcs/tests/deprecated-rpc`,
             method: "post",
             headers: this.headers,
             params,
@@ -88,7 +86,7 @@ export class TestClientMiscTestsService {
     }
     sendObject(params: ObjectWithEveryType) {
         return arriRequest<ObjectWithEveryType, ObjectWithEveryType>({
-            url: `${this.baseUrl}/rpcs/misc-tests/send-object`,
+            url: `${this.baseUrl}/rpcs/tests/send-object`,
             method: "post",
             headers: this.headers,
             params,
@@ -101,7 +99,7 @@ export class TestClientMiscTestsService {
             ObjectWithEveryNullableType,
             ObjectWithEveryNullableType
         >({
-            url: `${this.baseUrl}/rpcs/misc-tests/send-object-with-nullable-fields`,
+            url: `${this.baseUrl}/rpcs/tests/send-object-with-nullable-fields`,
             method: "post",
             headers: this.headers,
             params,
@@ -114,7 +112,7 @@ export class TestClientMiscTestsService {
             ObjectWithEveryOptionalType,
             ObjectWithEveryOptionalType
         >({
-            url: `${this.baseUrl}/rpcs/misc-tests/send-partial-object`,
+            url: `${this.baseUrl}/rpcs/tests/send-partial-object`,
             method: "post",
             headers: this.headers,
             params,
@@ -124,7 +122,7 @@ export class TestClientMiscTestsService {
     }
     sendRecursiveObject(params: RecursiveObject) {
         return arriRequest<RecursiveObject, RecursiveObject>({
-            url: `${this.baseUrl}/rpcs/misc-tests/send-recursive-object`,
+            url: `${this.baseUrl}/rpcs/tests/send-recursive-object`,
             method: "post",
             headers: this.headers,
             params,
@@ -134,7 +132,7 @@ export class TestClientMiscTestsService {
     }
     sendRecursiveUnion(params: RecursiveUnion) {
         return arriRequest<RecursiveUnion, RecursiveUnion>({
-            url: `${this.baseUrl}/rpcs/misc-tests/send-recursive-union`,
+            url: `${this.baseUrl}/rpcs/tests/send-recursive-union`,
             method: "post",
             headers: this.headers,
             params,
@@ -148,7 +146,7 @@ export class TestClientMiscTestsService {
     ) {
         return arriSseRequest<AutoReconnectResponse, AutoReconnectParams>(
             {
-                url: `${this.baseUrl}/rpcs/misc-tests/stream-auto-reconnect`,
+                url: `${this.baseUrl}/rpcs/tests/stream-auto-reconnect`,
                 method: "get",
                 headers: this.headers,
                 params,
@@ -158,6 +156,9 @@ export class TestClientMiscTestsService {
             options,
         );
     }
+    /**
+     * This route will always return an error. The client should automatically retry with exponential backoff.
+     */
     streamConnectionErrorTest(
         params: StreamConnectionErrorTestParams,
         options: SseOptions<StreamConnectionErrorTestResponse>,
@@ -167,7 +168,7 @@ export class TestClientMiscTestsService {
             StreamConnectionErrorTestParams
         >(
             {
-                url: `${this.baseUrl}/rpcs/misc-tests/stream-connection-error-test`,
+                url: `${this.baseUrl}/rpcs/tests/stream-connection-error-test`,
                 method: "get",
                 headers: this.headers,
                 params,
@@ -177,10 +178,13 @@ export class TestClientMiscTestsService {
             options,
         );
     }
+    /**
+     * Test to ensure that the client can handle receiving streams of large objects. When objects are large messages will sometimes get sent in chunks. Meaning you have to handle receiving a partial message
+     */
     streamLargeObjects(options: SseOptions<StreamLargeObjectsResponse>) {
         return arriSseRequest<StreamLargeObjectsResponse, undefined>(
             {
-                url: `${this.baseUrl}/rpcs/misc-tests/stream-large-objects`,
+                url: `${this.baseUrl}/rpcs/tests/stream-large-objects`,
                 method: "get",
                 headers: this.headers,
                 params: undefined,
@@ -196,7 +200,7 @@ export class TestClientMiscTestsService {
     ) {
         return arriSseRequest<ChatMessage, ChatMessageParams>(
             {
-                url: `${this.baseUrl}/rpcs/misc-tests/stream-messages`,
+                url: `${this.baseUrl}/rpcs/tests/stream-messages`,
                 method: "get",
                 headers: this.headers,
                 params,
@@ -206,10 +210,13 @@ export class TestClientMiscTestsService {
             options,
         );
     }
+    /**
+     * When the client receives the 'done' event, it should close the connection and NOT reconnect
+     */
     streamTenEventsThenEnd(options: SseOptions<ChatMessage>) {
         return arriSseRequest<ChatMessage, undefined>(
             {
-                url: `${this.baseUrl}/rpcs/misc-tests/stream-ten-events-then-end`,
+                url: `${this.baseUrl}/rpcs/tests/stream-ten-events-then-end`,
                 method: "get",
                 headers: this.headers,
                 params: undefined,
@@ -222,7 +229,7 @@ export class TestClientMiscTestsService {
     streamTenEventsThenError(options: SseOptions<ChatMessage>) {
         return arriSseRequest<ChatMessage, undefined>(
             {
-                url: `${this.baseUrl}/rpcs/misc-tests/stream-ten-events-then-error`,
+                url: `${this.baseUrl}/rpcs/tests/stream-ten-events-then-error`,
                 method: "post",
                 headers: this.headers,
                 params: undefined,
@@ -234,6 +241,26 @@ export class TestClientMiscTestsService {
     }
 }
 
+export class TestClientAdaptersService {
+    private readonly baseUrl: string;
+    private readonly headers: Record<string, string>;
+
+    constructor(options: TestClientOptions = {}) {
+        this.baseUrl = options.baseUrl ?? "";
+        this.headers = { "client-version": "10", ...options.headers };
+    }
+    typebox(params: TypeBoxObject) {
+        return arriRequest<TypeBoxObject, TypeBoxObject>({
+            url: `${this.baseUrl}/rpcs/adapters/typebox`,
+            method: "post",
+            headers: this.headers,
+            params,
+            parser: $$TypeBoxObject.parse,
+            serializer: $$TypeBoxObject.serialize,
+        });
+    }
+}
+
 export interface ManuallyAddedModel {
     hello: string;
 }
@@ -330,12 +357,11 @@ const $$ManuallyAddedModel = {
     },
 };
 
-export interface AuthorsUpdateAuthorParams {
-    authorId: string;
-    data: UpdateAuthorData;
+export interface DefaultPayload {
+    message: string;
 }
-const $$AuthorsUpdateAuthorParams = {
-    parse(input: Record<any, any>): AuthorsUpdateAuthorParams {
+const $$DefaultPayload = {
+    parse(input: Record<any, any>): DefaultPayload {
         function $fallback(instancePath, schemaPath) {
             throw new Error(
                 `Error parsing input. InstancePath: "${instancePath}". SchemaPath: "${schemaPath}"`,
@@ -347,87 +373,15 @@ const $$AuthorsUpdateAuthorParams = {
             let result = {};
             if (typeof json === "object" && json !== null) {
                 const __D1 = {};
-                if (typeof json.authorId === "string") {
-                    __D1.authorId = json.authorId;
+                if (typeof json.message === "string") {
+                    __D1.message = json.message;
                 } else {
                     $fallback(
-                        "/authorId",
-                        "/properties/authorId/type",
-                        "Expected string at /authorId",
+                        "/message",
+                        "/properties/message/type",
+                        "Expected string at /message",
                     );
                 }
-                if (typeof json.data === "object" && json.data !== null) {
-                    const __D2 = {};
-                    if (typeof json.data.name === "undefined") {
-                        // ignore undefined
-                    } else {
-                        if (typeof json.data.name === "string") {
-                            __D2.name = json.data.name;
-                        } else {
-                            $fallback(
-                                "/data/name",
-                                "/properties/data/optionalProperties/name/type",
-                                "Expected string at /data/name",
-                            );
-                        }
-                    }
-                    if (typeof json.data.bio === "undefined") {
-                        // ignore undefined
-                    } else {
-                        if (json.data.bio === null) {
-                            __D2.bio = json.data.bio;
-                        } else {
-                            if (typeof json.data.bio === "string") {
-                                __D2.bio = json.data.bio;
-                            } else {
-                                $fallback(
-                                    "/data/bio",
-                                    "/properties/data/optionalProperties/bio/type",
-                                    "Expected string at /data/bio",
-                                );
-                            }
-                        }
-                    }
-                    if (typeof json.data.createdAt === "undefined") {
-                        // ignore undefined
-                    } else {
-                        if (
-                            typeof json.data.createdAt === "object" &&
-                            json.data.createdAt instanceof Date
-                        ) {
-                            __D2.createdAt = json.data.createdAt;
-                        } else if (typeof json.data.createdAt === "string") {
-                            __D2.createdAt = new Date(json.data.createdAt);
-                        } else {
-                            $fallback(
-                                "/data/createdAt",
-                                "/properties/data/optionalProperties/createdAt",
-                                "Expected instanceof Date or ISO Date string at /data/createdAt",
-                            );
-                        }
-                    }
-                    if (typeof json.data.updatedAt === "undefined") {
-                        // ignore undefined
-                    } else {
-                        if (
-                            typeof json.data.updatedAt === "object" &&
-                            json.data.updatedAt instanceof Date
-                        ) {
-                            __D2.updatedAt = json.data.updatedAt;
-                        } else if (typeof json.data.updatedAt === "string") {
-                            __D2.updatedAt = new Date(json.data.updatedAt);
-                        } else {
-                            $fallback(
-                                "/data/updatedAt",
-                                "/properties/data/optionalProperties/updatedAt",
-                                "Expected instanceof Date or ISO Date string at /data/updatedAt",
-                            );
-                        }
-                    }
-                    __D1.data = __D2;
-                } else {
-                    $fallback("/data", "/properties/data", "Expected object");
-                }
                 result = __D1;
             } else {
                 $fallback("", "", "Expected object");
@@ -437,94 +391,22 @@ const $$AuthorsUpdateAuthorParams = {
         let result = {};
         if (typeof input === "object" && input !== null) {
             const __D1 = {};
-            if (typeof input.authorId === "string") {
-                __D1.authorId = input.authorId;
+            if (typeof input.message === "string") {
+                __D1.message = input.message;
             } else {
                 $fallback(
-                    "/authorId",
-                    "/properties/authorId/type",
-                    "Expected string at /authorId",
+                    "/message",
+                    "/properties/message/type",
+                    "Expected string at /message",
                 );
             }
-            if (typeof input.data === "object" && input.data !== null) {
-                const __D2 = {};
-                if (typeof input.data.name === "undefined") {
-                    // ignore undefined
-                } else {
-                    if (typeof input.data.name === "string") {
-                        __D2.name = input.data.name;
-                    } else {
-                        $fallback(
-                            "/data/name",
-                            "/properties/data/optionalProperties/name/type",
-                            "Expected string at /data/name",
-                        );
-                    }
-                }
-                if (typeof input.data.bio === "undefined") {
-                    // ignore undefined
-                } else {
-                    if (input.data.bio === null) {
-                        __D2.bio = input.data.bio;
-                    } else {
-                        if (typeof input.data.bio === "string") {
-                            __D2.bio = input.data.bio;
-                        } else {
-                            $fallback(
-                                "/data/bio",
-                                "/properties/data/optionalProperties/bio/type",
-                                "Expected string at /data/bio",
-                            );
-                        }
-                    }
-                }
-                if (typeof input.data.createdAt === "undefined") {
-                    // ignore undefined
-                } else {
-                    if (
-                        typeof input.data.createdAt === "object" &&
-                        input.data.createdAt instanceof Date
-                    ) {
-                        __D2.createdAt = input.data.createdAt;
-                    } else if (typeof input.data.createdAt === "string") {
-                        __D2.createdAt = new Date(input.data.createdAt);
-                    } else {
-                        $fallback(
-                            "/data/createdAt",
-                            "/properties/data/optionalProperties/createdAt",
-                            "Expected instanceof Date or ISO Date string at /data/createdAt",
-                        );
-                    }
-                }
-                if (typeof input.data.updatedAt === "undefined") {
-                    // ignore undefined
-                } else {
-                    if (
-                        typeof input.data.updatedAt === "object" &&
-                        input.data.updatedAt instanceof Date
-                    ) {
-                        __D2.updatedAt = input.data.updatedAt;
-                    } else if (typeof input.data.updatedAt === "string") {
-                        __D2.updatedAt = new Date(input.data.updatedAt);
-                    } else {
-                        $fallback(
-                            "/data/updatedAt",
-                            "/properties/data/optionalProperties/updatedAt",
-                            "Expected instanceof Date or ISO Date string at /data/updatedAt",
-                        );
-                    }
-                }
-                __D1.data = __D2;
-            } else {
-                $fallback("/data", "/properties/data", "Expected object");
-            }
             result = __D1;
         } else {
             $fallback("", "", "Expected object");
         }
         return result;
     },
-    serialize(input: AuthorsUpdateAuthorParams): string {
+    serialize(input: DefaultPayload): string {
         let json = "";
 
         const STR_ESCAPE =
@@ -532,516 +414,43 @@ const $$AuthorsUpdateAuthorParams = {
 
         json += "";
         json += "{";
-        json += `"authorId":`;
-        if (input.authorId.length < 42) {
+        json += `"message":`;
+        if (input.message.length < 42) {
             let __result__ = "";
             let __last__ = -1;
             let __point__ = 255;
             let __finished__ = false;
-            for (let i = 0; i < input.authorId.length; i++) {
-                __point__ = input.authorId.charCodeAt(i);
+            for (let i = 0; i < input.message.length; i++) {
+                __point__ = input.message.charCodeAt(i);
                 if (
                     __point__ < 32 ||
                     (__point__ >= 0xd800 && __point__ <= 0xdfff)
                 ) {
-                    json += JSON.stringify(input.authorId);
+                    json += JSON.stringify(input.message);
                     __finished__ = true;
                     break;
                 }
                 if (__point__ === 0x22 || __point__ === 0x5c) {
                     __last__ === -1 && (__last__ = 0);
-                    __result__ += input.authorId.slice(__last__, i) + "\\";
+                    __result__ += input.message.slice(__last__, i) + "\\";
                     __last__ = i;
                 }
             }
             if (!__finished__) {
                 if (__last__ === -1) {
-                    json += `"${input.authorId}"`;
+                    json += `"${input.message}"`;
                 } else {
-                    json += `"${__result__}${input.authorId.slice(__last__)}"`;
+                    json += `"${__result__}${input.message.slice(__last__)}"`;
                 }
             }
         } else if (
-            input.authorId.length < 5000 &&
-            !STR_ESCAPE.test(input.authorId)
+            input.message.length < 5000 &&
+            !STR_ESCAPE.test(input.message)
         ) {
-            json += `"${input.authorId}"`;
-        } else {
-            json += JSON.stringify(input.authorId);
-        }
-
-        json += ',"data":';
-        json += "{";
-        let dataHasFields = false;
-        if (typeof input.data.name !== "undefined") {
-            if (dataHasFields) {
-                json += `,"name":`;
-                if (input.data.name.length < 42) {
-                    let __result__ = "";
-                    let __last__ = -1;
-                    let __point__ = 255;
-                    let __finished__ = false;
-                    for (let i = 0; i < input.data.name.length; i++) {
-                        __point__ = input.data.name.charCodeAt(i);
-                        if (
-                            __point__ < 32 ||
-                            (__point__ >= 0xd800 && __point__ <= 0xdfff)
-                        ) {
-                            json += JSON.stringify(input.data.name);
-                            __finished__ = true;
-                            break;
-                        }
-                        if (__point__ === 0x22 || __point__ === 0x5c) {
-                            __last__ === -1 && (__last__ = 0);
-                            __result__ +=
-                                input.data.name.slice(__last__, i) + "\\";
-                            __last__ = i;
-                        }
-                    }
-                    if (!__finished__) {
-                        if (__last__ === -1) {
-                            json += `"${input.data.name}"`;
-                        } else {
-                            json += `"${__result__}${input.data.name.slice(__last__)}"`;
-                        }
-                    }
-                } else if (
-                    input.data.name.length < 5000 &&
-                    !STR_ESCAPE.test(input.data.name)
-                ) {
-                    json += `"${input.data.name}"`;
-                } else {
-                    json += JSON.stringify(input.data.name);
-                }
-            } else {
-                json += `"name":`;
-                if (input.data.name.length < 42) {
-                    let __result__ = "";
-                    let __last__ = -1;
-                    let __point__ = 255;
-                    let __finished__ = false;
-                    for (let i = 0; i < input.data.name.length; i++) {
-                        __point__ = input.data.name.charCodeAt(i);
-                        if (
-                            __point__ < 32 ||
-                            (__point__ >= 0xd800 && __point__ <= 0xdfff)
-                        ) {
-                            json += JSON.stringify(input.data.name);
-                            __finished__ = true;
-                            break;
-                        }
-                        if (__point__ === 0x22 || __point__ === 0x5c) {
-                            __last__ === -1 && (__last__ = 0);
-                            __result__ +=
-                                input.data.name.slice(__last__, i) + "\\";
-                            __last__ = i;
-                        }
-                    }
-                    if (!__finished__) {
-                        if (__last__ === -1) {
-                            json += `"${input.data.name}"`;
-                        } else {
-                            json += `"${__result__}${input.data.name.slice(__last__)}"`;
-                        }
-                    }
-                } else if (
-                    input.data.name.length < 5000 &&
-                    !STR_ESCAPE.test(input.data.name)
-                ) {
-                    json += `"${input.data.name}"`;
-                } else {
-                    json += JSON.stringify(input.data.name);
-                }
-                dataHasFields = true;
-            }
-        }
-        if (typeof input.data.bio !== "undefined") {
-            if (dataHasFields) {
-                if (typeof input.data.bio === "string") {
-                    json += `,"bio":`;
-                    if (input.data.bio.length < 42) {
-                        let __result__ = "";
-                        let __last__ = -1;
-                        let __point__ = 255;
-                        let __finished__ = false;
-                        for (let i = 0; i < input.data.bio.length; i++) {
-                            __point__ = input.data.bio.charCodeAt(i);
-                            if (
-                                __point__ < 32 ||
-                                (__point__ >= 0xd800 && __point__ <= 0xdfff)
-                            ) {
-                                json += JSON.stringify(input.data.bio);
-                                __finished__ = true;
-                                break;
-                            }
-                            if (__point__ === 0x22 || __point__ === 0x5c) {
-                                __last__ === -1 && (__last__ = 0);
-                                __result__ +=
-                                    input.data.bio.slice(__last__, i) + "\\";
-                                __last__ = i;
-                            }
-                        }
-                        if (!__finished__) {
-                            if (__last__ === -1) {
-                                json += `"${input.data.bio}"`;
-                            } else {
-                                json += `"${__result__}${input.data.bio.slice(__last__)}"`;
-                            }
-                        }
-                    } else if (
-                        input.data.bio.length < 5000 &&
-                        !STR_ESCAPE.test(input.data.bio)
-                    ) {
-                        json += `"${input.data.bio}"`;
-                    } else {
-                        json += JSON.stringify(input.data.bio);
-                    }
-                } else {
-                    json += ',"bio":null';
-                }
-            } else {
-                if (typeof input.data.bio === "string") {
-                    json += `"bio":`;
-                    if (input.data.bio.length < 42) {
-                        let __result__ = "";
-                        let __last__ = -1;
-                        let __point__ = 255;
-                        let __finished__ = false;
-                        for (let i = 0; i < input.data.bio.length; i++) {
-                            __point__ = input.data.bio.charCodeAt(i);
-                            if (
-                                __point__ < 32 ||
-                                (__point__ >= 0xd800 && __point__ <= 0xdfff)
-                            ) {
-                                json += JSON.stringify(input.data.bio);
-                                __finished__ = true;
-                                break;
-                            }
-                            if (__point__ === 0x22 || __point__ === 0x5c) {
-                                __last__ === -1 && (__last__ = 0);
-                                __result__ +=
-                                    input.data.bio.slice(__last__, i) + "\\";
-                                __last__ = i;
-                            }
-                        }
-                        if (!__finished__) {
-                            if (__last__ === -1) {
-                                json += `"${input.data.bio}"`;
-                            } else {
-                                json += `"${__result__}${input.data.bio.slice(__last__)}"`;
-                            }
-                        }
-                    } else if (
-                        input.data.bio.length < 5000 &&
-                        !STR_ESCAPE.test(input.data.bio)
-                    ) {
-                        json += `"${input.data.bio}"`;
-                    } else {
-                        json += JSON.stringify(input.data.bio);
-                    }
-                } else {
-                    json += '"bio":null';
-                }
-                dataHasFields = true;
-            }
-        }
-        if (typeof input.data.createdAt !== "undefined") {
-            if (dataHasFields) {
-                json += `,"createdAt":"${input.data.createdAt.toISOString()}"`;
-            } else {
-                json += `"createdAt":"${input.data.createdAt.toISOString()}"`;
-                dataHasFields = true;
-            }
-        }
-        if (typeof input.data.updatedAt !== "undefined") {
-            if (dataHasFields) {
-                json += `,"updatedAt":"${input.data.updatedAt.toISOString()}"`;
-            } else {
-                json += `"updatedAt":"${input.data.updatedAt.toISOString()}"`;
-                dataHasFields = true;
-            }
-        }
-        json += "}";
-        json += "}";
-        return json;
-    },
-};
-export interface UpdateAuthorData {
-    name?: string;
-    bio?: string | null;
-    createdAt?: Date;
-    updatedAt?: Date;
-}
-
-export interface Author {
-    id: string;
-    name: string;
-    bio: string | null;
-    createdAt: Date;
-    updatedAt: Date;
-}
-const $$Author = {
-    parse(input: Record<any, any>): Author {
-        function $fallback(instancePath, schemaPath) {
-            throw new Error(
-                `Error parsing input. InstancePath: "${instancePath}". SchemaPath: "${schemaPath}"`,
-            );
-        }
-
-        if (typeof input === "string") {
-            const json = JSON.parse(input);
-            let result = {};
-            if (typeof json === "object" && json !== null) {
-                const __D1 = {};
-                if (typeof json.id === "string") {
-                    __D1.id = json.id;
-                } else {
-                    $fallback(
-                        "/id",
-                        "/properties/id/type",
-                        "Expected string at /id",
-                    );
-                }
-                if (typeof json.name === "string") {
-                    __D1.name = json.name;
-                } else {
-                    $fallback(
-                        "/name",
-                        "/properties/name/type",
-                        "Expected string at /name",
-                    );
-                }
-                if (json.bio === null) {
-                    __D1.bio = json.bio;
-                } else {
-                    if (typeof json.bio === "string") {
-                        __D1.bio = json.bio;
-                    } else {
-                        $fallback(
-                            "/bio",
-                            "/properties/bio/type",
-                            "Expected string at /bio",
-                        );
-                    }
-                }
-                if (
-                    typeof json.createdAt === "object" &&
-                    json.createdAt instanceof Date
-                ) {
-                    __D1.createdAt = json.createdAt;
-                } else if (typeof json.createdAt === "string") {
-                    __D1.createdAt = new Date(json.createdAt);
-                } else {
-                    $fallback(
-                        "/createdAt",
-                        "/properties/createdAt",
-                        "Expected instanceof Date or ISO Date string at /createdAt",
-                    );
-                }
-                if (
-                    typeof json.updatedAt === "object" &&
-                    json.updatedAt instanceof Date
-                ) {
-                    __D1.updatedAt = json.updatedAt;
-                } else if (typeof json.updatedAt === "string") {
-                    __D1.updatedAt = new Date(json.updatedAt);
-                } else {
-                    $fallback(
-                        "/updatedAt",
-                        "/properties/updatedAt",
-                        "Expected instanceof Date or ISO Date string at /updatedAt",
-                    );
-                }
-                result = __D1;
-            } else {
-                $fallback("", "", "Expected object");
-            }
-            return result;
-        }
-        let result = {};
-        if (typeof input === "object" && input !== null) {
-            const __D1 = {};
-            if (typeof input.id === "string") {
-                __D1.id = input.id;
-            } else {
-                $fallback(
-                    "/id",
-                    "/properties/id/type",
-                    "Expected string at /id",
-                );
-            }
-            if (typeof input.name === "string") {
-                __D1.name = input.name;
-            } else {
-                $fallback(
-                    "/name",
-                    "/properties/name/type",
-                    "Expected string at /name",
-                );
-            }
-            if (input.bio === null) {
-                __D1.bio = input.bio;
-            } else {
-                if (typeof input.bio === "string") {
-                    __D1.bio = input.bio;
-                } else {
-                    $fallback(
-                        "/bio",
-                        "/properties/bio/type",
-                        "Expected string at /bio",
-                    );
-                }
-            }
-            if (
-                typeof input.createdAt === "object" &&
-                input.createdAt instanceof Date
-            ) {
-                __D1.createdAt = input.createdAt;
-            } else if (typeof input.createdAt === "string") {
-                __D1.createdAt = new Date(input.createdAt);
-            } else {
-                $fallback(
-                    "/createdAt",
-                    "/properties/createdAt",
-                    "Expected instanceof Date or ISO Date string at /createdAt",
-                );
-            }
-            if (
-                typeof input.updatedAt === "object" &&
-                input.updatedAt instanceof Date
-            ) {
-                __D1.updatedAt = input.updatedAt;
-            } else if (typeof input.updatedAt === "string") {
-                __D1.updatedAt = new Date(input.updatedAt);
-            } else {
-                $fallback(
-                    "/updatedAt",
-                    "/properties/updatedAt",
-                    "Expected instanceof Date or ISO Date string at /updatedAt",
-                );
-            }
-            result = __D1;
-        } else {
-            $fallback("", "", "Expected object");
-        }
-        return result;
-    },
-    serialize(input: Author): string {
-        let json = "";
-
-        const STR_ESCAPE =
-            /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/;
-
-        json += "";
-        json += "{";
-        json += `"id":`;
-        if (input.id.length < 42) {
-            let __result__ = "";
-            let __last__ = -1;
-            let __point__ = 255;
-            let __finished__ = false;
-            for (let i = 0; i < input.id.length; i++) {
-                __point__ = input.id.charCodeAt(i);
-                if (
-                    __point__ < 32 ||
-                    (__point__ >= 0xd800 && __point__ <= 0xdfff)
-                ) {
-                    json += JSON.stringify(input.id);
-                    __finished__ = true;
-                    break;
-                }
-                if (__point__ === 0x22 || __point__ === 0x5c) {
-                    __last__ === -1 && (__last__ = 0);
-                    __result__ += input.id.slice(__last__, i) + "\\";
-                    __last__ = i;
-                }
-            }
-            if (!__finished__) {
-                if (__last__ === -1) {
-                    json += `"${input.id}"`;
-                } else {
-                    json += `"${__result__}${input.id.slice(__last__)}"`;
-                }
-            }
-        } else if (input.id.length < 5000 && !STR_ESCAPE.test(input.id)) {
-            json += `"${input.id}"`;
-        } else {
-            json += JSON.stringify(input.id);
-        }
-        json += `,"name":`;
-        if (input.name.length < 42) {
-            let __result__ = "";
-            let __last__ = -1;
-            let __point__ = 255;
-            let __finished__ = false;
-            for (let i = 0; i < input.name.length; i++) {
-                __point__ = input.name.charCodeAt(i);
-                if (
-                    __point__ < 32 ||
-                    (__point__ >= 0xd800 && __point__ <= 0xdfff)
-                ) {
-                    json += JSON.stringify(input.name);
-                    __finished__ = true;
-                    break;
-                }
-                if (__point__ === 0x22 || __point__ === 0x5c) {
-                    __last__ === -1 && (__last__ = 0);
-                    __result__ += input.name.slice(__last__, i) + "\\";
-                    __last__ = i;
-                }
-            }
-            if (!__finished__) {
-                if (__last__ === -1) {
-                    json += `"${input.name}"`;
-                } else {
-                    json += `"${__result__}${input.name.slice(__last__)}"`;
-                }
-            }
-        } else if (input.name.length < 5000 && !STR_ESCAPE.test(input.name)) {
-            json += `"${input.name}"`;
-        } else {
-            json += JSON.stringify(input.name);
-        }
-        if (typeof input.bio === "string") {
-            json += `,"bio":`;
-            if (input.bio.length < 42) {
-                let __result__ = "";
-                let __last__ = -1;
-                let __point__ = 255;
-                let __finished__ = false;
-                for (let i = 0; i < input.bio.length; i++) {
-                    __point__ = input.bio.charCodeAt(i);
-                    if (
-                        __point__ < 32 ||
-                        (__point__ >= 0xd800 && __point__ <= 0xdfff)
-                    ) {
-                        json += JSON.stringify(input.bio);
-                        __finished__ = true;
-                        break;
-                    }
-                    if (__point__ === 0x22 || __point__ === 0x5c) {
-                        __last__ === -1 && (__last__ = 0);
-                        __result__ += input.bio.slice(__last__, i) + "\\";
-                        __last__ = i;
-                    }
-                }
-                if (!__finished__) {
-                    if (__last__ === -1) {
-                        json += `"${input.bio}"`;
-                    } else {
-                        json += `"${__result__}${input.bio.slice(__last__)}"`;
-                    }
-                }
-            } else if (input.bio.length < 5000 && !STR_ESCAPE.test(input.bio)) {
-                json += `"${input.bio}"`;
-            } else {
-                json += JSON.stringify(input.bio);
-            }
+            json += `"${input.message}"`;
         } else {
-            json += ',"bio":null';
+            json += JSON.stringify(input.message);
         }
-        json += `,"createdAt":"${input.createdAt.toISOString()}"`;
-        json += `,"updatedAt":"${input.updatedAt.toISOString()}"`;
         json += "}";
         return json;
     },
diff --git a/tests/clients/client-typescript/testClient.test.ts b/tests/clients/client-typescript/testClient.test.ts
index 958a5551..96194279 100644
--- a/tests/clients/client-typescript/testClient.test.ts
+++ b/tests/clients/client-typescript/testClient.test.ts
@@ -9,7 +9,6 @@ import {
     type RecursiveObject,
     type RecursiveUnion,
     type TypeBoxObject,
-    type UpdateAuthorData,
 } from "./testClient.rpc";
 
 const baseUrl = "http://127.0.0.1:2020";
@@ -26,7 +25,7 @@ const unauthenticatedClient = new TestClient({
 });
 
 test("route request", async () => {
-    const result = await ofetch("/routes/authors/12345", {
+    const result = await ofetch("/routes/hello-world", {
         method: "post",
         baseURL: baseUrl,
         headers,
@@ -34,269 +33,218 @@ test("route request", async () => {
             name: "John Doe",
         },
     });
-    expect(result.id).toBe("12345");
-    expect(result.name).toBe("John Doe");
+    expect(result).toBe("hello world");
 });
 
-describe("miscTests", () => {
-    const input: ObjectWithEveryType = {
-        any: {
-            blah: "blah",
-            blah2: "blah2",
-            blah3: true,
-        },
-        boolean: true,
-        string: "hello world",
+test("route request (unauthorized)", async () => {
+    try {
+        await ofetch("/routes/hello-world", {
+            method: "post",
+            baseURL: baseUrl,
+        });
+    } catch (err) {
+        expect(err instanceof ArriRequestErrorInstance);
+        if (err instanceof ArriRequestErrorInstance) {
+            expect(err.statusCode).toBe(401);
+        }
+    }
+});
+
+test("can handle RPCs with no params", async () => {
+    const result = await client.tests.emptyParamsGetRequest();
+    const result2 = await client.tests.emptyParamsPostRequest();
+    expect(typeof result.message).toBe("string");
+    expect(typeof result2.message).toBe("string");
+});
+test("can handle RPCs with no response", async () => {
+    await client.tests.emptyResponseGetRequest({ message: "ok" });
+    await client.tests.emptyResponsePostRequest({ message: "ok" });
+});
+const input: ObjectWithEveryType = {
+    any: {
+        blah: "blah",
+        blah2: "blah2",
+        blah3: true,
+    },
+    boolean: true,
+    string: "hello world",
+    timestamp: new Date(),
+    float32: 0,
+    float64: 0,
+    int8: 0,
+    uint8: 0,
+    int16: 0,
+    uint16: 0,
+    int32: 0,
+    uint32: 0,
+    int64: 0n,
+    uint64: 0n,
+    enumerator: "B",
+    array: [true, false, false],
+    object: {
+        string: "",
+        boolean: false,
         timestamp: new Date(),
-        float32: 0,
-        float64: 0,
-        int8: 0,
-        uint8: 0,
-        int16: 0,
-        uint16: 0,
-        int32: 0,
-        uint32: 0,
-        int64: 0n,
-        uint64: 0n,
-        enumerator: "B",
-        array: [true, false, false],
-        object: {
-            string: "",
-            boolean: false,
-            timestamp: new Date(),
-        },
-        record: {
-            A: true,
-            B: false,
-        },
-        discriminator: {
-            type: "B",
-            title: "Hello World",
-            description: "",
-        },
-        nestedObject: {
+    },
+    record: {
+        A: true,
+        B: false,
+    },
+    discriminator: {
+        type: "B",
+        title: "Hello World",
+        description: "",
+    },
+    nestedObject: {
+        id: "",
+        timestamp: new Date(),
+        data: {
             id: "",
             timestamp: new Date(),
             data: {
                 id: "",
                 timestamp: new Date(),
-                data: {
-                    id: "",
-                    timestamp: new Date(),
-                },
             },
         },
-        nestedArray: [
-            [
-                { id: "", timestamp: new Date() },
-                { id: "", timestamp: new Date() },
-            ],
+    },
+    nestedArray: [
+        [
+            { id: "", timestamp: new Date() },
+            { id: "", timestamp: new Date() },
         ],
-    };
-    test("sendObject()", async () => {
-        const input: ObjectWithEveryType = {
-            any: {
-                blah: "blah",
-                blah2: "blah2",
-                blah3: true,
-            },
-            boolean: true,
-            string: "hello world",
-            timestamp: new Date(),
-            float32: 0,
-            float64: 0,
-            int8: 0,
-            uint8: 0,
-            int16: 0,
-            uint16: 0,
-            int32: 0,
-            uint32: 0,
-            int64: 0n,
-            uint64: 0n,
-            enumerator: "B",
-            array: [true, false, false],
-            object: {
-                string: "",
-                boolean: false,
-                timestamp: new Date(),
-            },
-            record: {
-                A: true,
-                B: false,
-            },
-            discriminator: {
-                type: "B",
-                title: "Hello World",
-                description: "",
-            },
-            nestedObject: {
-                id: "",
-                timestamp: new Date(),
-                data: {
-                    id: "",
-                    timestamp: new Date(),
-                    data: {
-                        id: "",
-                        timestamp: new Date(),
-                    },
-                },
-            },
-            nestedArray: [
-                [
-                    { id: "", timestamp: new Date() },
-                    { id: "", timestamp: new Date() },
-                ],
-            ],
-        };
-        const result = await client.miscTests.sendObject(input);
-        expect(result).toStrictEqual(input);
-    });
-    test("sendObject() unauthenticated", async () => {
-        try {
-            await unauthenticatedClient.miscTests.sendObject(input);
-            expect(true).toBe(false);
-        } catch (err) {
-            expect(err instanceof ArriRequestErrorInstance);
-            if (err instanceof ArriRequestErrorInstance) {
-                expect(err.statusCode).toBe(401);
-            }
+    ],
+};
+test("can send/receive object every field type", async () => {
+    const result = await client.tests.sendObject(input);
+    expect(result).toStrictEqual(input);
+});
+test("unauthenticated RPC request returns a 401 error", async () => {
+    try {
+        await unauthenticatedClient.tests.sendObject(input);
+        expect(true).toBe(false);
+    } catch (err) {
+        expect(err instanceof ArriRequestErrorInstance);
+        if (err instanceof ArriRequestErrorInstance) {
+            expect(err.statusCode).toBe(401);
         }
-    });
-    test("sendPartialObject()", async () => {
-        const fullObjectResult =
-            await client.miscTests.sendPartialObject(input);
-        expect(fullObjectResult).toStrictEqual(input);
-        const partialInput: ObjectWithEveryOptionalType = {
-            string: "",
-            int16: 0,
-            int64: 0n,
-        };
-        const partialObjectResult =
-            await client.miscTests.sendPartialObject(partialInput);
-        expect(partialObjectResult).toStrictEqual(partialInput);
-    });
-    test("sendObjectWithNullableFields", async () => {
-        const fullObjectResult =
-            await client.miscTests.sendObjectWithNullableFields(input);
-        expect(fullObjectResult).toStrictEqual(input);
-        const nullableInput: ObjectWithEveryNullableType = {
-            any: null,
-            boolean: null,
-            string: null,
+    }
+});
+test("can send/receive partial objects", async () => {
+    const fullObjectResult = await client.tests.sendPartialObject(input);
+    expect(fullObjectResult).toStrictEqual(input);
+    const partialInput: ObjectWithEveryOptionalType = {
+        string: "",
+        int16: 0,
+        int64: 0n,
+    };
+    const partialObjectResult =
+        await client.tests.sendPartialObject(partialInput);
+    expect(partialObjectResult).toStrictEqual(partialInput);
+});
+test("can send/receive object with nullable fields", async () => {
+    const fullObjectResult =
+        await client.tests.sendObjectWithNullableFields(input);
+    expect(fullObjectResult).toStrictEqual(input);
+    const nullableInput: ObjectWithEveryNullableType = {
+        any: null,
+        boolean: null,
+        string: null,
+        timestamp: null,
+        float32: null,
+        float64: null,
+        int8: null,
+        uint8: null,
+        int16: null,
+        uint16: null,
+        int32: null,
+        uint32: null,
+        int64: null,
+        uint64: null,
+        enumerator: null,
+        array: null,
+        object: null,
+        record: null,
+        discriminator: null,
+        nestedObject: {
+            id: null,
             timestamp: null,
-            float32: null,
-            float64: null,
-            int8: null,
-            uint8: null,
-            int16: null,
-            uint16: null,
-            int32: null,
-            uint32: null,
-            int64: null,
-            uint64: null,
-            enumerator: null,
-            array: null,
-            object: null,
-            record: null,
-            discriminator: null,
-            nestedObject: {
+            data: {
                 id: null,
                 timestamp: null,
-                data: {
-                    id: null,
-                    timestamp: null,
-                    data: null,
-                },
+                data: null,
             },
-            nestedArray: [null],
-        };
-        const nullableResult =
-            await client.miscTests.sendObjectWithNullableFields(nullableInput);
-        expect(nullableResult).toStrictEqual(nullableInput);
-    });
+        },
+        nestedArray: [null],
+    };
+    const nullableResult =
+        await client.tests.sendObjectWithNullableFields(nullableInput);
+    expect(nullableResult).toStrictEqual(nullableInput);
+});
 
-    test("recursive object", async () => {
-        const payload: RecursiveObject = {
+test("can send/receive recursive objects", async () => {
+    const payload: RecursiveObject = {
+        left: {
             left: {
-                left: {
-                    left: null,
-                    right: null,
-                    value: "depth3",
-                },
+                left: null,
+                right: null,
+                value: "depth3",
+            },
+            right: {
+                left: null,
                 right: {
                     left: null,
-                    right: {
-                        left: null,
-                        right: null,
-                        value: "depth4",
-                    },
-                    value: "depth3",
+                    right: null,
+                    value: "depth4",
                 },
-                value: "depth2",
+                value: "depth3",
             },
-            right: null,
-            value: "depth1",
-        };
-        const result = await client.miscTests.sendRecursiveObject(payload);
-        expect(result).toStrictEqual(payload);
-    });
+            value: "depth2",
+        },
+        right: null,
+        value: "depth1",
+    };
+    const result = await client.tests.sendRecursiveObject(payload);
+    expect(result).toStrictEqual(payload);
+});
 
-    test("recursive union", async () => {
-        const payload: RecursiveUnion = {
-            type: "CHILDREN",
-            data: [
-                {
-                    type: "CHILD",
-                    data: {
+test("can send/receive recursive unions", async () => {
+    const payload: RecursiveUnion = {
+        type: "CHILDREN",
+        data: [
+            {
+                type: "CHILD",
+                data: {
+                    type: "TEXT",
+                    data: "Hello world",
+                },
+            },
+            {
+                type: "SHAPE",
+                data: {
+                    width: 1,
+                    height: 2,
+                    color: "blue",
+                },
+            },
+            {
+                type: "CHILDREN",
+                data: [
+                    {
                         type: "TEXT",
                         data: "Hello world",
                     },
-                },
-                {
-                    type: "SHAPE",
-                    data: {
-                        width: 1,
-                        height: 2,
-                        color: "blue",
-                    },
-                },
-                {
-                    type: "CHILDREN",
-                    data: [
-                        {
-                            type: "TEXT",
-                            data: "Hello world",
-                        },
-                    ],
-                },
-            ],
-        };
-        const result = await client.miscTests.sendRecursiveUnion(payload);
-        expect(result).toStrictEqual(payload);
-    });
-});
-
-test("unauthorized route request", async () => {
-    try {
-        await ofetch("/routes/authors/12345", {
-            method: "post",
-            baseURL: baseUrl,
-            body: {
-                name: "John Doe",
+                ],
             },
-        });
-    } catch (err) {
-        expect(err instanceof ArriRequestErrorInstance);
-        if (err instanceof ArriRequestErrorInstance) {
-            expect(err.statusCode).toBe(401);
-        }
-    }
+        ],
+    };
+    const result = await client.tests.sendRecursiveUnion(payload);
+    expect(result).toStrictEqual(payload);
 });
 
-test("SSE request", async () => {
+test("[SSE] supports server sent events", async () => {
     let wasConnected = false;
     let receivedMessageCount = 0;
-    const controller = client.miscTests.streamMessages(
+    const controller = client.tests.streamMessages(
         { channelId: "1" },
         {
             onData(data) {
@@ -332,11 +280,11 @@ test("SSE request", async () => {
     expect(wasConnected).toBe(true);
 }, 2000);
 
-test("SSE Request with errors", async () => {
+test("[SSE] parses both 'message' and 'error' events", async () => {
     let timesConnected = 0;
     let messageCount = 0;
     let errorReceived: ArriRequestError | undefined;
-    const controller = client.miscTests.streamTenEventsThenError({
+    const controller = client.tests.streamTenEventsThenError({
         onData(_) {
             messageCount++;
         },
@@ -359,11 +307,11 @@ test("SSE Request with errors", async () => {
     expect(messageCount).toBe(10);
 }, 2000);
 
-test("SSE Request with done event", async () => {
+test("[SSE] closes connection when receiving 'done' event", async () => {
     let timesConnected = 0;
     let messageCount = 0;
     let errorReceived: ArriRequestError | undefined;
-    const controller = client.miscTests.streamTenEventsThenEnd({
+    const controller = client.tests.streamTenEventsThenEnd({
         onData(_) {
             messageCount++;
         },
@@ -385,11 +333,11 @@ test("SSE Request with done event", async () => {
     expect(messageCount).toBe(10);
 });
 
-test("SSE Requests Auto-Reconnect", async () => {
+test("[SSE] auto-reconnects when connection is closed by server", async () => {
     let connectionCount = 0;
     let errorCount = 0;
     let messageCount = 0;
-    const controller = client.miscTests.streamAutoReconnect(
+    const controller = client.tests.streamAutoReconnect(
         {
             messageCount: 10,
         },
@@ -434,17 +382,3 @@ describe("arri adapters", () => {
         expect(result).toStrictEqual(input);
     });
 });
-
-describe("manually added rpcs", () => {
-    test("updateAuthor()", async () => {
-        const input: UpdateAuthorData = {
-            name: "John Doe",
-        };
-        const result = await client.authors.updateAuthor({
-            authorId: "1",
-            data: input,
-        });
-        expect(result.id).toBe("1");
-        expect(result.name).toBe("John Doe");
-    });
-});
diff --git a/tests/server/package.json b/tests/server/package.json
index 5ccfa177..db80f7ba 100644
--- a/tests/server/package.json
+++ b/tests/server/package.json
@@ -11,6 +11,8 @@
     "integration-tests": "nx run-many -t integration-test"
   },
   "devDependencies": {
+    "arri": "workspace:*",
+    "arri-validate": "workspace:*",
     "arri-adapter-typebox": "workspace:*",
     "arri-codegen-utils": "workspace:*"
   }
diff --git a/tests/server/src/app.ts b/tests/server/src/app.ts
index 2f1aea23..6820ecdb 100644
--- a/tests/server/src/app.ts
+++ b/tests/server/src/app.ts
@@ -6,7 +6,7 @@ import {
     handleCors,
 } from "arri";
 import { a } from "arri-validate";
-import usersRouter from "./routes/authors";
+import manualRouter from "./routes/other";
 
 const app = new ArriApp({
     rpcRoutePrefix: "rpcs",
@@ -49,6 +49,6 @@ app.registerModels({
     }),
 });
 
-app.use(usersRouter);
+app.use(manualRouter);
 
 export default app;
diff --git a/tests/server/src/procedures/miscTests/deprecatedRpc.rpc.ts b/tests/server/src/procedures/tests/deprecatedRpc.rpc.ts
similarity index 73%
rename from tests/server/src/procedures/miscTests/deprecatedRpc.rpc.ts
rename to tests/server/src/procedures/tests/deprecatedRpc.rpc.ts
index 629f2a20..954f5f43 100644
--- a/tests/server/src/procedures/miscTests/deprecatedRpc.rpc.ts
+++ b/tests/server/src/procedures/tests/deprecatedRpc.rpc.ts
@@ -2,7 +2,8 @@ import { defineRpc } from "arri";
 import { a } from "arri-validate";
 
 export default defineRpc({
-    description: "This RPC is no longer supported",
+    description:
+        "If the target language supports it. Generated code should mark this procedure as deprecated.",
     isDeprecated: true,
     params: a.object(
         {
diff --git a/tests/server/src/procedures/miscTests/sendObject.rpc.ts b/tests/server/src/procedures/tests/sendObject.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/sendObject.rpc.ts
rename to tests/server/src/procedures/tests/sendObject.rpc.ts
diff --git a/tests/server/src/procedures/miscTests/sendObjectWithNullableFields.rpc.ts b/tests/server/src/procedures/tests/sendObjectWithNullableFields.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/sendObjectWithNullableFields.rpc.ts
rename to tests/server/src/procedures/tests/sendObjectWithNullableFields.rpc.ts
diff --git a/tests/server/src/procedures/miscTests/sendPartialObject.rpc.ts b/tests/server/src/procedures/tests/sendPartialObject.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/sendPartialObject.rpc.ts
rename to tests/server/src/procedures/tests/sendPartialObject.rpc.ts
diff --git a/tests/server/src/procedures/miscTests/sendRecursiveObject.rpc.ts b/tests/server/src/procedures/tests/sendRecursiveObject.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/sendRecursiveObject.rpc.ts
rename to tests/server/src/procedures/tests/sendRecursiveObject.rpc.ts
diff --git a/tests/server/src/procedures/miscTests/sendRecursiveUnion.rpc.ts b/tests/server/src/procedures/tests/sendRecursiveUnion.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/sendRecursiveUnion.rpc.ts
rename to tests/server/src/procedures/tests/sendRecursiveUnion.rpc.ts
diff --git a/tests/server/src/procedures/miscTests/streamAutoReconnect.rpc.ts b/tests/server/src/procedures/tests/streamAutoReconnect.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/streamAutoReconnect.rpc.ts
rename to tests/server/src/procedures/tests/streamAutoReconnect.rpc.ts
diff --git a/tests/server/src/procedures/miscTests/streamConnectionErrorTest.rpc.ts b/tests/server/src/procedures/tests/streamConnectionErrorTest.rpc.ts
similarity index 82%
rename from tests/server/src/procedures/miscTests/streamConnectionErrorTest.rpc.ts
rename to tests/server/src/procedures/tests/streamConnectionErrorTest.rpc.ts
index 4af6ffa3..e6cfbb29 100644
--- a/tests/server/src/procedures/miscTests/streamConnectionErrorTest.rpc.ts
+++ b/tests/server/src/procedures/tests/streamConnectionErrorTest.rpc.ts
@@ -2,6 +2,8 @@ import { defineError, defineEventStreamRpc } from "arri";
 import { a } from "arri-validate";
 
 export default defineEventStreamRpc({
+    description:
+        "This route will always return an error. The client should automatically retry with exponential backoff.",
     params: a.object(
         {
             statusCode: a.uint16(),
diff --git a/tests/server/src/procedures/miscTests/streamLargeObjects.rpc.ts b/tests/server/src/procedures/tests/streamLargeObjects.rpc.ts
similarity index 87%
rename from tests/server/src/procedures/miscTests/streamLargeObjects.rpc.ts
rename to tests/server/src/procedures/tests/streamLargeObjects.rpc.ts
index 6572f20f..0c8f6d59 100644
--- a/tests/server/src/procedures/miscTests/streamLargeObjects.rpc.ts
+++ b/tests/server/src/procedures/tests/streamLargeObjects.rpc.ts
@@ -24,6 +24,8 @@ export type StreamLargeObjectsResponse = a.infer<
 >;
 
 export default defineEventStreamRpc({
+    description:
+        "Test to ensure that the client can handle receiving streams of large objects. When objects are large messages will sometimes get sent in chunks. Meaning you have to handle receiving a partial message",
     params: undefined,
     response: StreamLargeObjectsResponse,
     async handler({ stream }) {
diff --git a/tests/server/src/procedures/miscTests/streamMessages.rpc.ts b/tests/server/src/procedures/tests/streamMessages.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/streamMessages.rpc.ts
rename to tests/server/src/procedures/tests/streamMessages.rpc.ts
diff --git a/tests/server/src/procedures/miscTests/streamTenEventsThenEnd.rpc.ts b/tests/server/src/procedures/tests/streamTenEventsThenEnd.rpc.ts
similarity index 90%
rename from tests/server/src/procedures/miscTests/streamTenEventsThenEnd.rpc.ts
rename to tests/server/src/procedures/tests/streamTenEventsThenEnd.rpc.ts
index 2de5443e..b692a92e 100644
--- a/tests/server/src/procedures/miscTests/streamTenEventsThenEnd.rpc.ts
+++ b/tests/server/src/procedures/tests/streamTenEventsThenEnd.rpc.ts
@@ -3,6 +3,8 @@ import { defineEventStreamRpc } from "arri";
 import { ChatMessage } from "./streamMessages.rpc";
 
 export default defineEventStreamRpc({
+    description:
+        "When the client receives the 'done' event, it should close the connection and NOT reconnect",
     params: undefined,
     response: ChatMessage,
     handler({ stream }) {
diff --git a/tests/server/src/procedures/miscTests/streamTenEventsThenError.rpc.ts b/tests/server/src/procedures/tests/streamTenEventsThenError.rpc.ts
similarity index 100%
rename from tests/server/src/procedures/miscTests/streamTenEventsThenError.rpc.ts
rename to tests/server/src/procedures/tests/streamTenEventsThenError.rpc.ts
diff --git a/tests/server/src/routes/authors.ts b/tests/server/src/routes/authors.ts
deleted file mode 100644
index 6f9d7a13..00000000
--- a/tests/server/src/routes/authors.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { ArriRouter } from "arri";
-import { a } from "arri-validate";
-import { Author, getRandomAuthor } from "../models";
-
-const router = new ArriRouter();
-
-router.route({
-    path: "/routes/hello-world",
-    method: ["get", "post"],
-    handler(_) {
-        return `hello world`;
-    },
-});
-
-const UpdateAuthorData = a.partial(a.omit(Author, ["id"]), {
-    id: "UpdateAuthorData",
-});
-type UpdateAuthorData = a.infer<typeof UpdateAuthorData>;
-
-router.route({
-    path: "/routes/authors/:authorId",
-    method: "post",
-    body: UpdateAuthorData,
-    async handler(event) {
-        const body = event.context.body;
-        return getRandomAuthor({
-            id: event.context.params.authorId,
-            name: body.name,
-            bio: body.bio,
-            createdAt: body.createdAt,
-            updatedAt: body.updatedAt,
-        });
-    },
-});
-
-router.rpc({
-    name: "authors.updateAuthor",
-    params: a.object({
-        authorId: a.string(),
-        data: UpdateAuthorData,
-    }),
-    response: Author,
-    async handler({ params }) {
-        return getRandomAuthor({
-            id: params.authorId,
-            name: params.data.name,
-            bio: params.data.bio,
-            createdAt: params.data.createdAt,
-            updatedAt: params.data.updatedAt,
-        });
-    },
-});
-
-export default router;
diff --git a/tests/server/src/routes/other.ts b/tests/server/src/routes/other.ts
new file mode 100644
index 00000000..0cb37100
--- /dev/null
+++ b/tests/server/src/routes/other.ts
@@ -0,0 +1,61 @@
+import { ArriRouter } from "arri";
+import { a } from "arri-validate";
+
+const router = new ArriRouter();
+
+const DefaultPayload = a.object(
+    {
+        message: a.string(),
+    },
+    {
+        id: "DefaultPayload",
+    },
+);
+
+router.route({
+    path: "/routes/hello-world",
+    method: ["get", "post"],
+    handler(_) {
+        return `hello world`;
+    },
+});
+
+router.rpc({
+    method: "get",
+    name: "tests.emptyParamsGetRequest",
+    params: undefined,
+    response: DefaultPayload,
+    handler() {
+        return {
+            message: "ok",
+        };
+    },
+});
+
+router.rpc({
+    name: "tests.emptyParamsPostRequest",
+    params: undefined,
+    response: DefaultPayload,
+    handler() {
+        return {
+            message: "ok",
+        };
+    },
+});
+
+router.rpc({
+    method: "get",
+    name: "tests.emptyResponseGetRequest",
+    params: DefaultPayload,
+    response: undefined,
+    handler() {},
+});
+
+router.rpc({
+    name: "tests.emptyResponsePostRequest",
+    params: DefaultPayload,
+    response: undefined,
+    handler() {},
+});
+
+export default router;
diff --git a/tests/server/tsconfig.json b/tests/server/tsconfig.json
index b1d58d11..0a23d446 100644
--- a/tests/server/tsconfig.json
+++ b/tests/server/tsconfig.json
@@ -1,6 +1,14 @@
 {
-  "extends": "../../tsconfig.base.json",
   "compilerOptions": {
+    "baseUrl": ".",
+    "target": "ES2020",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "strict": true,
+    "skipLibCheck": true,
     "types": ["vitest", "vitest/globals", "node"]
   }
 }