@synnaxlabs/client 0.44.3 → 0.45.0

package/dist/workspace/schematic/symbol/client.d.ts

@@ -0,0 +1,57 @@
+import { UnaryClient } from '@synnaxlabs/freighter';
+import { z } from 'zod';
+import { ontology } from '../../../ontology';
+import { group } from '../../../ontology/group';
+import { Key, New, Symbol } from './payload';
+declare const retrieveRequestZ: z.ZodObject<{
+    keys: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    searchTerm: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const singleRetrieveArgsZ: z.ZodPipe<z.ZodObject<{
+    key: z.ZodUUID;
+}, z.core.$strip>, z.ZodTransform<{
+    keys: string[];
+}, {
+    key: string;
+}>>;
+declare const retrieveArgsZ: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+    key: z.ZodUUID;
+}, z.core.$strip>, z.ZodTransform<{
+    keys: string[];
+}, {
+    key: string;
+}>>, z.ZodObject<{
+    keys: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    searchTerm: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
+export type SingleRetrieveArgs = z.input<typeof singleRetrieveArgsZ>;
+export type MultiRetrieveArgs = z.input<typeof retrieveRequestZ>;
+export declare const SET_CHANNEL_NAME = "sy_schematic_symbol_set";
+export declare const DELETE_CHANNEL_NAME = "sy_schematic_symbol_delete";
+export interface CreateArgs extends New {
+    parent: ontology.ID;
+}
+export interface CreateMultipleArgs {
+    symbols: New[];
+    parent: ontology.ID;
+}
+export declare class Client {
+    private readonly client;
+    constructor(client: UnaryClient);
+    create(options: CreateArgs): Promise<Symbol>;
+    create(options: CreateMultipleArgs): Promise<Symbol[]>;
+    rename(key: Key, name: string): Promise<void>;
+    retrieve(args: SingleRetrieveArgs): Promise<Symbol>;
+    retrieve(args: MultiRetrieveArgs): Promise<Symbol[]>;
+    delete(key: Key): Promise<void>;
+    delete(keys: Key[]): Promise<void>;
+    retrieveGroup(): Promise<group.Payload>;
+}
+export declare const ontologyID: (key: Key) => ontology.ID;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/workspace/schematic/symbol/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/workspace/schematic/symbol/client.ts"],"names":[],"mappings":"AASA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,OAAO,EACL,KAAK,GAAG,EAER,KAAK,GAAG,EAER,KAAK,MAAM,EAEZ,MAAM,sCAAsC,CAAC;AAY9C,QAAA,MAAM,gBAAgB;;;;;iBAKpB,CAAC;AAEH,QAAA,MAAM,mBAAmB;;;;;;GAEmB,CAAC;AAE7C,QAAA,MAAM,aAAa;;;;;;;;;;;mBAAmD,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACzD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAQjE,eAAO,MAAM,gBAAgB,4BAA4B,CAAC;AAC1D,eAAO,MAAM,mBAAmB,+BAA+B,CAAC;AAEhE,MAAM,WAAW,UAAW,SAAQ,GAAG;IACrC,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC;CACrB;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAC5C,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IActD,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU7C,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAcpD,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAC/B,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWlC,aAAa,IAAI,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;CAU9C;AAED,eAAO,MAAM,UAAU,GAAI,KAAK,GAAG,KAAG,QAAQ,CAAC,EAG7C,CAAC"}

package/dist/workspace/schematic/symbol/client.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.spec.d.ts.map

package/dist/workspace/schematic/symbol/client.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.spec.d.ts","sourceRoot":"","sources":["../../../../src/workspace/schematic/symbol/client.spec.ts"],"names":[],"mappings":""}

package/dist/workspace/schematic/symbol/external.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './payload';
+//# sourceMappingURL=external.d.ts.map

package/dist/workspace/schematic/symbol/external.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../../src/workspace/schematic/symbol/external.ts"],"names":[],"mappings":"AASA,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC"}

package/dist/workspace/schematic/symbol/index.d.ts

@@ -0,0 +1,2 @@
+export * as symbol from './external';
+//# sourceMappingURL=index.d.ts.map

package/dist/workspace/schematic/symbol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/workspace/schematic/symbol/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,MAAM,MAAM,uCAAuC,CAAC"}

package/dist/workspace/schematic/symbol/payload.d.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+export declare const keyZ: z.ZodUUID;
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+export declare const regionZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    selectors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    strokeColor: z.ZodOptional<z.ZodString>;
+    fillColor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface Region extends z.infer<typeof regionZ> {
+}
+export declare const stateZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    regions: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        selectors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        strokeColor: z.ZodOptional<z.ZodString>;
+        fillColor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface State extends z.infer<typeof stateZ> {
+}
+export declare const handleZ: z.ZodObject<{
+    key: z.ZodString;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    orientation: z.ZodEnum<{
+        top: "top";
+        right: "right";
+        bottom: "bottom";
+        left: "left";
+    }>;
+}, z.core.$strip>;
+export interface Handle extends z.infer<typeof handleZ> {
+}
+export declare const specZ: z.ZodObject<{
+    svg: z.ZodString;
+    states: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        regions: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            selectors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            strokeColor: z.ZodOptional<z.ZodString>;
+            fillColor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    variant: z.ZodString;
+    handles: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        orientation: z.ZodEnum<{
+            top: "top";
+            right: "right";
+            bottom: "bottom";
+            left: "left";
+        }>;
+    }, z.core.$strip>>;
+    scale: z.ZodDefault<z.ZodNumber>;
+    scaleStroke: z.ZodDefault<z.ZodBoolean>;
+    previewViewport: z.ZodDefault<z.ZodObject<{
+        zoom: z.ZodDefault<z.ZodNumber>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface Spec extends z.infer<typeof specZ> {
+}
+export declare const symbolZ: z.ZodObject<{
+    key: z.ZodUUID;
+    version: z.ZodDefault<z.ZodOptional<z.ZodLiteral<1>>>;
+    name: z.ZodString;
+    data: z.ZodObject<{
+        svg: z.ZodString;
+        states: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            regions: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                selectors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                strokeColor: z.ZodOptional<z.ZodString>;
+                fillColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        variant: z.ZodString;
+        handles: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+            orientation: z.ZodEnum<{
+                top: "top";
+                right: "right";
+                bottom: "bottom";
+                left: "left";
+            }>;
+        }, z.core.$strip>>;
+        scale: z.ZodDefault<z.ZodNumber>;
+        scaleStroke: z.ZodDefault<z.ZodBoolean>;
+        previewViewport: z.ZodDefault<z.ZodObject<{
+            zoom: z.ZodDefault<z.ZodNumber>;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const newZ: z.ZodObject<{
+    key: z.ZodOptional<z.ZodUUID>;
+    version: z.ZodDefault<z.ZodOptional<z.ZodLiteral<1>>>;
+    name: z.ZodString;
+    data: z.ZodObject<{
+        svg: z.ZodString;
+        states: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            regions: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                selectors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                strokeColor: z.ZodOptional<z.ZodString>;
+                fillColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        variant: z.ZodString;
+        handles: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+            orientation: z.ZodEnum<{
+                top: "top";
+                right: "right";
+                bottom: "bottom";
+                left: "left";
+            }>;
+        }, z.core.$strip>>;
+        scale: z.ZodDefault<z.ZodNumber>;
+        scaleStroke: z.ZodDefault<z.ZodBoolean>;
+        previewViewport: z.ZodDefault<z.ZodObject<{
+            zoom: z.ZodDefault<z.ZodNumber>;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export interface New extends z.input<typeof newZ> {
+}
+export interface Symbol extends z.infer<typeof symbolZ> {
+}
+//# sourceMappingURL=payload.d.ts.map

package/dist/workspace/schematic/symbol/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../../src/workspace/schematic/symbol/payload.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,IAAI,WAAW,CAAC;AAC7B,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AACvC,MAAM,MAAM,MAAM,GAAG,GAAG,GAAG,GAAG,EAAE,CAAC;AAEjC,eAAO,MAAM,OAAO;;;;;;iBAMlB,CAAC;AAEH,MAAM,WAAW,MAAO,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;CAAG;AAE1D,eAAO,MAAM,MAAM;;;;;;;;;;iBAIjB,CAAC;AAEH,MAAM,WAAW,KAAM,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC;CAAG;AAExD,eAAO,MAAM,OAAO;;;;;;;;;;;;iBAIlB,CAAC;AAEH,MAAM,WAAW,MAAO,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;CAAG;AAO1D,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQhB,CAAC;AAEH,MAAM,WAAW,IAAK,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;CAAG;AAEtD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKlB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAiC,CAAC;AACnD,MAAM,WAAW,GAAI,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC;CAAG;AAEpD,MAAM,WAAW,MAAO,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;CAAG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/client",
-  "version": "0.44.3",
+  "version": "0.45.0",
   "description": "The Synnax Client Library",
   "keywords": [
     "synnax",
@@ -26,8 +26,8 @@
   "dependencies": {
     "async-mutex": "^0.5.0",
     "zod": "^4.0.2",
-    "@synnaxlabs/x": "^0.44.3",
-    "@synnaxlabs/freighter": "^0.44.1"
+    "@synnaxlabs/freighter": "^0.45.0",
+    "@synnaxlabs/x": "^0.45.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^3.2.4",

package/src/channel/client.ts

@@ -22,6 +22,7 @@ import { z } from "zod";
 import {
   type Key,
   type KeyOrName,
+  keyZ,
   type Name,
   type New,
   type Params,
@@ -135,21 +136,22 @@ export class Channel {
     expression = "",
     requires = [],
   }: New & {
+    internal?: boolean;
     frameClient?: framer.Client;
     density?: CrudeDensity;
     status?: status.Crude;
   }) {
-    this.key = key;
+    this.key = keyZ.parse(key);
     this.name = name;
     this.dataType = new DataType(dataType);
     this.leaseholder = leaseholder;
-    this.index = index;
+    this.index = keyZ.parse(index);
     this.isIndex = isIndex;
     this.internal = internal;
     this.alias = alias;
     this.virtual = virtual;
     this.expression = expression;
-    this.requires = requires ?? [];
+    this.requires = keyZ.array().parse(requires ?? []);
     if (argsStatus != null) this.status = status.create(argsStatus);
     this._frameClient = frameClient ?? null;
   }

package/src/channel/payload.ts

@@ -12,7 +12,14 @@ import { z } from "zod";
 
 import { nullableArrayZ } from "@/util/zod";
 
-export const keyZ = z.number();
+const errorMessage = "Channel key must be a valid uint32.";
+export const keyZ = z.uint32().or(
+  z
+    .string()
+    .refine((val) => !isNaN(Number(val)), { message: errorMessage })
+    .transform(Number)
+    .refine((val) => val < 2 ** 32 - 1, { message: errorMessage }),
+);
 export type Key = z.infer<typeof keyZ>;
 export type Keys = Key[];
 export const nameZ = z.string();
@@ -51,7 +58,8 @@ export const newZ = payloadZ.extend({
   requires: nullableArrayZ(keyZ).optional().default([]),
 });
 
-export interface New extends Omit<z.input<typeof newZ>, "dataType" | "status"> {
+export interface New
+  extends Omit<z.input<typeof newZ>, "dataType" | "status" | "internal"> {
   dataType: CrudeDataType;
 }
 

package/src/channel/writer.ts

@@ -71,6 +71,7 @@ export class Writer {
   }
 
   async delete(props: DeleteProps): Promise<void> {
+    const keys = keyZ.array().parse(props.keys ?? []);
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
       DELETE_ENDPOINT,
@@ -78,7 +79,7 @@ export class Writer {
       deleteReqZ,
       deleteResZ,
     );
-    if (props.keys != null) this.cache.delete(props.keys);
+    if (keys.length > 0) this.cache.delete(keys);
     if (props.names != null) this.cache.delete(props.names);
   }
 

package/src/ontology/group/client.ts

@@ -14,6 +14,9 @@ import { Group } from "@/ontology/group/group";
 import { type Key, type Name, type Payload } from "@/ontology/group/payload";
 import { Writer } from "@/ontology/group/writer";
 
+export const SET_CHANNEL_NAME = "sy_group_set";
+export const DELETE_CHANNEL_NAME = "sy_group_delete";
+
 export class Client {
   private readonly creator: Writer;
 

package/src/ontology/payload.ts

@@ -42,6 +42,7 @@ export const resourceTypeZ = z.enum([
   "task",
   "policy",
   "table",
+  "schematic_symbol",
 ]);
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 

package/src/ranger/alias.ts

@@ -23,10 +23,7 @@ const resolveReqZ = z.object({ range: keyZ, aliases: z.string().array() });
 
 const resolveResZ = z.object({ aliases: z.record(z.string(), channel.keyZ) });
 
-const setReqZ = z.object({
-  range: keyZ,
-  aliases: z.record(channel.keyZ.or(z.string()), z.string()),
-});
+const setReqZ = z.object({ range: keyZ, aliases: z.record(channel.keyZ, z.string()) });
 
 const setResZ = z.unknown();
 

package/src/workspace/schematic/client.ts

@@ -24,6 +24,7 @@ import {
   type Schematic,
   schematicZ,
 } from "@/workspace/schematic/payload";
+import { symbol } from "@/workspace/schematic/symbol";
 
 const RETRIEVE_ENDPOINT = "/workspace/schematic/retrieve";
 const CREATE_ENDPOINT = "/workspace/schematic/create";
@@ -45,10 +46,12 @@ const copyResZ = z.object({ schematic: schematicZ });
 const emptyResZ = z.object({});
 
 export class Client {
+  readonly symbols: symbol.Client;
   private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
     this.client = client;
+    this.symbols = new symbol.Client(client);
   }
 
   async create(workspace: WorkspaceKey, schematic: New): Promise<Schematic>;

package/src/workspace/schematic/external.ts

@@ -9,3 +9,4 @@
 
 export * from "@/workspace/schematic/client";
 export * from "@/workspace/schematic/payload";
+export * from "@/workspace/schematic/symbol";

package/src/workspace/schematic/symbol/client.spec.ts

@@ -0,0 +1,133 @@
+// Copyright 2025 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 { beforeAll, describe, expect, it } from "vitest";
+
+import { ontology } from "@/ontology";
+import { type group } from "@/ontology/group";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+describe("Symbol Client", () => {
+  let group: group.Group;
+  beforeAll(async () => {
+    group = await client.ontology.groups.create(ontology.ROOT_ID, "Test Symbols");
+  });
+  describe("create", () => {
+    it("should create a single symbol", async () => {
+      const symbol = await client.workspaces.schematic.symbols.create({
+        name: "Test Symbol",
+        data: {
+          svg: "<svg></svg>",
+          states: [],
+          handles: [],
+          variant: "sensor",
+        },
+        parent: group.ontologyID,
+      });
+      expect(symbol.name).toBe("Test Symbol");
+      expect(symbol.key).toBeDefined();
+    });
+
+    it("should create multiple symbols", async () => {
+      const symbols = await client.workspaces.schematic.symbols.create({
+        symbols: [
+          {
+            name: "Symbol 1",
+            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+          },
+          {
+            name: "Symbol 2",
+            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+          },
+        ],
+        parent: group.ontologyID,
+      });
+      expect(symbols).toHaveLength(2);
+      expect(symbols[0].name).toBe("Symbol 1");
+      expect(symbols[1].name).toBe("Symbol 2");
+    });
+  });
+
+  describe("retrieve", () => {
+    it("should retrieve a single symbol by key", async () => {
+      const created = await client.workspaces.schematic.symbols.create({
+        name: "Retrieve Test",
+        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+        parent: group.ontologyID,
+      });
+
+      const retrieved = await client.workspaces.schematic.symbols.retrieve({
+        key: created.key,
+      });
+      expect(retrieved.key).toBe(created.key);
+      expect(retrieved.name).toBe("Retrieve Test");
+    });
+
+    it("should retrieve multiple symbols by keys", async () => {
+      const created1 = await client.workspaces.schematic.symbols.create({
+        name: "Multi Test 1",
+        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+        parent: group.ontologyID,
+      });
+      const created2 = await client.workspaces.schematic.symbols.create({
+        name: "Multi Test 2",
+        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+        parent: group.ontologyID,
+      });
+
+      const retrieved = await client.workspaces.schematic.symbols.retrieve({
+        keys: [created1.key, created2.key],
+      });
+      expect(retrieved).toHaveLength(2);
+    });
+  });
+
+  describe("rename", () => {
+    it("should rename a symbol", async () => {
+      const symbol = await client.workspaces.schematic.symbols.create({
+        name: "Original Name",
+        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+        parent: group.ontologyID,
+      });
+
+      await client.workspaces.schematic.symbols.rename(symbol.key, "New Name");
+
+      const retrieved = await client.workspaces.schematic.symbols.retrieve({
+        key: symbol.key,
+      });
+      expect(retrieved.name).toBe("New Name");
+    });
+  });
+
+  describe("delete", () => {
+    it("should delete a single symbol", async () => {
+      const symbol = await client.workspaces.schematic.symbols.create({
+        name: "Delete Test",
+        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+        parent: group.ontologyID,
+      });
+
+      await client.workspaces.schematic.symbols.delete(symbol.key);
+
+      await expect(
+        client.workspaces.schematic.symbols.retrieve({ key: symbol.key }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("retrieveGroup", () => {
+    it("should retrieve the symbol group", async () => {
+      const group = await client.workspaces.schematic.symbols.retrieveGroup();
+      expect(group.key).toBeDefined();
+      expect(group.name).toBe("Schematic Symbols");
+    });
+  });
+});