@synnaxlabs/client 0.53.0 → 0.54.0

package/src/framer/streamer.spec.ts

@@ -41,6 +41,36 @@ describe("Streamer", () => {
       const d = await streamer.read();
       expect(Array.from(d.get(ch.key))).toEqual([1, 2, 3]);
     });
+    test("should preserve non-zero time ranges through codec round-trip", async () => {
+      const ch = await newVirtualChannel(client);
+      const streamer = await client.openStreamer(ch.key);
+      const writer = await client.openWriter({
+        start: TimeStamp.now(),
+        channels: ch.key,
+      });
+      const start = new TimeStamp(1000000000n);
+      const end = new TimeStamp(6000000000n);
+      try {
+        const fr = new Frame(
+          [ch.key],
+          [
+            new Series({
+              data: new Float64Array([1, 2, 3]),
+              dataType: DataType.FLOAT64,
+              timeRange: start.spanRange(TimeSpan.seconds(5)),
+            }),
+          ],
+        );
+        await writer.write(fr);
+      } finally {
+        await writer.close();
+      }
+      const d = await streamer.read();
+      const series = d.series[0];
+      expect(series.timeRange).toBeDefined();
+      expect(series.timeRange?.start.valueOf()).toEqual(start.valueOf());
+      expect(series.timeRange?.end.valueOf()).toEqual(end.valueOf());
+    });
     test("open with config", async () => {
       const ch = await newVirtualChannel(client);
       await expect(client.openStreamer({ channels: ch.key })).resolves.not.toThrow();
@@ -56,6 +86,73 @@ describe("Streamer", () => {
     it("should throw an error when the streamer is opened with a channel that does not exist", async () => {
       await expect(client.openStreamer([5678])).rejects.toThrow("not found");
     });
+    describe("excludeGroups", () => {
+      test("should filter out frames from a writer whose group matches", async () => {
+        const ch = await newVirtualChannel(client);
+        const streamer = await client.openStreamer({
+          channels: ch.key,
+          excludeGroups: [42],
+        });
+        const writer = await client.openWriter({
+          start: TimeStamp.now(),
+          channels: ch.key,
+          controlSubject: { name: "grouped", key: id.create(), group: 42 },
+        });
+        try {
+          await writer.write(ch.key, new Float64Array([1, 2, 3]));
+          const result = await Promise.race([
+            streamer.read().then((f) => f),
+            sleep.sleep(TimeSpan.milliseconds(500)).then(() => null),
+          ]);
+          expect(result).toBeNull();
+        } finally {
+          await writer.close();
+          streamer.close();
+        }
+      });
+
+      test("should deliver frames from a writer whose group does not match", async () => {
+        const ch = await newVirtualChannel(client);
+        const streamer = await client.openStreamer({
+          channels: ch.key,
+          excludeGroups: [99],
+        });
+        const writer = await client.openWriter({
+          start: TimeStamp.now(),
+          channels: ch.key,
+          controlSubject: { name: "grouped", key: id.create(), group: 42 },
+        });
+        try {
+          await writer.write(ch.key, new Float64Array([1, 2, 3]));
+          const d = await streamer.read();
+          expect(Array.from(d.get(ch.key))).toEqual([1, 2, 3]);
+        } finally {
+          await writer.close();
+          streamer.close();
+        }
+      });
+
+      test("should deliver frames from a writer with group 0 even if 0 is excluded", async () => {
+        const ch = await newVirtualChannel(client);
+        const streamer = await client.openStreamer({
+          channels: ch.key,
+          excludeGroups: [0],
+        });
+        const writer = await client.openWriter({
+          start: TimeStamp.now(),
+          channels: ch.key,
+        });
+        try {
+          await writer.write(ch.key, new Float64Array([1, 2, 3]));
+          const d = await streamer.read();
+          expect(Array.from(d.get(ch.key))).toEqual([1, 2, 3]);
+        } finally {
+          await writer.close();
+          streamer.close();
+        }
+      });
+    });
+
     describe("downsampling", () => {
       test("downsample factor of 1", async () => {
         const ch = await newVirtualChannel(client);
@@ -484,6 +581,7 @@ describe("Streamer", () => {
       expect(openMock).toHaveBeenCalledWith({
         ...config,
         downsampleFactor: 1,
+        excludeGroups: [],
         throttleRate: new Rate(0),
       });
       await hardened.update([1, 2, 3]);

package/src/framer/streamer.ts

@@ -22,6 +22,7 @@ const reqZ = z.object({
   keys: z.number().array(),
   downsampleFactor: z.int(),
   throttleRate: Rate.z.optional(),
+  excludeGroups: z.uint32().array().optional(),
 });
 
 /**
@@ -48,6 +49,9 @@ const intermediateStreamerConfigZ = z.object({
   /** useHighPerformanceCodec sets whether the writer will use the Synnax frame encoder
    as opposed to the standard JSON encoding mechanisms for frames. */
   useHighPerformanceCodec: z.boolean().default(true),
+  /** excludeGroups sets writer group IDs whose frames should be filtered out by the
+   Core. Used for telemetry bypass deduplication. */
+  excludeGroups: z.uint32().array().default([]),
 });
 
 export const streamerConfigZ = intermediateStreamerConfigZ.or(
@@ -116,11 +120,13 @@ export const createStreamOpener =
       adapter,
       cfg.downsampleFactor,
       cfg.throttleRate,
+      cfg.excludeGroups,
     );
     stream.send({
       keys: Array.from(adapter.keys),
       downsampleFactor: cfg.downsampleFactor,
       throttleRate: cfg.throttleRate,
+      excludeGroups: cfg.excludeGroups,
     });
     const [, err] = await stream.receive();
     if (err != null) throw err;
@@ -145,17 +151,20 @@ class BaseStreamer implements Streamer {
   private readonly adapter: ReadAdapter;
   private readonly downsampleFactor: number;
   private readonly throttleRate: Rate;
+  private readonly excludeGroups: number[];
 
   constructor(
     stream: Stream<typeof reqZ, typeof resZ>,
     adapter: ReadAdapter,
     downsampleFactor: number = 1,
     throttleRate: Rate = new Rate(0),
+    excludeGroups: number[] = [],
   ) {
     this.stream = new StreamProxy("Streamer", stream);
     this.adapter = adapter;
     this.downsampleFactor = downsampleFactor;
     this.throttleRate = throttleRate;
+    this.excludeGroups = excludeGroups;
   }
 
   get keys(): channel.Key[] {
@@ -183,6 +192,7 @@ class BaseStreamer implements Streamer {
       keys: Array.from(this.adapter.keys),
       downsampleFactor: this.downsampleFactor,
       throttleRate: this.throttleRate,
+      excludeGroups: this.excludeGroups,
     });
   }
 

package/src/framer/types.gen.ts

@@ -0,0 +1,20 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { z } from "zod";
+
+export enum WriterCommand {
+  Open = 0,
+  Write = 1,
+  Commit = 2,
+  SetAuthority = 3,
+}
+export const writerCommandZ = z.enum(WriterCommand);

package/src/framer/writer.ts

@@ -16,7 +16,7 @@ import { SynnaxError } from "@/errors";
 import { WriteAdapter } from "@/framer/adapter";
 import { WSWriterCodec } from "@/framer/codec";
 import { type CrudeFrame, frameZ } from "@/framer/frame";
-import { WriterCommand } from "@/framer/payload";
+import { WriterCommand } from "@/framer/types.gen";
 
 export enum WriterMode {
   PersistStream = 1,
@@ -135,9 +135,12 @@ const authorityArgsZ = z
         throw new Error(
           "authority is required when setting authority for a single channel",
         );
-      return { keys: [value] as channel.KeysOrNames, authorities: [authority] };
+      return {
+        keys: [value] as channel.Key[] | channel.Name[],
+        authorities: [authority],
+      };
     }
-    const oValue = value as Record<channel.KeyOrName, control.Authority>;
+    const oValue = value as Record<channel.Key | channel.Name, control.Authority>;
     return { keys: Object.keys(oValue), authorities: Object.values(oValue) };
   });
 
@@ -213,15 +216,18 @@ export class Writer {
     return writer;
   }
 
-  async write(channel: channel.KeyOrName, data: CrudeSeries): Promise<void>;
-  async write(channel: channel.KeysOrNames, data: CrudeSeries[]): Promise<void>;
+  async write(channel: channel.Key | channel.Name, data: CrudeSeries): Promise<void>;
   async write(
-    frame: CrudeFrame | Record<channel.KeyOrName, CrudeSeries>,
+    channel: channel.Key[] | channel.Name[],
+    data: CrudeSeries[],
+  ): Promise<void>;
+  async write(
+    frame: CrudeFrame | Record<channel.Key | channel.Name, CrudeSeries>,
   ): Promise<void>;
   async write(
     channelsOrData:
       | channel.Params
-      | Record<channel.KeyOrName, CrudeSeries>
+      | Record<channel.Key | channel.Name, CrudeSeries>
       | CrudeFrame,
     series?: CrudeSeries | CrudeSeries[],
   ): Promise<void>;
@@ -243,7 +249,7 @@ export class Writer {
   async write(
     channelsOrData:
       | channel.Params
-      | Record<channel.KeyOrName, CrudeSeries>
+      | Record<channel.Key | channel.Name, CrudeSeries>
       | CrudeFrame,
     series?: CrudeSeries | CrudeSeries[],
   ): Promise<void> {

package/src/group/client.ts

@@ -11,7 +11,7 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
 import z from "zod";
 
-import { type Group, groupZ, type Key, keyZ } from "@/group/payload";
+import { type Group, groupZ, type Key, keyZ } from "@/group/types.gen";
 import { idZ as ontologyIDZ } from "@/ontology/payload";
 
 export const SET_CHANNEL_NAME = "sy_group_set";

package/src/group/external.ts

@@ -8,4 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/group/client";
-export * from "@/group/payload";
+export * from "@/group/types.gen";

package/src/group/group.spec.ts

@@ -59,7 +59,7 @@ describe("Group", () => {
       await client.groups.delete(g.key);
       await expect(
         async () => await client.ontology.retrieve(group.ontologyID(g.key)),
-      ).rejects.toThrowError(NotFoundError);
+      ).rejects.toThrow(NotFoundError);
     });
   });
 });

package/src/{access/role/payload.ts → group/types.gen.ts}

@@ -7,26 +7,26 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+// Code generated by Oracle. DO NOT EDIT.
+
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
 
 export const keyZ = z.uuid();
-
 export type Key = z.infer<typeof keyZ>;
 
-export const roleZ = z.object({
+/**
+ * Group is a named collection container for organizing related resources. Groups
+ * provide hierarchical organization through the ontology system.
+ */
+export const groupZ = z.object({
+  /** key is the unique identifier for this group. */
   key: keyZ,
+  /** name is a human-readable name for the group. */
   name: z.string(),
-  description: z.string().optional(),
-  internal: z.boolean().optional(),
 });
+export interface Group extends z.infer<typeof groupZ> {}
 
-export type Role = z.infer<typeof roleZ>;
-
-export const newZ = roleZ.partial({ key: true });
-
-export type New = z.infer<typeof newZ>;
-
-export const ontologyID = ontology.createIDFactory<Key>("role");
+export const ontologyID = ontology.createIDFactory<Key>("group");
 export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/label/client.ts

@@ -11,16 +11,13 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
 import z from "zod";
 
-import { type Key, keyZ, type Label, labelZ } from "@/label/payload";
+import { type Key, keyZ, type Label, labelZ, type New, newZ } from "@/label/payload";
 import { ontology } from "@/ontology";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
 export const SET_CHANNEL_NAME = "sy_label_set";
 export const DELETE_CHANNEL_NAME = "sy_label_delete";
 
-export const newZ = labelZ.extend({ key: keyZ.optional() });
-export interface New extends z.input<typeof newZ> {}
-
 const createReqZ = z.object({ labels: newZ.array() });
 const createResZ = z.object({ labels: labelZ.array() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
@@ -55,7 +52,7 @@ export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
 export type RetrieveMultipleParams = z.input<typeof retrieveRequestZ>;
 
-const retrieveResponseZ = z.object({ labels: array.nullableZ(labelZ) });
+const retrieveResponseZ = z.object({ labels: array.nullishToEmpty(labelZ) });
 
 export class Client {
   readonly type: string = "label";

package/src/label/label.spec.ts

@@ -17,14 +17,20 @@ const client = createTestClient();
 describe("Label", () => {
   describe("create", () => {
     it("should create a label", async () => {
-      const v = await client.labels.create({ name: "Label", color: "#E774D0" });
+      const v = await client.labels.create({
+        name: "Label",
+        color: "#E774D0",
+      });
       expect(v.key).not.toHaveLength(0);
     });
   });
 
   describe("retrieve", () => {
     it("should retrieve a label by its key", async () => {
-      const v = await client.labels.create({ name: "Label", color: "#E774D0" });
+      const v = await client.labels.create({
+        name: "Label",
+        color: "#E774D0",
+      });
       const retrieved = await client.labels.retrieve({ key: v.key });
       expect(retrieved).toEqual(v);
     });
@@ -32,7 +38,10 @@ describe("Label", () => {
 
   describe("delete", () => {
     it("should delete a label by its key", async () => {
-      const v = await client.labels.create({ name: "Label", color: "#E774D0" });
+      const v = await client.labels.create({
+        name: "Label",
+        color: "#E774D0",
+      });
       await client.labels.delete(v.key);
       await expect(
         async () => await client.labels.retrieve({ key: v.key }),

package/src/label/payload.ts

@@ -14,6 +14,8 @@ export type Params = label.Key | label.Key[];
 export const keyZ = label.keyZ;
 export type Key = label.Key;
 export const labelZ = label.labelZ;
-export type Label = label.Label;
+export interface Label extends label.Label {}
+export const newZ = label.newZ;
+export interface New extends label.New {}
 
 export const LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE = "labeled_by";

package/src/lineplot/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, type record } from "@synnaxlabs/x";
+import { array, caseconv, record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import {
@@ -18,15 +18,16 @@ import {
   linePlotZ,
   type New,
   newZ,
-  type Params,
-} from "@/lineplot/payload";
-import { ontology } from "@/ontology";
+} from "@/lineplot/types.gen";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { workspace } from "@/workspace";
 
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
 
-const setDataReqZ = z.object({ key: keyZ, data: z.string() });
+const setDataReqZ = z.object({
+  key: keyZ,
+  data: caseconv.preserveCase(record.unknownZ()),
+});
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const retrieveReqZ = z.object({ keys: keyZ.array() });
@@ -39,7 +40,7 @@ export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
 export type RetrieveMultipleParams = z.input<typeof retrieveReqZ>;
 
-const retrieveResZ = z.object({ linePlots: array.nullableZ(linePlotZ) });
+const retrieveResZ = z.object({ linePlots: array.nullishToEmpty(linePlotZ) });
 
 const createReqZ = z.object({ workspace: workspace.keyZ, linePlots: newZ.array() });
 const createResZ = z.object({ linePlots: linePlotZ.array() });
@@ -84,7 +85,7 @@ export class Client {
     await sendRequired(
       this.client,
       "/lineplot/set-data",
-      { key, data: JSON.stringify(data) },
+      { key, data },
       setDataReqZ,
       emptyResZ,
     );
@@ -107,7 +108,7 @@ export class Client {
     return isSingle ? res.linePlots[0] : res.linePlots;
   }
 
-  async delete(keys: Params): Promise<void> {
+  async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired(
       this.client,
       "/lineplot/delete",
@@ -117,6 +118,3 @@ export class Client {
     );
   }
 }
-
-export const ontologyID = ontology.createIDFactory<Key>("lineplot");
-export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/lineplot/external.ts

@@ -8,4 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/lineplot/client";
-export * from "@/lineplot/payload";
+export * from "@/lineplot/types.gen";

package/src/lineplot/lineplot.spec.ts

@@ -77,4 +77,44 @@ describe("LinePlot", () => {
       );
     });
   });
+  describe("case preservation", () => {
+    test("should preserve key casing in data field on create/retrieve cycle", async () => {
+      const ws = await client.workspaces.create({ name: "CaseTest", layout: {} });
+      const linePlot = await client.lineplots.create(ws.key, {
+        name: "CaseTest",
+        data: {
+          camelCaseKey: "value1",
+          PascalCaseKey: "value2",
+          snake_case_key: "value3",
+          nested: {
+            innerCamelCase: 123,
+            InnerPascalCase: { deepKey: true },
+          },
+        },
+      });
+
+      const retrieved = await client.lineplots.retrieve({
+        key: linePlot.key,
+      });
+
+      const data = retrieved.data as Record<string, unknown>;
+      expect(data.camelCaseKey).toEqual("value1");
+      expect(data.PascalCaseKey).toEqual("value2");
+      expect(data.snake_case_key).toEqual("value3");
+      expect((data.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
+      expect(
+        (
+          (data.nested as Record<string, unknown>).InnerPascalCase as Record<
+            string,
+            unknown
+          >
+        ).deepKey,
+      ).toEqual(true);
+      expect(Object.keys(data)).toContain("camelCaseKey");
+      expect(Object.keys(data)).toContain("PascalCaseKey");
+      expect(Object.keys(data)).toContain("snake_case_key");
+      expect(Object.keys(data)).not.toContain("camel_case_key");
+      expect(Object.keys(data)).not.toContain("pascal_case_key");
+    });
+  });
 });

package/src/lineplot/types.gen.ts

@@ -0,0 +1,42 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { caseconv, record } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+
+export const keyZ = z.uuid();
+export type Key = z.infer<typeof keyZ>;
+
+/**
+ * LinePlot is a time-series visualization component for plotting telemetry data.
+ * Line plots support multiple channels, real-time streaming, and historical
+ * data display with zoom and pan capabilities.
+ */
+export const linePlotZ = z.object({
+  /** key is the unique identifier for this line plot. */
+  key: keyZ,
+  /** name is a human-readable name for the line plot. */
+  name: z.string(),
+  /**
+   * data is the line plot configuration including channel references, axis
+   * settings, and display options.
+   */
+  data: caseconv.preserveCase(record.nullishToEmpty()),
+});
+export interface LinePlot extends z.infer<typeof linePlotZ> {}
+
+export const newZ = linePlotZ.partial({ key: true });
+export interface New extends z.input<typeof newZ> {}
+
+export const ontologyID = ontology.createIDFactory<Key>("lineplot");
+export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/log/client.ts

@@ -8,25 +8,19 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, type record } from "@synnaxlabs/x";
+import { array, caseconv, record } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import {
-  type Key,
-  keyZ,
-  type Log,
-  logZ,
-  type New,
-  newZ,
-  type Params,
-} from "@/log/payload";
-import { ontology } from "@/ontology";
+import { type Key, keyZ, type Log, logZ, type New, newZ } from "@/log/types.gen";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { workspace } from "@/workspace";
 
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
 
-const setDataReqZ = z.object({ key: keyZ, data: z.string() });
+const setDataReqZ = z.object({
+  key: keyZ,
+  data: caseconv.preserveCase(record.unknownZ()),
+});
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const retrieveReqZ = z.object({ keys: keyZ.array() });
@@ -39,7 +33,7 @@ export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
 export type RetrieveMultipleParams = z.input<typeof retrieveReqZ>;
 
-const retrieveResZ = z.object({ logs: array.nullableZ(logZ) });
+const retrieveResZ = z.object({ logs: array.nullishToEmpty(logZ) });
 
 const createReqZ = z.object({ workspace: workspace.keyZ, logs: newZ.array() });
 const createResZ = z.object({ logs: logZ.array() });
@@ -81,7 +75,7 @@ export class Client {
     await sendRequired(
       this.client,
       "/log/set-data",
-      { key, data: JSON.stringify(data) },
+      { key, data },
       setDataReqZ,
       emptyResZ,
     );
@@ -104,7 +98,7 @@ export class Client {
     return isSingle ? res.logs[0] : res.logs;
   }
 
-  async delete(keys: Params): Promise<void> {
+  async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired(
       this.client,
       "/log/delete",
@@ -114,6 +108,3 @@ export class Client {
     );
   }
 }
-
-export const ontologyID = ontology.createIDFactory<Key>("log");
-export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/log/external.ts

@@ -8,4 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/log/client";
-export * from "@/log/payload";
+export * from "@/log/types.gen";

package/src/log/log.spec.ts

@@ -65,4 +65,42 @@ describe("Log", () => {
       );
     });
   });
+  describe("case preservation", () => {
+    test("should preserve key casing in data field on create/retrieve cycle", async () => {
+      const ws = await client.workspaces.create({ name: "CaseTest", layout: {} });
+      const log = await client.logs.create(ws.key, {
+        name: "CaseTest",
+        data: {
+          camelCaseKey: "value1",
+          PascalCaseKey: "value2",
+          snake_case_key: "value3",
+          nested: {
+            innerCamelCase: 123,
+            InnerPascalCase: { deepKey: true },
+          },
+        },
+      });
+
+      const retrieved = await client.logs.retrieve({ key: log.key });
+
+      const data = retrieved.data as Record<string, unknown>;
+      expect(data.camelCaseKey).toEqual("value1");
+      expect(data.PascalCaseKey).toEqual("value2");
+      expect(data.snake_case_key).toEqual("value3");
+      expect((data.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
+      expect(
+        (
+          (data.nested as Record<string, unknown>).InnerPascalCase as Record<
+            string,
+            unknown
+          >
+        ).deepKey,
+      ).toEqual(true);
+      expect(Object.keys(data)).toContain("camelCaseKey");
+      expect(Object.keys(data)).toContain("PascalCaseKey");
+      expect(Object.keys(data)).toContain("snake_case_key");
+      expect(Object.keys(data)).not.toContain("camel_case_key");
+      expect(Object.keys(data)).not.toContain("pascal_case_key");
+    });
+  });
 });