@synnaxlabs/client 0.20.0 → 0.22.0

package/src/workspace/{pid → schematic}/external.ts

@@ -7,5 +7,5 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * from "@/workspace/pid/payload";
-export * from "@/workspace/pid/client";
+export * from "@/workspace/schematic/payload";
+export * from "@/workspace/schematic/client";

package/src/workspace/{pid → schematic}/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as pid from "@/workspace/pid/external";
+export * as schematic from "@/workspace/schematic/external";

package/src/workspace/{pid → schematic}/payload.ts

@@ -7,25 +7,25 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type UnknownRecord, unknownRecordZ } from "@synnaxlabs/x";
+import { type UnknownRecord, unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 export type Params = Key | Key[];
 
-export const pidZ = z.object({
+export const schematicZ = z.object({
   key: z.string(),
   name: z.string(),
   data: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
   snapshot: z.boolean(),
 });
 
-export const pidRemoteZ = z.object({
+export const schematicRemoteZ = z.object({
   key: z.string(),
   name: z.string(),
   snapshot: z.boolean(),
   data: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
 });
 
-export type PID = z.infer<typeof pidZ>;
+export type Schematic = z.infer<typeof schematicZ>;

package/src/workspace/{pid → schematic}/retriever.ts

@@ -8,10 +8,10 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { toArray } from "@synnaxlabs/x";
+import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { type PID, type Params, pidRemoteZ } from "./payload";
+import { type Schematic, type Params, schematicRemoteZ } from "@/workspace/schematic/payload";
 
 const reqZ = z.object({
   keys: z.string().array(),
@@ -20,24 +20,24 @@ const reqZ = z.object({
 type Request = z.infer<typeof reqZ>;
 
 const resZ = z.object({
-  pids: pidRemoteZ.array(),
+  schematics: schematicRemoteZ.array(),
 });
 
 export class Retriever {
-  private readonly ENDPOINT = "/workspace/pid/retrieve";
+  private readonly ENDPOINT = "/workspace/schematic/retrieve";
   private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
     this.client = client;
   }
 
-  async retrieve(params: Params): Promise<PID[]> {
+  async retrieve(params: Params): Promise<Schematic[]> {
     return (await sendRequired(
-      this.client, 
-      this.ENDPOINT, 
-      { keys: toArray(params) }, 
-      reqZ, 
+      this.client,
+      this.ENDPOINT,
+      { keys: toArray(params) },
+      reqZ,
       resZ,
-    )).pids;
+    )).schematics;
   }
 }

package/src/workspace/{pid/pid.spec.ts → schematic/schematic.spec.ts}

@@ -16,94 +16,94 @@ const client = newClient();
 
 const ZERO_UUID = "00000000-0000-0000-0000-000000000000";
 
-describe("PID", () => {
+describe("Schematic", () => {
   describe("create", () => {
     test("create one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
-      const pid = await client.workspaces.pid.create(ws.key, {
-        name: "PID",
+      const schematic = await client.workspaces.schematic.create(ws.key, {
+        name: "Schematic",
         data: { one: 1 },
       });
-      expect(pid.name).toEqual("PID");
-      expect(pid.key).not.toEqual(ZERO_UUID);
-      expect(pid.data.one).toEqual(1);
+      expect(schematic.name).toEqual("Schematic");
+      expect(schematic.key).not.toEqual(ZERO_UUID);
+      expect(schematic.data.one).toEqual(1);
     });
   });
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
-      const pid = await client.workspaces.pid.create(ws.key, {
-        name: "PID",
+      const schematic = await client.workspaces.schematic.create(ws.key, {
+        name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.pid.rename(pid.key, "PID2");
-      const res = await client.workspaces.pid.retrieve(pid.key);
-      expect(res.name).toEqual("PID2");
+      await client.workspaces.schematic.rename(schematic.key, "Schematic2");
+      const res = await client.workspaces.schematic.retrieve(schematic.key);
+      expect(res.name).toEqual("Schematic2");
     });
   });
   describe("setData", () => {
     test("set data", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
-      const pid = await client.workspaces.pid.create(ws.key, {
-        name: "PID",
+      const schematic = await client.workspaces.schematic.create(ws.key, {
+        name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.pid.setData(pid.key, { two: 2 });
-      const res = await client.workspaces.pid.retrieve(pid.key);
+      await client.workspaces.schematic.setData(schematic.key, { two: 2 });
+      const res = await client.workspaces.schematic.retrieve(schematic.key);
       expect(res.data.two).toEqual(2);
     });
   });
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
-      const pid = await client.workspaces.pid.create(ws.key, {
-        name: "PID",
+      const schematic = await client.workspaces.schematic.create(ws.key, {
+        name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.pid.delete(pid.key);
-      await expect(client.workspaces.pid.retrieve(pid.key)).rejects.toThrow();
+      await client.workspaces.schematic.delete(schematic.key);
+      await expect(client.workspaces.schematic.retrieve(schematic.key)).rejects.toThrow();
     });
   });
   describe("copy", () => {
     test("copy one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
-      const pid = await client.workspaces.pid.create(ws.key, {
-        name: "PID",
+      const schematic = await client.workspaces.schematic.create(ws.key, {
+        name: "Schematic",
         data: { one: 1 },
       });
-      const pid2 = await client.workspaces.pid.copy(pid.key, "PID2", false);
-      expect(pid2.name).toEqual("PID2");
-      expect(pid2.key).not.toEqual(ZERO_UUID);
-      expect(pid2.data.one).toEqual(1);
+      const schematic2 = await client.workspaces.schematic.copy(schematic.key, "Schematic2", false);
+      expect(schematic2.name).toEqual("Schematic2");
+      expect(schematic2.key).not.toEqual(ZERO_UUID);
+      expect(schematic2.data.one).toEqual(1);
     });
     describe("snapshot", () => {
       it("should not allow the caller to edit the snapshot", async () => {
         const ws = await client.workspaces.create({
-          name: "PID",
+          name: "Schematic",
           layout: { one: 1 },
         });
-        const pid = await client.workspaces.pid.create(ws.key, {
-          name: "PID",
+        const schematic = await client.workspaces.schematic.create(ws.key, {
+          name: "Schematic",
           data: { one: 1 },
         });
-        const pid2 = await client.workspaces.pid.copy(pid.key, "PID2", true);
+        const schematic2 = await client.workspaces.schematic.copy(schematic.key, "Schematic2", true);
         await expect(
-          client.workspaces.pid.setData(pid2.key, { two: 2 }),
+          client.workspaces.schematic.setData(schematic2.key, { two: 2 }),
         ).rejects.toThrow(ValidationError);
       });
     });

package/src/workspace/{pid → schematic}/writer.ts

@@ -8,33 +8,34 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { toArray, type UnknownRecord } from "@synnaxlabs/x";
+import { type UnknownRecord } from "@synnaxlabs/x/record";
+import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
 import { keyZ as workspaceKeyZ } from "@/workspace/payload";
 import {
-  pidZ,
-  type PID,
+  schematicZ,
+  type Schematic,
   type Params,
   keyZ,
   type Key,
-  pidRemoteZ,
-} from "@/workspace/pid/payload";
+  schematicRemoteZ,
+} from "@/workspace/schematic/payload";
 
-export const newPIDZ = pidZ.partial({ key: true, snapshot: true }).transform((p) => ({
+export const newSchematicZ = schematicZ.partial({ key: true, snapshot: true }).transform((p) => ({
   ...p,
   data: JSON.stringify(p.data),
 }));
 
-export type NewPID = z.input<typeof newPIDZ>;
+export type NewSchematic = z.input<typeof newSchematicZ>;
 
 const createReqZ = z.object({
   workspace: workspaceKeyZ,
-  pids: newPIDZ.array(),
+  schematics: newSchematicZ.array(),
 });
 
 const createResZ = z.object({
-  pids: pidRemoteZ.array(),
+  schematics: schematicRemoteZ.array(),
 });
 
 const deleteReqZ = z.object({
@@ -64,14 +65,14 @@ const copyReqZ = z.object({
 });
 
 const copyResZ = z.object({
-  pid: pidRemoteZ,
+  schematic: schematicRemoteZ,
 });
 
-const CREATE_ENDPOINT = "/workspace/pid/create";
-const DELETE_ENDPOINT = "/workspace/pid/delete";
-const RENAME_ENDPOINT = "/workspace/pid/rename";
-const SET_DATA_ENDPOINT = "/workspace/pid/set-data";
-const COPY_ENDPOINT = "/workspace/pid/copy";
+const CREATE_ENDPOINT = "/workspace/schematic/create";
+const DELETE_ENDPOINT = "/workspace/schematic/delete";
+const RENAME_ENDPOINT = "/workspace/schematic/rename";
+const SET_DATA_ENDPOINT = "/workspace/schematic/set-data";
+const COPY_ENDPOINT = "/workspace/schematic/copy";
 
 export class Writer {
   private readonly client: UnaryClient;
@@ -80,20 +81,20 @@ export class Writer {
     this.client = client;
   }
 
-  async create(workspace: string, pid: NewPID): Promise<PID> {
-    const pid_ = { ...pid, data: JSON.stringify(pid.data) };
+  async create(workspace: string, schematic: NewSchematic): Promise<Schematic> {
+    const schematic_ = { ...schematic, data: JSON.stringify(schematic.data) };
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
       CREATE_ENDPOINT,
-      { workspace, pids: [pid_] },
+      { workspace, schematics: [schematic_] },
       createReqZ,
       createResZ,
     );
 
-    return res.pids[0];
+    return res.schematics[0];
   }
 
-  async copy(key: Key, name: string, snapshot: boolean): Promise<PID> {
+  async copy(key: Key, name: string, snapshot: boolean): Promise<Schematic> {
     const res = await sendRequired<typeof copyReqZ, typeof copyResZ>(
       this.client,
       COPY_ENDPOINT,
@@ -101,7 +102,7 @@ export class Writer {
       copyReqZ,
       copyResZ,
     );
-    return res.pid;
+    return res.schematic;
   }
 
   async delete(params: Params): Promise<void> {
@@ -115,21 +116,21 @@ export class Writer {
     );
   }
 
-  async rename(pid: Key, name: string): Promise<void> {
+  async rename(schematic: Key, name: string): Promise<void> {
     await sendRequired<typeof renameReqZ, typeof renameResZ>(
       this.client,
       RENAME_ENDPOINT,
-      { key: pid, name },
+      { key: schematic, name },
       renameReqZ,
       renameResZ,
     );
   }
 
-  async setData(pid: Key, data: UnknownRecord): Promise<void> {
+  async setData(schematic: Key, data: UnknownRecord): Promise<void> {
     await sendRequired<typeof setDataReqZ, typeof setDataResZ>(
       this.client,
       SET_DATA_ENDPOINT,
-      { key: pid, data: JSON.stringify(data) },
+      { key: schematic, data: JSON.stringify(data) },
       setDataReqZ,
       renameResZ,
     );

package/src/workspace/workspace.spec.ts

@@ -19,10 +19,10 @@ describe("Workspace", () => {
   describe("create", () => {
     test("create one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
-      expect(ws.name).toEqual("PID");
+      expect(ws.name).toEqual("Schematic");
       expect(ws.key).not.toEqual(ZERO_UUID);
       expect(ws.layout.one).toEqual(1);
     });
@@ -30,18 +30,18 @@ describe("Workspace", () => {
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
-      await client.workspaces.rename(ws.key, "PID2");
+      await client.workspaces.rename(ws.key, "Schematic2");
       const res = await client.workspaces.retrieve(ws.key);
-      expect(res.name).toEqual("PID2");
+      expect(res.name).toEqual("Schematic2");
     });
   });
   describe("setLayout", () => {
     test("set layout", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
       await client.workspaces.setLayout(ws.key, { two: 2 });
@@ -52,7 +52,7 @@ describe("Workspace", () => {
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
       await client.workspaces.delete(ws.key);

package/src/workspace/writer.ts

@@ -8,10 +8,16 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { toArray, type UnknownRecord } from "@synnaxlabs/x";
+import { type UnknownRecord } from "@synnaxlabs/x/record";
+import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { type Workspace, workspaceZ, keyZ, workspaceRemoteZ } from "./payload";
+import {
+  type Workspace,
+  workspaceZ,
+  keyZ,
+  workspaceRemoteZ,
+} from "@/workspace/payload";
 
 const newWorkspaceZ = workspaceZ.partial({ key: true }).transform((w) => ({
   ...w,

package/dist/hardware/device/payload.d.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-export declare const deviceKeyZ: z.ZodString;
-export declare const deviceZ: z.ZodObject<{
-    key: z.ZodString;
-    rack: z.ZodNumber;
-    name: z.ZodString;
-    make: z.ZodString;
-    model: z.ZodString;
-    location: z.ZodString;
-    properties: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    key: string;
-    rack: number;
-    make: string;
-    model: string;
-    location: string;
-    properties: string;
-}, {
-    name: string;
-    key: string;
-    rack: number;
-    make: string;
-    model: string;
-    location: string;
-    properties: string;
-}>;
-export type Device = z.infer<typeof deviceZ>;
-export type DeviceKey = z.infer<typeof deviceKeyZ>;
-//# sourceMappingURL=payload.d.ts.map

package/dist/hardware/device/payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/hardware/device/payload.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,UAAU,aAAa,CAAC;AAErC,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;EAQlB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/hardware/device/retriever.d.ts

@@ -1,10 +0,0 @@
-import { type UnaryClient } from "@synnaxlabs/freighter";
-import { type Device } from './payload';
-export declare class Retriever {
-    private readonly client;
-    constructor(client: UnaryClient);
-    search(term: string): Promise<Device[]>;
-    page(offset: number, limit: number): Promise<Device[]>;
-    retrieve(keys: string[]): Promise<Device[]>;
-}
-//# sourceMappingURL=retriever.d.ts.map

package/dist/hardware/device/retriever.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retriever.d.ts","sourceRoot":"","sources":["../../../src/hardware/device/retriever.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAAE,KAAK,MAAM,EAAuB,MAAM,2BAA2B,CAAC;AAgB7E,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAQvC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAStD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAOlD"}

package/dist/hardware/device/writer.d.ts

@@ -1,9 +0,0 @@
-import { type UnaryClient } from "@synnaxlabs/freighter";
-import { type Device } from './payload';
-export declare class Writer {
-    private readonly client;
-    constructor(client: UnaryClient);
-    create(devices: Device[]): Promise<Device[]>;
-    delete(keys: string[]): Promise<void>;
-}
-//# sourceMappingURL=writer.d.ts.map

package/dist/hardware/device/writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/hardware/device/writer.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAAE,KAAK,MAAM,EAAuB,MAAM,2BAA2B,CAAC;AAmB7E,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAW5C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAS5C"}

package/dist/hardware/rack/payload.d.ts

@@ -1,26 +0,0 @@
-import { z } from "zod";
-export declare const rackKeyZ: z.ZodNumber;
-export type RackKey = z.infer<typeof rackKeyZ>;
-export declare const rackZ: z.ZodObject<{
-    key: z.ZodNumber;
-    name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    key: number;
-}, {
-    name: string;
-    key: number;
-}>;
-export type RackPayload = z.infer<typeof rackZ>;
-export declare const newRackZ: z.ZodObject<{
-    name: z.ZodString;
-    key: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    key?: number | undefined;
-}, {
-    name: string;
-    key?: number | undefined;
-}>;
-export type NewRack = z.input<typeof newRackZ>;
-//# sourceMappingURL=payload.d.ts.map

package/dist/hardware/rack/payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/hardware/rack/payload.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,QAAQ,aAAa,CAAC;AAEnC,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C,eAAO,MAAM,KAAK;;;;;;;;;EAGhB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAEhD,eAAO,MAAM,QAAQ;;;;;;;;;EAA+B,CAAC;AAErD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/dist/hardware/rack/retriever.d.ts

@@ -1,10 +0,0 @@
-import { type UnaryClient } from "@synnaxlabs/freighter";
-import { type RackPayload } from './payload';
-export declare class Retriever {
-    private readonly client;
-    constructor(client: UnaryClient);
-    page(offset: number, limit: number): Promise<RackPayload[]>;
-    search(term: string): Promise<RackPayload[]>;
-    retrieve(keys: number[]): Promise<RackPayload[]>;
-}
-//# sourceMappingURL=retriever.d.ts.map

package/dist/hardware/rack/retriever.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retriever.d.ts","sourceRoot":"","sources":["../../../src/hardware/rack/retriever.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAgB5E,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAW3D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAW5C,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CAUvD"}

package/dist/hardware/rack/writer.d.ts

@@ -1,9 +0,0 @@
-import { NewRack, RackPayload } from './payload';
-import { UnaryClient } from "@synnaxlabs/freighter";
-export declare class Writer {
-    private readonly client;
-    constructor(client: UnaryClient);
-    create(racks: NewRack[]): Promise<RackPayload[]>;
-    delete(keys: number[]): Promise<void>;
-}
-//# sourceMappingURL=writer.d.ts.map

package/dist/hardware/rack/writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/hardware/rack/writer.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,OAAO,EAAE,WAAW,EAA6B,MAAM,yBAAyB,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AAmBlE,qBAAa,MAAM;IACf,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAWhD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAU9C"}

package/dist/hardware/task/external.d.ts

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

package/dist/hardware/task/external.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../src/hardware/task/external.ts"],"names":[],"mappings":"AASA,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC"}

package/dist/hardware/task/payload.d.ts

@@ -1,42 +0,0 @@
-import { type UnknownRecord } from "@synnaxlabs/x";
-import { z } from "zod";
-export declare const taskKeyZ: z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodBigInt, string, bigint>, z.ZodEffects<z.ZodNumber, string, number>]>;
-export type TaskKey = z.infer<typeof taskKeyZ>;
-export declare const taskZ: z.ZodObject<{
-    key: z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodBigInt, string, bigint>, z.ZodEffects<z.ZodNumber, string, number>]>;
-    name: z.ZodString;
-    type: z.ZodString;
-    config: z.ZodType<UnknownRecord, z.ZodTypeDef, UnknownRecord>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    key: string;
-    type: string;
-    config: UnknownRecord;
-}, {
-    name: string;
-    key: string | number | bigint;
-    type: string;
-    config: UnknownRecord;
-}>;
-export declare const newTaskZ: z.ZodObject<{
-    name: z.ZodString;
-    type: z.ZodString;
-    key: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodBigInt, string, bigint>, z.ZodEffects<z.ZodNumber, string, number>]>, string, string | number | bigint>>;
-    config: z.ZodEffects<z.ZodUnknown, string, unknown>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    type: string;
-    config: string;
-    key?: string | undefined;
-}, {
-    name: string;
-    type: string;
-    key?: string | number | bigint | undefined;
-    config?: unknown;
-}>;
-export type NewTask = z.input<typeof newTaskZ>;
-export type Task<T extends string = string, C extends UnknownRecord = UnknownRecord> = Omit<z.infer<typeof taskZ>, "config" | "type"> & {
-    type: T;
-    config: C;
-};
-//# sourceMappingURL=payload.d.ts.map

package/dist/hardware/task/payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/hardware/task/payload.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,QAAQ,iHAInB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;EAOhB,CAAC;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;EAGnB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C,MAAM,MAAM,IAAI,CACd,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,CAAC,SAAS,aAAa,GAAG,aAAa,IACrC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC"}

package/dist/hardware/task/retriever.d.ts

@@ -1,29 +0,0 @@
-import { type UnaryClient } from "@synnaxlabs/freighter";
-import { z } from "zod";
-import { type Task } from './payload';
-declare const retrieveReqZ: z.ZodObject<{
-    rack: z.ZodOptional<z.ZodNumber>;
-    keys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    offset: z.ZodOptional<z.ZodNumber>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    rack?: number | undefined;
-    keys?: string[] | undefined;
-    offset?: number | undefined;
-    limit?: number | undefined;
-}, {
-    rack?: number | undefined;
-    keys?: string[] | undefined;
-    offset?: number | undefined;
-    limit?: number | undefined;
-}>;
-export type RetrieveRequest = z.infer<typeof retrieveReqZ>;
-export declare class Retriever {
-    private readonly client;
-    constructor(client: UnaryClient);
-    retrieve(params: RetrieveRequest): Promise<Task[]>;
-    search(term: string): Promise<Task[]>;
-    page(offset: number, limit: number): Promise<Task[]>;
-}
-export {};
-//# sourceMappingURL=retriever.d.ts.map

package/dist/hardware/task/retriever.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retriever.d.ts","sourceRoot":"","sources":["../../../src/hardware/task/retriever.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,KAAK,IAAI,EAAS,MAAM,yBAAyB,CAAC;AAE3D,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;EAKhB,CAAC;AAMH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAI3D,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAWlD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAWrC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;CAU3D"}

package/dist/hardware/task/writer.d.ts

@@ -1,9 +0,0 @@
-import { type UnaryClient } from "@synnaxlabs/freighter";
-import { type NewTask, type Task } from './payload';
-export declare class Writer {
-    private readonly client;
-    constructor(client: UnaryClient);
-    create(tasks: NewTask[]): Promise<Task[]>;
-    delete(keys: bigint[]): Promise<void>;
-}
-//# sourceMappingURL=writer.d.ts.map

package/dist/hardware/task/writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/hardware/task/writer.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,IAAI,EAIV,MAAM,yBAAyB,CAAC;AAmBjC,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAWzC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAS5C"}