@synnaxlabs/client 0.49.3 → 0.52.3

package/src/device/client.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -8,10 +8,18 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, type record } from "@synnaxlabs/x";
+import { array, type record, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { type Device, deviceZ, type Key, keyZ, type New, newZ } from "@/device/payload";
+import {
+  type Device,
+  type DeviceSchemas,
+  deviceZ,
+  type Key,
+  keyZ,
+  type New,
+  newZ,
+} from "@/device/payload";
 import { ontology } from "@/ontology";
 import { keyZ as rackKeyZ } from "@/rack/payload";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
@@ -19,8 +27,21 @@ import { checkForMultipleOrNoResults } from "@/util/retrieve";
 export const SET_CHANNEL_NAME = "sy_device_set";
 export const DELETE_CHANNEL_NAME = "sy_device_delete";
 
-const createReqZ = z.object({ devices: newZ.array() });
-const createResZ = z.object({ devices: deviceZ.array() });
+const createReqZ = <
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+>(
+  schemas?: DeviceSchemas<Properties, Make, Model>,
+) => z.object({ devices: zod.toArray(newZ(schemas)) });
+
+const createResZ = <
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+>(
+  schemas?: DeviceSchemas<Properties, Make, Model>,
+) => z.object({ devices: deviceZ(schemas).array() });
 
 const deleteReqZ = z.object({ keys: keyZ.array() });
 const deleteResZ = z.object({});
@@ -37,7 +58,14 @@ const retrieveRequestZ = z.object({
   offset: z.int().optional(),
   includeStatus: z.boolean().optional(),
 });
-const retrieveResZ = z.object({ devices: array.nullableZ(deviceZ) });
+
+const retrieveResZ = <
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+>(
+  schemas?: DeviceSchemas<Properties, Make, Model>,
+) => z.object({ devices: array.nullableZ(deviceZ(schemas)) });
 
 const singleRetrieveArgsZ = z
   .object({
@@ -56,6 +84,12 @@ const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveRequestZ]);
 
 export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 
+type RetrieveSchemas<
+  Properties extends z.ZodType<record.Unknown>,
+  Make extends z.ZodType<string>,
+  Model extends z.ZodType<string>,
+> = { schemas: DeviceSchemas<Properties, Make, Model> };
+
 export class Client {
   private readonly client: UnaryClient;
 
@@ -64,64 +98,76 @@ export class Client {
   }
 
   async retrieve<
-    Properties extends record.Unknown = record.Unknown,
-    Make extends string = string,
-    Model extends string = string,
-  >(args: RetrieveSingleParams): Promise<Device<Properties, Make, Model>>;
+    Properties extends z.ZodType<record.Unknown>,
+    Make extends z.ZodType<string>,
+    Model extends z.ZodType<string>,
+  >(
+    args: RetrieveSingleParams & RetrieveSchemas<Properties, Make, Model>,
+  ): Promise<Device<Properties, Make, Model>>;
 
-  async retrieve<
-    Properties extends record.Unknown = record.Unknown,
-    Make extends string = string,
-    Model extends string = string,
-  >(args: RetrieveMultipleParams): Promise<Array<Device<Properties, Make, Model>>>;
+  async retrieve(args: RetrieveSingleParams): Promise<Device>;
 
   async retrieve<
-    Properties extends record.Unknown = record.Unknown,
-    Make extends string = string,
-    Model extends string = string,
+    Properties extends z.ZodType<record.Unknown>,
+    Make extends z.ZodType<string>,
+    Model extends z.ZodType<string>,
   >(
-    args: RetrieveArgs,
-  ): Promise<Device<Properties, Make, Model> | Array<Device<Properties, Make, Model>>> {
-    const isSingle = typeof args === "object" && "key" in args;
+    args: RetrieveMultipleParams & RetrieveSchemas<Properties, Make, Model>,
+  ): Promise<Array<Device<Properties, Make, Model>>>;
+
+  async retrieve(args: RetrieveMultipleParams): Promise<Array<Device>>;
+
+  async retrieve(
+    args: RetrieveArgs & { schemas?: DeviceSchemas },
+  ): Promise<Device | Array<Device>> {
+    const { schemas, ...rest } = args as RetrieveArgs & { schemas?: DeviceSchemas };
+    const isSingle = typeof rest === "object" && "key" in rest;
     const res = await sendRequired(
       this.client,
       "/device/retrieve",
-      args,
+      rest,
       retrieveArgsZ,
-      retrieveResZ,
+      retrieveResZ(schemas),
     );
-    checkForMultipleOrNoResults("Device", args, res.devices, isSingle);
-    const devices = res.devices as Device<Properties, Make, Model>[];
-    return isSingle ? devices[0] : devices;
+    checkForMultipleOrNoResults("Device", rest, res.devices, isSingle);
+    return isSingle ? res.devices[0] : res.devices;
   }
 
   async create<
-    Properties extends record.Unknown = record.Unknown,
-    Make extends string = string,
-    Model extends string = string,
-  >(device: New<Properties, Make>): Promise<Device<Properties, Make, Model>>;
-  async create<
-    Properties extends record.Unknown = record.Unknown,
-    Make extends string = string,
-    Model extends string = string,
-  >(devices: New<Properties, Make>[]): Promise<Device<Properties, Make, Model>[]>;
+    Properties extends z.ZodType<record.Unknown>,
+    Make extends z.ZodType<string>,
+    Model extends z.ZodType<string>,
+  >(
+    device: New<Properties, Make, Model>,
+    schemas: DeviceSchemas<Properties, Make, Model>,
+  ): Promise<Device<Properties, Make, Model>>;
+
+  async create(device: New): Promise<Device>;
+
   async create<
-    Properties extends record.Unknown = record.Unknown,
-    Make extends string = string,
-    Model extends string = string,
+    Properties extends z.ZodType<record.Unknown>,
+    Make extends z.ZodType<string>,
+    Model extends z.ZodType<string>,
   >(
-    devices: New<Properties, Make> | New<Properties, Make>[],
-  ): Promise<Device<Properties, Make, Model> | Device<Properties, Make, Model>[]> {
+    devices: New<Properties, Make, Model>[],
+    schemas: DeviceSchemas<Properties, Make, Model>,
+  ): Promise<Device<Properties, Make, Model>[]>;
+
+  async create(devices: New[]): Promise<Device[]>;
+
+  async create(
+    devices: New | New[],
+    schemas?: DeviceSchemas,
+  ): Promise<Device | Device[]> {
     const isSingle = !Array.isArray(devices);
     const res = await sendRequired(
       this.client,
       "/device/create",
       { devices: array.toArray(devices) },
-      createReqZ,
-      createResZ,
+      createReqZ(schemas),
+      createResZ(schemas),
     );
-    const created = res.devices as Device<Properties, Make, Model>[];
-    return isSingle ? created[0] : created;
+    return isSingle ? res.devices[0] : res.devices;
   }
 
   async delete(keys: Key | Key[]): Promise<void> {

package/src/device/device.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/device/external.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/device/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/device/payload.spec.ts

@@ -0,0 +1,118 @@
+// 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.
+
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+
+import { deviceZ, newZ } from "@/device/payload";
+
+const VALID_DEVICE = {
+  key: "dev-1",
+  rack: 1,
+  name: "Test Device",
+  make: "ni",
+  model: "pxi-6281",
+  location: "Lab1",
+  properties: { rate: 10 },
+  status: null,
+};
+
+describe("deviceZ", () => {
+  describe("default schemas", () => {
+    it("should accept a valid device", () => {
+      const result = deviceZ().safeParse(VALID_DEVICE);
+      expect(result.success).toBe(true);
+    });
+
+    it("should reject a device with an empty name", () => {
+      const result = deviceZ().safeParse({ ...VALID_DEVICE, name: "" });
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject a device with an empty make", () => {
+      const result = deviceZ().safeParse({ ...VALID_DEVICE, make: "" });
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject a device with an empty model", () => {
+      const result = deviceZ().safeParse({ ...VALID_DEVICE, model: "" });
+      expect(result.success).toBe(false);
+    });
+
+    it("should accept properties as an object", () => {
+      const result = deviceZ().parse(VALID_DEVICE);
+      expect(result.properties).toEqual({ rate: 10 });
+    });
+  });
+
+  describe("custom make schema", () => {
+    const makeZ = z.enum(["ni", "labjack"]);
+
+    it("should accept a valid make value", () => {
+      const result = deviceZ({ make: makeZ }).safeParse(VALID_DEVICE);
+      expect(result.success).toBe(true);
+    });
+
+    it("should reject an invalid make value", () => {
+      const result = deviceZ({ make: makeZ }).safeParse({
+        ...VALID_DEVICE,
+        make: "unknown",
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("custom model schema", () => {
+    const modelZ = z.literal("pxi-6281");
+
+    it("should accept a matching model", () => {
+      const result = deviceZ({ model: modelZ }).safeParse(VALID_DEVICE);
+      expect(result.success).toBe(true);
+    });
+
+    it("should reject a non-matching model", () => {
+      const result = deviceZ({ model: modelZ }).safeParse({
+        ...VALID_DEVICE,
+        model: "t7",
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("custom properties schema", () => {
+    const propertiesZ = z.object({ rate: z.number(), channel: z.string() });
+
+    it("should validate properties against the custom schema", () => {
+      const result = deviceZ({ properties: propertiesZ }).safeParse({
+        ...VALID_DEVICE,
+        properties: { rate: 10, channel: "ai0" },
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("should reject properties that don't match the custom schema", () => {
+      expect(() => deviceZ({ properties: propertiesZ }).parse(VALID_DEVICE)).toThrow();
+    });
+  });
+});
+
+describe("newZ", () => {
+  it("should encode properties to a JSON string", () => {
+    const result = newZ().parse(VALID_DEVICE);
+    expect(result.properties).toEqual(VALID_DEVICE.properties);
+  });
+
+  it("should still validate make and model with custom schemas", () => {
+    const makeZ = z.literal("ni");
+    const result = newZ({ make: makeZ }).safeParse(VALID_DEVICE);
+    expect(result.success).toBe(true);
+    const bad = newZ({ make: makeZ }).safeParse({ ...VALID_DEVICE, make: "opc" });
+    expect(bad.success).toBe(false);
+  });
+});

package/src/device/payload.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,11 +7,10 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { binary, record, status, zod } from "@synnaxlabs/x";
+import { record, status, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { keyZ as rackKeyZ } from "@/rack/payload";
-import { decodeJSONString } from "@/util/decodeJSONString";
 
 export const keyZ = z.string();
 export type Key = z.infer<typeof keyZ>;
@@ -21,38 +20,64 @@ export const statusZ = status.statusZ(statusDetailsZ);
 
 export interface Status extends z.infer<typeof statusZ> {}
 
-export const deviceZ = z.object({
-  key: keyZ,
-  rack: rackKeyZ.min(1, "Must select a location to connect from"),
-  name: z.string().min(1, "Name is required"),
-  make: z.string().min(1, "Make is required"),
-  model: z.string().min(1, "Model is required"),
-  location: z.string().min(1, "Location is required"),
-  configured: z.boolean().optional(),
-  properties: record.unknownZ.or(z.string().transform(decodeJSONString)),
-  status: zod.nullToUndefined(statusZ),
-});
+export interface DeviceSchemas<
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+> {
+  properties?: Properties;
+  make?: Make;
+  model?: Model;
+}
+
+export const deviceZ = <
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+>({ properties, make, model }: DeviceSchemas<Properties, Make, Model> = {}) =>
+  z.object({
+    key: keyZ,
+    rack: rackKeyZ.min(1, "Must select a location to connect from"),
+    name: z.string().min(1, "Name is required"),
+    make: make ?? z.string().min(1, "Make is required"),
+    model: model ?? z.string().min(1, "Model is required"),
+    location: z.string().min(1, "Location is required"),
+    configured: z.boolean().optional(),
+    properties: properties ?? record.nullishToEmpty(),
+    status: zod.nullToUndefined(statusZ),
+  });
 
 export interface Device<
-  Properties extends record.Unknown = record.Unknown,
-  Make extends string = string,
-  Model extends string = string,
-> extends Omit<z.infer<typeof deviceZ>, "properties" | "status"> {
-  properties: Properties;
-  make: Make;
-  model: Model;
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+> extends Omit<
+  z.infer<ReturnType<typeof deviceZ>>,
+  "properties" | "make" | "model" | "status"
+> {
+  properties: z.infer<Properties>;
+  make: z.infer<Make>;
+  model: z.infer<Model>;
   status?: Status;
 }
 
-export const newZ = deviceZ.extend({
-  properties: z.unknown().transform((c) => binary.JSON_CODEC.encodeString(c)),
-});
+export const newZ = <
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+>(
+  schemas: DeviceSchemas<Properties, Make, Model> = {},
+) =>
+  deviceZ(schemas).extend({
+    properties: schemas?.properties ?? record.nullishToEmpty(),
+  });
+
 export interface New<
-  Properties extends record.Unknown = record.Unknown,
-  Make extends string = string,
-  Model extends string = string,
-> extends Omit<z.input<typeof newZ>, "properties"> {
-  properties: Properties;
-  make: Make;
-  model: Model;
+  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+> extends Omit<z.input<ReturnType<typeof newZ>>, "properties"> {
+  properties: z.infer<Properties>;
+  make: z.infer<Make>;
+  model: z.infer<Model>;
 }

package/src/errors.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -64,7 +64,7 @@ test("client", async () => {
     expect(NotFoundError.matches(e)).toBe(true);
   }
   try {
-    await client.workspaces.schematics.retrieve({ key: uuid.create() });
+    await client.schematics.retrieve({ key: uuid.create() });
   } catch (e) {
     expect(NotFoundError.matches(e)).toBe(true);
   }

package/src/errors.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/adapter.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/adapter.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -15,7 +15,7 @@ import { Codec } from "@/framer/codec";
 import { type CrudeFrame, Frame } from "@/framer/frame";
 
 export class ReadAdapter {
-  private adapter: Map<channel.Key, channel.Name> | null;
+  private adapter: Map<channel.Key, string> | null;
   retriever: channel.Retriever;
   keys: Set<channel.Key>;
   codec: Codec;
@@ -54,7 +54,7 @@ export class ReadAdapter {
       this.keys = new Set(normalized as channel.Key[]);
       return true;
     }
-    const a = new Map<channel.Key, channel.Name>();
+    const a = new Map<channel.Key, string>();
     this.adapter = a;
     normalized.forEach((name) => {
       const channel = fetched.find((channel) => channel.name === name);
@@ -87,7 +87,7 @@ export class ReadAdapter {
 }
 
 export class WriteAdapter {
-  private adapter: Map<channel.Name, channel.Key> | null;
+  private adapter: Map<string, channel.Key> | null;
   retriever: channel.Retriever;
   keys: channel.Key[];
   codec: Codec;
@@ -125,9 +125,7 @@ export class WriteAdapter {
     const hasRemovedKeys = !previousKeySet.isSubsetOf(newKeySet);
     const hasChanged = hasAddedKeys || hasRemovedKeys;
     if (!hasChanged) return false;
-    this.adapter = new Map<channel.Name, channel.Key>(
-      results.map((c) => [c.name, c.key]),
-    );
+    this.adapter = new Map<string, channel.Key>(results.map((c) => [c.name, c.key]));
     this.keys = newKeys;
     this.codec.update(
       this.keys,
@@ -137,7 +135,7 @@ export class WriteAdapter {
   }
 
   private async fetchChannel(
-    ch: channel.Key | channel.Name | channel.Payload,
+    ch: channel.KeyOrName | channel.Payload,
   ): Promise<channel.Payload> {
     const res = await this.retriever.retrieve(ch);
     if (res.length === 0) throw new Error(`Channel ${JSON.stringify(ch)} not found`);

package/src/framer/client.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/client.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/codec.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/codec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/deleter.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/deleter.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/external.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/frame.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/frame.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -95,7 +95,7 @@ export type CrudeFrame =
  * and array can be square.
  */
 export class Frame {
-  readonly columns: channel.Keys | channel.Names = [];
+  readonly columns: channel.KeysOrNames = [];
   readonly series: Series[] = [];
 
   constructor(
@@ -140,7 +140,7 @@ export class Frame {
       ["string", "number"].includes(typeof columnsOrData)
     ) {
       const data_ = array.toArray(series);
-      const cols = array.toArray(columnsOrData) as channel.Keys | channel.Names;
+      const cols = array.toArray(columnsOrData) as channel.KeysOrNames;
       validateMatchedColsAndSeries(cols, data_);
       data_.forEach((d, i) => this.push(cols[i], d));
       return;
@@ -184,23 +184,23 @@ export class Frame {
    * @returns the channel names if the frame is keyed by channel name, and throws an error
    * otherwise.
    */
-  get names(): channel.Names {
+  get names(): string[] {
     if (this.colType === "key") throw new UnexpectedError("colType is not name");
-    return (this.columns as channel.Names) ?? [];
+    return (this.columns as string[]) ?? [];
   }
 
   /**
    * @returns the unique channel names if the frame is keyed by channel name, and throws an
    * otherwise.
    */
-  get uniqueNames(): channel.Names {
+  get uniqueNames(): string[] {
     return unique.unique(this.names);
   }
 
   /**
    * @returns the unique columns in the frame.
    */
-  get uniqueColumns(): channel.Keys | channel.Names {
+  get uniqueColumns(): channel.KeysOrNames {
     return this.colType === "key" ? this.uniqueKeys : this.uniqueNames;
   }
 
@@ -280,9 +280,9 @@ export class Frame {
    * @returns a frame with the given channel keys or names.
    * @param keys the channel keys or names.
    */
-  get(keys: channel.Keys | channel.Names): Frame;
+  get(keys: channel.KeysOrNames): Frame;
 
-  get(key: channel.KeyOrName | channel.Keys | channel.Names): MultiSeries | Frame {
+  get(key: channel.PrimitiveParams): MultiSeries | Frame {
     if (Array.isArray(key))
       return this.filter((k) => (key as channel.Keys).includes(k as channel.Key));
     return new MultiSeries(this.series.filter((_, i) => this.columns[i] === key));

package/src/framer/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/iterator.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 Synnax Labs, Inc.
+// Copyright 2026 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.