@synnaxlabs/client 0.43.1 → 0.44.2

package/src/ranger/payload.ts

@@ -7,11 +7,12 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { array } from "@synnaxlabs/x/array";
 import { TimeRange } from "@synnaxlabs/x/telem";
-import { z } from "zod/v4";
+import { z } from "zod";
 
-export const keyZ = z.string().uuid();
+import { label } from "@/label";
+
+export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 export const nameZ = z.string().min(1);
 export type Name = z.infer<typeof nameZ>;
@@ -24,40 +25,25 @@ export const payloadZ = z.object({
   name: nameZ,
   timeRange: TimeRange.z,
   color: z.string().optional(),
+  labels: label.labelZ
+    .array()
+    .or(z.null().transform(() => undefined))
+    .optional(),
+  get parent(): z.ZodUnion<readonly [z.ZodNull, typeof payloadZ]> {
+    // Using as unknown is bad, but unfortunately resolving the output type of this
+    // transform is nearly impossible.
+    return payloadZ
+      .optional()
+      .nullable()
+      .transform((p) => (p === undefined ? null : p)) as unknown as z.ZodUnion<
+      readonly [z.ZodNull, typeof payloadZ]
+    >;
+  },
 });
-export interface Payload extends z.infer<typeof payloadZ> {}
-
-export const newZ = payloadZ.partial({ key: true });
-export interface New extends z.input<typeof newZ> {}
 
-export type ParamAnalysisResult =
-  | { single: true; variant: "keys"; normalized: Keys; actual: Key; empty: never }
-  | { single: true; variant: "names"; normalized: Names; actual: Name; empty: never }
-  | { single: false; variant: "keys"; normalized: Keys; actual: Keys; empty: boolean }
-  | {
-      single: false;
-      variant: "names";
-      normalized: Names;
-      actual: Names;
-      empty: boolean;
-    };
+export type Payload = z.infer<typeof payloadZ>;
 
-export const analyzeParams = (ranges: Params): ParamAnalysisResult => {
-  const normal = array.toArray(ranges) as Keys | Names;
-  const empty = normal.length === 0;
-  let isKey = false;
-  if (!empty) isKey = keyZ.safeParse(normal[0]).success;
-  return {
-    single: !Array.isArray(ranges),
-    variant: isKey ? "keys" : "names",
-    normalized: normal,
-    actual: ranges,
-    empty,
-  } as ParamAnalysisResult;
-};
-
-export const ONTOLOGY_TYPE = "range";
-export type OntologyType = typeof ONTOLOGY_TYPE;
-
-export const ALIAS_ONTOLOGY_TYPE = "range-alias";
-export type AliasOntologyType = typeof ALIAS_ONTOLOGY_TYPE;
+export const newZ = payloadZ
+  .omit({ parent: true, labels: true })
+  .partial({ key: true });
+export interface New extends z.input<typeof newZ> {}

package/src/ranger/ranger.spec.ts

@@ -7,15 +7,14 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type change } from "@synnaxlabs/x";
 import { DataType, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
 import { describe, expect, it } from "vitest";
 
 import { NotFoundError } from "@/errors";
 import { type ranger } from "@/ranger";
-import { newClient } from "@/setupspecs";
+import { createTestClient } from "@/testutil/client";
 
-const client = newClient();
+const client = createTestClient();
 
 describe("Ranger", () => {
   describe("create", () => {
@@ -143,25 +142,6 @@ describe("Ranger", () => {
     });
   });
 
-  describe("page", () => {
-    it("should page through ranges", async () => {
-      await client.ranges.create({
-        name: "My New One Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-      });
-      await client.ranges.create({
-        name: "My New Two Second Range",
-        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(2)),
-      });
-      const ranges = await client.ranges.page(0, 1);
-      expect(ranges.length).toEqual(1);
-      const keys = ranges.map((r) => r.key);
-      const next = await client.ranges.page(1, 1);
-      expect(next.length).toEqual(1);
-      expect(next.map((r) => r.key)).not.toContain(keys[0]);
-    });
-  });
-
   describe("KV", () => {
     it("should set, get, and delete a single key", async () => {
       const rng = await client.ranges.create({
@@ -196,43 +176,44 @@ describe("Ranger", () => {
       const res = await rng.kv.list();
       expect(res).toEqual({ foo: "bar", baz: "qux" });
     });
+  });
 
-    describe("observable", () => {
-      it("should listen to key-value sets on the range", async () => {
-        const rng = await client.ranges.create({
-          name: "My New One Second Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        });
-        const obs = await rng.kv.openTracker();
-        const res = new Promise<change.Change<string, ranger.KVPair>[]>((resolve) => {
-          obs.onChange((pair) => resolve(pair));
-        });
-        await rng.kv.set("foo", "bar");
-        const pair = await res;
-        expect(pair.length).toBeGreaterThan(0);
-        expect(pair[0].value?.range).toEqual(rng.key);
-        expect(pair[0].value?.key).toEqual("foo");
-        expect(pair[0].value?.value).toEqual("bar");
+  describe("label", () => {
+    it("should set and get a label for the range", async () => {
+      const rng = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
       });
-      it("should listen to key-value deletes on the range", async () => {
-        const rng = await client.ranges.create({
-          name: "My New One Second Range",
-          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
-        });
-        await rng.kv.set("foo", "bar");
-        const obs = await rng.kv.openTracker();
-        const res = new Promise<change.Change<string, ranger.KVPair>[]>((resolve) => {
-          obs.onChange((changes) => {
-            if (changes.every((c) => c.variant === "delete")) resolve(changes);
-          });
-        });
-        await rng.kv.delete("foo");
-        const pair = await res;
-        expect(pair.length).toBeGreaterThan(0);
-        expect(pair[0].value?.range).toEqual(rng.key);
-        expect(pair[0].value?.key).toEqual("foo");
-        expect(pair[0].value?.value).toHaveLength(0);
+      const label = await client.labels.create({
+        name: "My New Label",
+        color: "#E774D0",
+      });
+      await rng.addLabel(label.key);
+      const newRange = await client.ranges.retrieve({
+        keys: [rng.key],
+        includeLabels: true,
+      });
+      expect(newRange[0].labels).toHaveLength(1);
+      expect(newRange[0].labels?.[0]).toEqual(label);
+    });
+  });
+
+  describe("parent", () => {
+    it("should set and get a parent for the range", async () => {
+      const parent = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+      });
+      const child = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+      });
+      await client.ontology.addChildren(parent.ontologyID, child.ontologyID);
+      const newParent = await client.ranges.retrieve({
+        keys: [child.key],
+        includeParent: true,
       });
+      expect(newParent[0].parent).toEqual(parent.payload);
     });
   });
 

package/src/ranger/writer.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import { ontology } from "@/ontology";
 import { keyZ, nameZ, type New, newZ, type Payload, payloadZ } from "@/ranger/payload";

package/src/{signals/index.ts → testutil/client.ts}

@@ -7,4 +7,14 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as signals from "@/signals/external";
+import Synnax, { type SynnaxProps } from "@/client";
+
+export const TEST_CLIENT_PROPS: SynnaxProps = {
+  host: "localhost",
+  port: 9090,
+  username: "synnax",
+  password: "seldon",
+};
+
+export const createTestClient = (props?: Partial<SynnaxProps>): Synnax =>
+  new Synnax({ ...TEST_CLIENT_PROPS, ...props });

package/src/user/client.ts

@@ -7,79 +7,154 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type UnaryClient } from "@synnaxlabs/freighter";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
+import { z } from "zod";
 
 import { MultipleFoundError, NotFoundError } from "@/errors";
-import { ontology } from "@/ontology";
-import { type Key, type New, ONTOLOGY_TYPE, type User } from "@/user/payload";
-import { Retriever } from "@/user/retriever";
-import { Writer } from "@/user/writer";
+import { type ontology } from "@/ontology";
+import { type Key, keyZ, type New, newZ, type User, userZ } from "@/user/payload";
+import { nullableArrayZ } from "@/util/zod";
+
+const retrieveRequestZ = z.object({
+  keys: keyZ.array().optional(),
+  usernames: z.string().array().optional(),
+});
+
+const keyRetrieveRequestZ = z
+  .object({
+    key: keyZ,
+  })
+  .transform(({ key }) => ({ keys: [key] }));
+
+const usernameRetrieveRequestZ = z
+  .object({
+    username: z.string(),
+  })
+  .transform(({ username }) => ({ usernames: [username] }));
+
+const usernamesRetrieveRequestZ = z
+  .object({
+    usernames: z.string().array(),
+  })
+  .transform(({ usernames }) => ({ usernames }));
+
+export type KeyRetrieveRequest = z.input<typeof keyRetrieveRequestZ>;
+export type UsernameRetrieveRequest = z.input<typeof usernameRetrieveRequestZ>;
+export type UsernamesRetrieveRequest = z.input<typeof usernamesRetrieveRequestZ>;
+
+const retrieveArgsZ = z.union([
+  keyRetrieveRequestZ,
+  usernameRetrieveRequestZ,
+  usernamesRetrieveRequestZ,
+  retrieveRequestZ,
+]);
+
+export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
+
+export interface RetrieveRequest extends z.infer<typeof retrieveRequestZ> {}
+
+const retrieveResZ = z.object({ users: nullableArrayZ(userZ) });
+
+const createReqZ = z.object({ users: newZ.array() });
+const createResZ = z.object({ users: userZ.array() });
+const changeUsernameReqZ = z.object({ key: keyZ, username: z.string().min(1) });
+const changeUsernameResZ = z.object({});
+const renameReqZ = z.object({
+  key: keyZ,
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+});
+const renameResZ = z.object({});
+const deleteReqZ = z.object({ keys: keyZ.array() });
+const deleteResZ = z.object({});
+
+const RETRIEVE_ENDPOINT = "/user/retrieve";
+const CREATE_ENDPOINT = "/user/create";
+const CHANGE_USERNAME_ENDPOINT = "/user/change-username";
+const RENAME_ENDPOINT = "/user/rename";
+const DELETE_ENDPOINT = "/user/delete";
 
 export class Client {
-  private readonly reader: Retriever;
-  private readonly writer: Writer;
+  private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
-    this.writer = new Writer(client);
-    this.reader = new Retriever(client);
+    this.client = client;
   }
 
   async create(user: New): Promise<User>;
-
   async create(users: New[]): Promise<User[]>;
-
   async create(users: New | New[]): Promise<User | User[]> {
     const isMany = Array.isArray(users);
-    const res = await this.writer.create(users);
-    return isMany ? res : res[0];
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { users: array.toArray(users) },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.users : res.users[0];
   }
 
   async changeUsername(key: Key, newUsername: string): Promise<void> {
-    await this.writer.changeUsername(key, newUsername);
-  }
-
-  async retrieve(key: Key): Promise<User>;
-
-  async retrieve(keys: Key[]): Promise<User[]>;
-
-  async retrieve(keys: Key | Key[]): Promise<User | User[]> {
-    const isMany = Array.isArray(keys);
-    const res = await this.reader.retrieve({ keys: array.toArray(keys) });
-    if (isMany) return res;
-    if (res.length === 0) throw new NotFoundError(`No user with key ${keys} found`);
-    if (res.length > 1)
-      throw new MultipleFoundError(`Multiple users found with key ${keys}`);
-    return res[0];
+    await sendRequired<typeof changeUsernameReqZ, typeof changeUsernameResZ>(
+      this.client,
+      CHANGE_USERNAME_ENDPOINT,
+      { key, username: newUsername },
+      changeUsernameReqZ,
+      changeUsernameResZ,
+    );
   }
 
-  async retrieveByName(username: string): Promise<User>;
-
-  async retrieveByName(usernames: string[]): Promise<User[]>;
-
-  async retrieveByName(usernames: string | string[]): Promise<User | User[]> {
-    const isMany = Array.isArray(usernames);
-    const res = await this.reader.retrieve({ usernames: array.toArray(usernames) });
-    if (isMany) return res;
-    if (res.length === 0)
-      throw new NotFoundError(`No user with username ${usernames} found`);
-    if (res.length > 1)
-      throw new MultipleFoundError(`Multiple users found with username ${usernames}`);
-    return res[0];
+  async retrieve(args: KeyRetrieveRequest): Promise<User>;
+  async retrieve(args: UsernameRetrieveRequest): Promise<User>;
+  async retrieve(args: RetrieveArgs): Promise<User[]>;
+  async retrieve(args: RetrieveArgs): Promise<User | User[]> {
+    const isSingle = "key" in args || "username" in args;
+    const res = await sendRequired<typeof retrieveArgsZ, typeof retrieveResZ>(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      args,
+      retrieveArgsZ,
+      retrieveResZ,
+    );
+
+    if (!isSingle) return res.users;
+
+    if (res.users.length === 0) {
+      const identifier =
+        "key" in args ? `key ${args.key}` : `username ${args.username}`;
+      throw new NotFoundError(`No user with ${identifier} found`);
+    }
+    if (res.users.length > 1) {
+      const identifier =
+        "key" in args ? `key ${args.key}` : `username ${args.username}`;
+      throw new MultipleFoundError(`Multiple users found with ${identifier}`);
+    }
+    return res.users[0];
   }
 
   async rename(key: Key, firstName?: string, lastName?: string): Promise<void> {
-    await this.writer.rename(key, firstName, lastName);
+    await sendRequired<typeof renameReqZ, typeof renameResZ>(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, firstName, lastName },
+      renameReqZ,
+      renameResZ,
+    );
   }
 
   async delete(key: Key): Promise<void>;
-
   async delete(keys: Key[]): Promise<void>;
-
   async delete(keys: Key | Key[]): Promise<void> {
-    await this.writer.delete(keys);
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: array.toArray(keys) },
+      deleteReqZ,
+      deleteResZ,
+    );
   }
 }
 
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+export const ontologyID = (key: Key): ontology.ID => ({ type: "user", key });

package/src/user/payload.ts

@@ -7,9 +7,9 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { z } from "zod/v4";
+import { z } from "zod";
 
-export const keyZ = z.string().uuid();
+export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
 export const userZ = z.object({
@@ -29,6 +29,3 @@ export const newZ = userZ
   .omit({ rootUser: true })
   .extend({ password: z.string().min(1) });
 export interface New extends z.infer<typeof newZ> {}
-
-export const ONTOLOGY_TYPE = "user";
-export type OntologyType = typeof ONTOLOGY_TYPE;

package/src/user/retriever.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import { keyZ, type User, userZ } from "@/user/payload";
 import { nullableArrayZ } from "@/util/zod";

package/src/user/user.spec.ts

@@ -11,7 +11,7 @@ import { id } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { AuthError, NotFoundError } from "@/errors";
-import { newClient } from "@/setupspecs";
+import { createTestClient } from "@/testutil/client";
 import { type user } from "@/user";
 
 interface SortType {
@@ -20,7 +20,7 @@ interface SortType {
 
 const sort = (a: SortType, b: SortType) => a.username.localeCompare(b.username);
 
-const client = newClient();
+const client = createTestClient();
 
 const userOne: user.New = {
   username: id.create(),
@@ -102,22 +102,22 @@ describe("User", () => {
     describe("by name", () => {
       describe("one", () => {
         test("found", async () => {
-          const res = await client.user.retrieveByName(userOne.username);
+          const res = await client.user.retrieve({ username: userOne.username });
           expect(res.username).toEqual(userOne.username);
           expect(res.key).toEqual(userOne.key);
           expect(res.firstName).toEqual(userOne.firstName);
           expect(res.lastName).toEqual(userOne.lastName);
         });
         test("not found", async () =>
-          await expect(client.user.retrieveByName(id.create())).rejects.toThrow(
+          await expect(client.user.retrieve({ username: id.create() })).rejects.toThrow(
             NotFoundError,
           ));
       });
       describe("many", () => {
         test("found", async () => {
-          const res = await client.user.retrieveByName(
-            userArray.map((u) => u.username),
-          );
+          const res = await client.user.retrieve({
+            usernames: userArray.map((u) => u.username),
+          });
           expect(res.sort(sort)).toHaveLength(2);
           res.forEach((u, i) => {
             expect(u.username).toEqual(userArray[i].username);
@@ -127,14 +127,13 @@ describe("User", () => {
           });
         });
         test("not found", async () => {
-          const res = await client.user.retrieveByName([id.create()]);
+          const res = await client.user.retrieve({ usernames: [id.create()] });
           expect(res).toEqual([]);
         });
         test("extra names getting deleted", async () => {
-          const res = await client.user.retrieveByName([
-            ...userArray.map((u) => u.username),
-            id.create(),
-          ]);
+          const res = await client.user.retrieve({
+            usernames: [...userArray.map((u) => u.username), id.create()],
+          });
           expect(res.sort(sort)).toHaveLength(2);
           res.forEach((u, i) => {
             expect(u.username).toEqual(userArray[i].username);
@@ -144,7 +143,7 @@ describe("User", () => {
           });
         });
         test("calling with no names", async () => {
-          const res = await client.user.retrieveByName([]);
+          const res = await client.user.retrieve({ usernames: [] });
           const usernames = res.map((u) => u.username);
           expect(usernames).toContain(userOne.username);
           expect(usernames).toContain(userTwo.username);
@@ -156,7 +155,7 @@ describe("User", () => {
     describe("by key", () => {
       describe("one", () => {
         test("found", async () => {
-          const res = await client.user.retrieve(userOne.key as string);
+          const res = await client.user.retrieve({ key: userOne.key as string });
           expect(res.username).toEqual(userOne.username);
           expect(res.key).toEqual(userOne.key);
           expect(res.firstName).toEqual(userOne.firstName);
@@ -166,16 +165,18 @@ describe("User", () => {
           await expect(
             client.user.delete(userOne.key as string),
           ).resolves.toBeUndefined();
-          await expect(client.user.retrieve(userOne.key as string)).rejects.toThrow(
-            NotFoundError,
-          );
+          await expect(
+            client.user.retrieve({ key: userOne.key as string }),
+          ).rejects.toThrow(NotFoundError);
           const u = await client.user.create(userOne);
           userOne.key = u.key;
         });
       });
       describe("many", () => {
         test("found", async () => {
-          const res = await client.user.retrieve(userArray.map((u) => u.key as string));
+          const res = await client.user.retrieve({
+            keys: userArray.map((u) => u.key as string),
+          });
           expect(res.sort(sort)).toHaveLength(2);
           res.forEach((u, i) => {
             expect(u.username).toEqual(userArray[i].username);
@@ -188,14 +189,13 @@ describe("User", () => {
           for (const u of userArray)
             await expect(client.user.delete(u.key as string)).resolves.toBeUndefined();
           await expect(
-            client.user.retrieve(userArray.map((u) => u.key as string)),
+            client.user.retrieve({ keys: userArray.map((u) => u.key as string) }),
           ).rejects.toThrow(NotFoundError);
-          // cleanup
           const users = await client.user.create(userArray);
           users.forEach((u, i) => (userArray[i].key = u.key));
         });
         test("all", async () => {
-          const res = await client.user.retrieve([]);
+          const res = await client.user.retrieve({ keys: [] });
           const usernames = res.map((u) => u.username);
           expect(usernames).toContain(userOne.username);
           expect(usernames).toContain(userTwo.username);
@@ -211,7 +211,7 @@ describe("User", () => {
       await expect(
         client.user.changeUsername(userOne.key as string, newUsername),
       ).resolves.toBeUndefined();
-      const res = await client.user.retrieveByName(newUsername);
+      const res = await client.user.retrieve({ username: newUsername });
       expect(res.username).toEqual(newUsername);
       expect(res.key).not.toEqual("");
       expect(res.firstName).toEqual(userOne.firstName);
@@ -240,7 +240,7 @@ describe("User", () => {
       await expect(
         client.user.rename(userOne.key as string, "Thomas", "Jefferson"),
       ).resolves.toBeUndefined();
-      const res = await client.user.retrieve(userOne.key as string);
+      const res = await client.user.retrieve({ key: userOne.key as string });
       expect(res.username).toEqual(userOne.username);
       expect(res.key).toEqual(userOne.key);
       expect(res.firstName).toEqual("Thomas");
@@ -252,7 +252,7 @@ describe("User", () => {
       await expect(
         client.user.rename(userOne.key as string, "James"),
       ).resolves.toBeUndefined();
-      const res = await client.user.retrieve(userOne.key as string);
+      const res = await client.user.retrieve({ key: userOne.key as string });
       expect(res.username).toEqual(userOne.username);
       expect(res.key).toEqual(userOne.key);
       expect(res.firstName).toEqual("James");
@@ -263,16 +263,16 @@ describe("User", () => {
   describe("Delete", () => {
     test("one that exists", async () => {
       await expect(client.user.delete(userOne.key as string)).resolves.toBeUndefined();
-      await expect(client.user.retrieve(userOne.key as string)).rejects.toThrow(
-        NotFoundError,
-      );
+      await expect(
+        client.user.retrieve({ key: userOne.key as string }),
+      ).rejects.toThrow(NotFoundError);
     });
     test("many that exist", async () => {
       await expect(
         client.user.delete(userArray.map((u) => u.key as string)),
       ).resolves.toBeUndefined();
       await expect(
-        client.user.retrieve(userArray.map((u) => u.key as string)),
+        client.user.retrieve({ keys: userArray.map((u) => u.key as string) }),
       ).rejects.toThrow(NotFoundError);
     });
     test("one that doesn't exist", async () => {
@@ -282,9 +282,9 @@ describe("User", () => {
       await expect(
         client.user.delete([userOne.key as string, userTwo.key as string]),
       ).resolves.toBeUndefined();
-      await expect(client.user.retrieve(userTwo.key as string)).rejects.toThrow(
-        NotFoundError,
-      );
+      await expect(
+        client.user.retrieve({ key: userTwo.key as string }),
+      ).rejects.toThrow(NotFoundError);
     });
   });
 });

package/src/user/writer.ts

@@ -9,7 +9,7 @@
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x/array";
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import { type Key, keyZ, type New, newZ, type User, userZ } from "@/user/payload";
 

package/src/util/decodeJSONString.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { binary, type UnknownRecord, unknownRecordZ } from "@synnaxlabs/x";
+import { binary, record } from "@synnaxlabs/x";
 
-export const decodeJSONString = (s: string): UnknownRecord =>
-  s ? binary.JSON_CODEC.decodeString(s, unknownRecordZ) : {};
+export const decodeJSONString = (s: string): record.Unknown =>
+  s ? binary.JSON_CODEC.decodeString(s, record.unknownZ) : {};