@synnaxlabs/client 0.45.1 → 0.46.0

package/src/workspace/schematic/client.ts

@@ -12,7 +12,7 @@ import { array, type record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type ontology } from "@/ontology";
-import { nullableArrayZ } from "@/util/zod";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { type Key as WorkspaceKey, keyZ as workspaceKeyZ } from "@/workspace/payload";
 import {
   type Key,
@@ -33,15 +33,36 @@ const SET_DATA_ENDPOINT = "/workspace/schematic/set-data";
 const DELETE_ENDPOINT = "/workspace/schematic/delete";
 const COPY_ENDPOINT = "/workspace/schematic/copy";
 
-const retrieveReqZ = z.object({ keys: keyZ.array() });
-const createReqZ = z.object({ workspace: workspaceKeyZ, schematics: newZ.array() });
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
+
 const setDataReqZ = z.object({ key: keyZ, data: z.string() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
-const copyReqZ = z.object({ key: keyZ, name: z.string(), snapshot: z.boolean() });
 
-const retrieveResZ = z.object({ schematics: nullableArrayZ(remoteZ) });
+const copyReqZ = z.object({
+  key: keyZ,
+  name: z.string(),
+  snapshot: z.boolean(),
+});
+
+const retrieveReqZ = z.object({ keys: keyZ.array() });
+const singleRetrieveArgsZ = z
+  .object({ key: keyZ })
+  .transform(({ key }) => ({ keys: [key] }));
+
+export const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveReqZ]);
+export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof retrieveReqZ>;
+export type CopyArgs = z.input<typeof copyReqZ>;
+
+const retrieveResZ = z.object({ schematics: array.nullableZ(remoteZ) });
+
+const createReqZ = z.object({
+  workspace: workspaceKeyZ,
+  schematics: newZ.array(),
+});
 const createResZ = z.object({ schematics: remoteZ.array() });
+
 const copyResZ = z.object({ schematic: schematicZ });
 const emptyResZ = z.object({});
 
@@ -91,22 +112,23 @@ export class Client {
     );
   }
 
-  async retrieve(key: Key): Promise<Schematic>;
-  async retrieve(keys: Key[]): Promise<Schematic[]>;
-  async retrieve(keys: Params): Promise<Schematic | Schematic[]> {
-    const isMany = Array.isArray(keys);
+  async retrieve(args: RetrieveSingleParams): Promise<Schematic>;
+  async retrieve(args: RetrieveMultipleParams): Promise<Schematic[]>;
+  async retrieve(
+    args: RetrieveSingleParams | RetrieveMultipleParams,
+  ): Promise<Schematic | Schematic[]> {
+    const isSingle = singleRetrieveArgsZ.safeParse(args).success;
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
-      { keys: array.toArray(keys) },
-      retrieveReqZ,
+      args,
+      retrieveArgsZ,
       retrieveResZ,
     );
-    return isMany ? res.schematics : res.schematics[0];
+    checkForMultipleOrNoResults("Schematic", args, res.schematics, isSingle);
+    return isSingle ? res.schematics[0] : res.schematics;
   }
 
-  async delete(key: Key): Promise<void>;
-  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
     await sendRequired(
       this.client,
@@ -117,11 +139,11 @@ export class Client {
     );
   }
 
-  async copy(key: Key, name: string, snapshot: boolean): Promise<Schematic> {
+  async copy(args: CopyArgs): Promise<Schematic> {
     const res = await sendRequired(
       this.client,
       COPY_ENDPOINT,
-      { key, name, snapshot },
+      args,
       copyReqZ,
       copyResZ,
     );
@@ -129,4 +151,7 @@ export class Client {
   }
 }
 
-export const ontologyID = (key: Key): ontology.ID => ({ type: "schematic", key });
+export const ontologyID = (key: Key): ontology.ID => ({
+  type: "schematic",
+  key,
+});

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

@@ -10,7 +10,7 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, it, test } from "vitest";
 
-import { ValidationError } from "@/errors";
+import { NotFoundError, ValidationError } from "@/errors";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -22,7 +22,7 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematic.create(ws.key, {
+      const schematic = await client.workspaces.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
@@ -37,12 +37,14 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematic.create(ws.key, {
+      const schematic = await client.workspaces.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.schematic.rename(schematic.key, "Schematic2");
-      const res = await client.workspaces.schematic.retrieve(schematic.key);
+      await client.workspaces.schematics.rename(schematic.key, "Schematic2");
+      const res = await client.workspaces.schematics.retrieve({
+        key: schematic.key,
+      });
       expect(res.name).toEqual("Schematic2");
     });
   });
@@ -52,12 +54,14 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematic.create(ws.key, {
+      const schematic = await client.workspaces.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.schematic.setData(schematic.key, { two: 2 });
-      const res = await client.workspaces.schematic.retrieve(schematic.key);
+      await client.workspaces.schematics.setData(schematic.key, { two: 2 });
+      const res = await client.workspaces.schematics.retrieve({
+        key: schematic.key,
+      });
       expect(res.data.two).toEqual(2);
     });
   });
@@ -67,14 +71,14 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematic.create(ws.key, {
+      const schematic = await client.workspaces.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.schematic.delete(schematic.key);
+      await client.workspaces.schematics.delete(schematic.key);
       await expect(
-        client.workspaces.schematic.retrieve(schematic.key),
-      ).rejects.toThrow();
+        client.workspaces.schematics.retrieve({ key: schematic.key }),
+      ).rejects.toThrow(NotFoundError);
     });
   });
   describe("copy", () => {
@@ -83,15 +87,15 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematic.create(ws.key, {
+      const schematic = await client.workspaces.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      const schematic2 = await client.workspaces.schematic.copy(
-        schematic.key,
-        "Schematic2",
-        false,
-      );
+      const schematic2 = await client.workspaces.schematics.copy({
+        key: schematic.key,
+        name: "Schematic2",
+        snapshot: false,
+      });
       expect(schematic2.name).toEqual("Schematic2");
       expect(schematic2.key).not.toEqual(uuid.ZERO);
       expect(schematic2.data.one).toEqual(1);
@@ -102,17 +106,17 @@ describe("Schematic", () => {
           name: "Schematic",
           layout: { one: 1 },
         });
-        const schematic = await client.workspaces.schematic.create(ws.key, {
+        const schematic = await client.workspaces.schematics.create(ws.key, {
           name: "Schematic",
           data: { one: 1 },
         });
-        const schematic2 = await client.workspaces.schematic.copy(
-          schematic.key,
-          "Schematic2",
-          true,
-        );
+        const schematic2 = await client.workspaces.schematics.copy({
+          key: schematic.key,
+          name: "Schematic2",
+          snapshot: true,
+        });
         await expect(
-          client.workspaces.schematic.setData(schematic2.key, { two: 2 }),
+          client.workspaces.schematics.setData(schematic2.key, { two: 2 }),
         ).rejects.toThrow(ValidationError);
       });
     });

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

@@ -10,19 +10,22 @@
 import { beforeAll, describe, expect, it } from "vitest";
 
 import { ontology } from "@/ontology";
-import { type group } from "@/ontology/group";
+import { group } from "@/ontology/group";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
 
 describe("Symbol Client", () => {
-  let group: group.Group;
+  let symbolGroup: group.Group;
   beforeAll(async () => {
-    group = await client.ontology.groups.create(ontology.ROOT_ID, "Test Symbols");
+    symbolGroup = await client.ontology.groups.create({
+      parent: ontology.ROOT_ID,
+      name: "Test Symbols",
+    });
   });
   describe("create", () => {
     it("should create a single symbol", async () => {
-      const symbol = await client.workspaces.schematic.symbols.create({
+      const symbol = await client.workspaces.schematics.symbols.create({
         name: "Test Symbol",
         data: {
           svg: "<svg></svg>",
@@ -30,14 +33,14 @@ describe("Symbol Client", () => {
           handles: [],
           variant: "sensor",
         },
-        parent: group.ontologyID,
+        parent: group.ontologyID(symbolGroup.key),
       });
       expect(symbol.name).toBe("Test Symbol");
       expect(symbol.key).toBeDefined();
     });
 
     it("should create multiple symbols", async () => {
-      const symbols = await client.workspaces.schematic.symbols.create({
+      const symbols = await client.workspaces.schematics.symbols.create({
         symbols: [
           {
             name: "Symbol 1",
@@ -48,7 +51,7 @@ describe("Symbol Client", () => {
             data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
           },
         ],
-        parent: group.ontologyID,
+        parent: group.ontologyID(symbolGroup.key),
       });
       expect(symbols).toHaveLength(2);
       expect(symbols[0].name).toBe("Symbol 1");
@@ -58,13 +61,13 @@ describe("Symbol Client", () => {
 
   describe("retrieve", () => {
     it("should retrieve a single symbol by key", async () => {
-      const created = await client.workspaces.schematic.symbols.create({
+      const created = await client.workspaces.schematics.symbols.create({
         name: "Retrieve Test",
         data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID,
+        parent: group.ontologyID(symbolGroup.key),
       });
 
-      const retrieved = await client.workspaces.schematic.symbols.retrieve({
+      const retrieved = await client.workspaces.schematics.symbols.retrieve({
         key: created.key,
       });
       expect(retrieved.key).toBe(created.key);
@@ -72,18 +75,18 @@ describe("Symbol Client", () => {
     });
 
     it("should retrieve multiple symbols by keys", async () => {
-      const created1 = await client.workspaces.schematic.symbols.create({
+      const created1 = await client.workspaces.schematics.symbols.create({
         name: "Multi Test 1",
         data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID,
+        parent: group.ontologyID(symbolGroup.key),
       });
-      const created2 = await client.workspaces.schematic.symbols.create({
+      const created2 = await client.workspaces.schematics.symbols.create({
         name: "Multi Test 2",
         data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID,
+        parent: group.ontologyID(symbolGroup.key),
       });
 
-      const retrieved = await client.workspaces.schematic.symbols.retrieve({
+      const retrieved = await client.workspaces.schematics.symbols.retrieve({
         keys: [created1.key, created2.key],
       });
       expect(retrieved).toHaveLength(2);
@@ -92,15 +95,15 @@ describe("Symbol Client", () => {
 
   describe("rename", () => {
     it("should rename a symbol", async () => {
-      const symbol = await client.workspaces.schematic.symbols.create({
+      const symbol = await client.workspaces.schematics.symbols.create({
         name: "Original Name",
         data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID,
+        parent: group.ontologyID(symbolGroup.key),
       });
 
-      await client.workspaces.schematic.symbols.rename(symbol.key, "New Name");
+      await client.workspaces.schematics.symbols.rename(symbol.key, "New Name");
 
-      const retrieved = await client.workspaces.schematic.symbols.retrieve({
+      const retrieved = await client.workspaces.schematics.symbols.retrieve({
         key: symbol.key,
       });
       expect(retrieved.name).toBe("New Name");
@@ -109,23 +112,23 @@ describe("Symbol Client", () => {
 
   describe("delete", () => {
     it("should delete a single symbol", async () => {
-      const symbol = await client.workspaces.schematic.symbols.create({
+      const symbol = await client.workspaces.schematics.symbols.create({
         name: "Delete Test",
         data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID,
+        parent: group.ontologyID(symbolGroup.key),
       });
 
-      await client.workspaces.schematic.symbols.delete(symbol.key);
+      await client.workspaces.schematics.symbols.delete(symbol.key);
 
       await expect(
-        client.workspaces.schematic.symbols.retrieve({ key: symbol.key }),
+        client.workspaces.schematics.symbols.retrieve({ key: symbol.key }),
       ).rejects.toThrow();
     });
   });
 
   describe("retrieveGroup", () => {
     it("should retrieve the symbol group", async () => {
-      const group = await client.workspaces.schematic.symbols.retrieveGroup();
+      const group = await client.workspaces.schematics.symbols.retrieveGroup();
       expect(group.key).toBeDefined();
       expect(group.name).toBe("Schematic Symbols");
     });

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

@@ -14,7 +14,6 @@ import { z } from "zod";
 import { ontology } from "@/ontology";
 import { group } from "@/ontology/group";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { nullableArrayZ } from "@/util/zod";
 import {
   type Key,
   keyZ,
@@ -48,10 +47,10 @@ const singleRetrieveArgsZ = z
 const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveRequestZ]);
 
 export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
-export type SingleRetrieveArgs = z.input<typeof singleRetrieveArgsZ>;
-export type MultiRetrieveArgs = z.input<typeof retrieveRequestZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof retrieveRequestZ>;
 
-const retrieveResZ = z.object({ symbols: nullableArrayZ(symbolZ) });
+const retrieveResZ = z.object({ symbols: array.nullableZ(symbolZ) });
 const createResZ = z.object({ symbols: symbolZ.array() });
 const emptyResZ = z.object({});
 const retrieveGroupReqZ = z.object({});
@@ -101,8 +100,8 @@ export class Client {
     );
   }
 
-  async retrieve(args: SingleRetrieveArgs): Promise<Symbol>;
-  async retrieve(args: MultiRetrieveArgs): Promise<Symbol[]>;
+  async retrieve(args: RetrieveSingleParams): Promise<Symbol>;
+  async retrieve(args: RetrieveMultipleParams): Promise<Symbol[]>;
   async retrieve(args: RetrieveArgs): Promise<Symbol | Symbol[]> {
     const isSingle = "key" in args;
     const res = await sendRequired(
@@ -116,8 +115,6 @@ export class Client {
     return isSingle ? res.symbols[0] : res.symbols;
   }
 
-  async delete(key: Key): Promise<void>;
-  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired(
       this.client,
@@ -128,7 +125,7 @@ export class Client {
     );
   }
 
-  async retrieveGroup(): Promise<group.Payload> {
+  async retrieveGroup(): Promise<group.Group> {
     const res = await sendRequired(
       this.client,
       RETRIEVE_GROUP_ENDPOINT,

package/src/workspace/table/client.ts

@@ -12,6 +12,7 @@ import { array, type record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type ontology } from "@/ontology";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { type Key as WorkspaceKey, keyZ as workspaceKeyZ } from "@/workspace/payload";
 import {
   type Key,
@@ -29,14 +30,26 @@ const RENAME_ENDPOINT = "/workspace/table/rename";
 const SET_DATA_ENDPOINT = "/workspace/table/set-data";
 const DELETE_ENDPOINT = "/workspace/table/delete";
 
-const retrieveReqZ = z.object({ keys: keyZ.array() });
-const createReqZ = z.object({ workspace: workspaceKeyZ, tables: newZ.array() });
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
+
 const setDataReqZ = z.object({ key: keyZ, data: z.string() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
-const retrieveResZ = z.object({ tables: remoteZ.array() });
+const retrieveReqZ = z.object({ keys: keyZ.array() });
+const singleRetrieveArgsZ = z
+  .object({ key: keyZ })
+  .transform(({ key }) => ({ keys: [key] }));
+
+export const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveReqZ]);
+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({ tables: array.nullableZ(remoteZ) });
+
+const createReqZ = z.object({ workspace: workspaceKeyZ, tables: newZ.array() });
 const createResZ = z.object({ tables: remoteZ.array() });
+
 const emptyResZ = z.object({});
 
 export class Client {
@@ -80,22 +93,23 @@ export class Client {
     );
   }
 
-  async retrieve(key: Key): Promise<Table>;
-  async retrieve(keys: Key[]): Promise<Table[]>;
-  async retrieve(keys: Params): Promise<Table | Table[]> {
-    const isMany = Array.isArray(keys);
+  async retrieve(args: RetrieveSingleParams): Promise<Table>;
+  async retrieve(args: RetrieveMultipleParams): Promise<Table[]>;
+  async retrieve(
+    args: RetrieveSingleParams | RetrieveMultipleParams,
+  ): Promise<Table | Table[]> {
+    const isSingle = singleRetrieveArgsZ.safeParse(args).success;
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
-      { keys: array.toArray(keys) },
-      retrieveReqZ,
+      args,
+      retrieveArgsZ,
       retrieveResZ,
     );
-    return isMany ? res.tables : res.tables[0];
+    checkForMultipleOrNoResults("Table", args, res.tables, isSingle);
+    return isSingle ? res.tables[0] : res.tables;
   }
 
-  async delete(key: Key): Promise<void>;
-  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
     await sendRequired(
       this.client,

package/src/workspace/table/table.spec.ts

@@ -10,6 +10,7 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
+import { NotFoundError } from "@/errors";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -18,7 +19,7 @@ describe("Table", () => {
   describe("create", () => {
     test("create one", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.workspaces.table.create(ws.key, {
+      const table = await client.workspaces.tables.create(ws.key, {
         name: "Table",
         data: { one: 1 },
       });
@@ -30,36 +31,38 @@ describe("Table", () => {
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.workspaces.table.create(ws.key, {
+      const table = await client.workspaces.tables.create(ws.key, {
         name: "Table",
         data: { one: 1 },
       });
-      await client.workspaces.table.rename(table.key, "Table2");
-      const res = await client.workspaces.table.retrieve(table.key);
+      await client.workspaces.tables.rename(table.key, "Table2");
+      const res = await client.workspaces.tables.retrieve({ key: table.key });
       expect(res.name).toEqual("Table2");
     });
   });
   describe("setData", () => {
     test("set data", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.workspaces.table.create(ws.key, {
+      const table = await client.workspaces.tables.create(ws.key, {
         name: "Table",
         data: { one: 1 },
       });
-      await client.workspaces.table.setData(table.key, { two: 2 });
-      const res = await client.workspaces.table.retrieve(table.key);
+      await client.workspaces.tables.setData(table.key, { two: 2 });
+      const res = await client.workspaces.tables.retrieve({ key: table.key });
       expect(res.data.two).toEqual(2);
     });
   });
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.workspaces.table.create(ws.key, {
+      const table = await client.workspaces.tables.create(ws.key, {
         name: "Table",
         data: { one: 1 },
       });
-      await client.workspaces.table.delete(table.key);
-      await expect(client.workspaces.table.retrieve(table.key)).rejects.toThrow();
+      await client.workspaces.tables.delete(table.key);
+      await expect(
+        client.workspaces.tables.retrieve({ key: table.key }),
+      ).rejects.toThrow(NotFoundError);
     });
   });
 });

package/dist/ontology/group/group.d.ts

@@ -1,10 +0,0 @@
-import { ontology } from '..';
-import { Key, Name } from './payload';
-export declare class Group {
-    key: Key;
-    name: Name;
-    constructor(name: Name, key: Key);
-    get ontologyID(): ontology.ID;
-}
-export declare const ontologyID: (key: Key) => ontology.ID;
-//# sourceMappingURL=group.d.ts.map

package/dist/ontology/group/group.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../src/ontology/group/group.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAE/D,qBAAa,KAAK;IAChB,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,IAAI,CAAC;gBAEC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG;IAKhC,IAAI,UAAU,IAAI,QAAQ,CAAC,EAAE,CAE5B;CACF;AAED,eAAO,MAAM,UAAU,GAAI,KAAK,GAAG,KAAG,QAAQ,CAAC,EAA8B,CAAC"}

package/dist/ontology/group/writer.d.ts

@@ -1,14 +0,0 @@
-import { UnaryClient } from '@synnaxlabs/freighter';
-import { Key, Name, Payload } from './payload';
-import { ID as OntologyID } from '../payload';
-export declare class Writer {
-    private static readonly CREATE_ENDPOINT;
-    private static readonly RENAME_ENDPOINT;
-    private static readonly DELETE_ENDPOINT;
-    client: UnaryClient;
-    constructor(client: UnaryClient);
-    create(parent: OntologyID, name: Name, key?: Key): Promise<Payload>;
-    rename(key: Key, name: Name): Promise<void>;
-    delete(keys: Key[]): Promise<void>;
-}
-//# sourceMappingURL=writer.d.ts.map

package/dist/ontology/group/writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/ontology/group/writer.ts"],"names":[],"mappings":"AASA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAEL,KAAK,GAAG,EAER,KAAK,IAAI,EAET,KAAK,OAAO,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,IAAI,UAAU,EAAsB,MAAM,oBAAoB,CAAC;AAU/E,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAA4B;IACnE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAA4B;IACnE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAA4B;IACnE,MAAM,EAAE,WAAW,CAAC;gBAER,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;IAWnE,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAU3C,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CASzC"}

package/dist/util/zod.d.ts

@@ -1,3 +0,0 @@
-import { z } from 'zod';
-export declare const nullableArrayZ: <Z extends z.ZodType>(item: Z) => z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<z.core.output<Z>[], null | undefined>>, z.ZodArray<Z>]>;
-//# sourceMappingURL=zod.d.ts.map

package/dist/util/zod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/util/zod.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,4JAIvD,CAAC"}

package/src/ontology/group/group.ts

@@ -1,27 +0,0 @@
-// 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 { type ontology } from "@/ontology";
-import { type Key, type Name } from "@/ontology/group/payload";
-
-export class Group {
-  key: Key;
-  name: Name;
-
-  constructor(name: Name, key: Key) {
-    this.key = key;
-    this.name = name;
-  }
-
-  get ontologyID(): ontology.ID {
-    return ontologyID(this.key);
-  }
-}
-
-export const ontologyID = (key: Key): ontology.ID => ({ type: "group", key });