@synnaxlabs/client 0.34.0 → 0.36.0

package/src/workspace/log/client.ts

@@ -1,51 +1,116 @@
-// Copyright 2024 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 UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord } from "@synnaxlabs/x/record";
-
-import { type Key, type Log, type Params } from "@/workspace/log/payload";
-import { Retriever } from "@/workspace/log/retriever";
-import { type NewLog, Writer } from "@/workspace/log/writer";
+import { ontology } from "@/ontology";
+import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, UnknownRecord } from "@synnaxlabs/x";
+import { 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 logZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
+});
+
+export type Log = z.infer<typeof logZ>;
+
+export const ONTOLOGY_TYPE: ontology.ResourceType = "log";
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+
+const RETRIEVE_ENDPOINT = "/workspace/log/retrieve";
+const CREATE_ENDPOINT = "/workspace/log/create";
+const RENAME_ENDPOINT = "/workspace/log/rename";
+const SET_DATA_ENDPOINT = "/workspace/log/set-data";
+const DELETE_ENDPOINT = "/workspace/log/delete";
+
+export const newLogZ = logZ.partial({ key: true }).transform((p) => ({
+  ...p,
+  data: JSON.stringify(p.data),
+}));
+
+export type NewLog = z.input<typeof newLogZ>;
+
+const retrieveReqZ = z.object({ keys: z.string().array() });
+const createReqZ = z.object({ workspace: z.string(), logs: newLogZ.array() });
+const renameReqZ = z.object({ key: z.string(), name: z.string() });
+const setDataReqZ = z.object({ key: z.string(), data: z.string() });
+const deleteReqZ = z.object({ keys: z.string().array() });
+
+const retrieveResZ = z.object({ logs: logZ.array() });
+const createResZ = z.object({ logs: logZ.array() });
+const emptyResZ = z.object({});
 
 export class Client {
-  private readonly writer: Writer;
-  private readonly retriever: Retriever;
+  private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
-    this.writer = new Writer(client);
-    this.retriever = new Retriever(client);
+    this.client = client;
   }
 
-  async create(workspace: string, log: NewLog): Promise<Log> {
-    return await this.writer.create(workspace, log);
+  async create(workspace: string, log: NewLog): Promise<Log>;
+  async create(workspace: string, logs: NewLog[]): Promise<Log[]>;
+  async create(workspace: string, logs: NewLog | NewLog[]): Promise<Log | Log[]> {
+    const isMany = Array.isArray(logs);
+    const normalized = toArray(logs);
+    const res = await sendRequired(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, logs: normalized },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.logs : res.logs[0];
   }
 
   async rename(key: Key, name: string): Promise<void> {
-    await this.writer.rename(key, name);
+    await sendRequired(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameReqZ,
+      emptyResZ,
+    );
   }
 
   async setData(key: Key, data: UnknownRecord): Promise<void> {
-    await this.writer.setData(key, data);
+    await sendRequired(
+      this.client,
+      SET_DATA_ENDPOINT,
+      { key, data: JSON.stringify(data) },
+      setDataReqZ,
+      emptyResZ,
+    );
   }
 
   async retrieve(key: Key): Promise<Log>;
-
   async retrieve(keys: Key[]): Promise<Log[]>;
-
   async retrieve(keys: Params): Promise<Log | Log[]> {
     const isMany = Array.isArray(keys);
-    const res = await this.retriever.retrieve(keys);
-    return isMany ? res : res[0];
+    const normalized = toArray(keys);
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { keys: normalized },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isMany ? res.logs : res.logs[0];
   }
 
+  async delete(key: Key): Promise<void>;
+  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
-    await this.writer.delete(keys);
+    const normalized = toArray(keys);
+    await sendRequired(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteReqZ,
+      emptyResZ,
+    );
   }
 }

package/src/workspace/log/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 log from "@/workspace/log/external";
+export * as log from "@/workspace/log/client";

package/src/workspace/schematic/client.ts

@@ -1,55 +1,147 @@
-// Copyright 2024 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 UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord } from "@synnaxlabs/x/record";
-
-import { type Key, type Params, type Schematic } from "@/workspace/schematic/payload";
-import { Retriever } from "@/workspace/schematic/retriever";
-import { type NewSchematic, Writer } from "@/workspace/schematic/writer";
+import { ontology } from "@/ontology";
+import { nullableArrayZ } from "@/util/zod";
+import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, UnknownRecord } from "@synnaxlabs/x";
+import { 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 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 schematicRemoteZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  snapshot: z.boolean(),
+  data: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+});
+
+export type Schematic = z.infer<typeof schematicZ>;
+
+export const ONTOLOGY_TYPE: ontology.ResourceType = "schematic";
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+
+const RETRIEVE_ENDPOINT = "/workspace/schematic/retrieve";
+const CREATE_ENDPOINT = "/workspace/schematic/create";
+const RENAME_ENDPOINT = "/workspace/schematic/rename";
+const SET_DATA_ENDPOINT = "/workspace/schematic/set-data";
+const DELETE_ENDPOINT = "/workspace/schematic/delete";
+const COPY_ENDPOINT = "/workspace/schematic/copy";
+
+export const newSchematicZ = schematicZ
+  .partial({ key: true, snapshot: true })
+  .transform((p) => ({
+    ...p,
+    data: JSON.stringify(p.data),
+  }));
+
+export type NewSchematic = z.input<typeof newSchematicZ>;
+
+const retrieveReqZ = z.object({ keys: z.string().array() });
+const createReqZ = z.object({
+  workspace: z.string(),
+  schematics: newSchematicZ.array(),
+});
+const renameReqZ = z.object({ key: z.string(), name: z.string() });
+const setDataReqZ = z.object({ key: z.string(), data: z.string() });
+const deleteReqZ = z.object({ keys: z.string().array() });
+const copyReqZ = z.object({ key: z.string(), name: z.string(), snapshot: z.boolean() });
+
+const retrieveResZ = z.object({ schematics: nullableArrayZ(schematicRemoteZ) });
+const createResZ = z.object({ schematics: schematicRemoteZ.array() });
+const copyResZ = z.object({ schematic: schematicZ });
+const emptyResZ = z.object({});
 
 export class Client {
-  private readonly writer: Writer;
-  private readonly retriever: Retriever;
+  private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
-    this.writer = new Writer(client);
-    this.retriever = new Retriever(client);
+    this.client = client;
   }
 
-  async create(workspace: string, schematic: NewSchematic): Promise<Schematic> {
-    return await this.writer.create(workspace, schematic);
+  async create(workspace: string, schematic: NewSchematic): Promise<Schematic>;
+  async create(workspace: string, schematics: NewSchematic[]): Promise<Schematic[]>;
+  async create(
+    workspace: string,
+    schematics: NewSchematic | NewSchematic[],
+  ): Promise<Schematic | Schematic[]> {
+    const isMany = Array.isArray(schematics);
+    const normalized = toArray(schematics);
+    const res = await sendRequired(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, schematics: normalized },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.schematics : res.schematics[0];
   }
 
   async rename(key: Key, name: string): Promise<void> {
-    await this.writer.rename(key, name);
+    await sendRequired(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameReqZ,
+      emptyResZ,
+    );
   }
 
   async setData(key: Key, data: UnknownRecord): Promise<void> {
-    await this.writer.setData(key, data);
+    await sendRequired(
+      this.client,
+      SET_DATA_ENDPOINT,
+      { key, data: JSON.stringify(data) },
+      setDataReqZ,
+      emptyResZ,
+    );
   }
 
   async retrieve(key: Key): Promise<Schematic>;
-
   async retrieve(keys: Key[]): Promise<Schematic[]>;
-
   async retrieve(keys: Params): Promise<Schematic | Schematic[]> {
     const isMany = Array.isArray(keys);
-    const res = await this.retriever.retrieve(keys);
-    return isMany ? res : res[0];
+    const normalized = toArray(keys);
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { keys: normalized },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isMany ? res.schematics : res.schematics[0];
   }
 
+  async delete(key: Key): Promise<void>;
+  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
-    await this.writer.delete(keys);
+    const normalized = toArray(keys);
+    await sendRequired(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteReqZ,
+      emptyResZ,
+    );
   }
 
   async copy(key: Key, name: string, snapshot: boolean): Promise<Schematic> {
-    return await this.writer.copy(key, name, snapshot);
+    const res = await sendRequired(
+      this.client,
+      COPY_ENDPOINT,
+      { key, name, snapshot },
+      copyReqZ,
+      copyResZ,
+    );
+    return res.schematic;
   }
 }

package/src/workspace/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 schematic from "@/workspace/schematic/external";
+export * as schematic from "@/workspace/schematic/client";

package/src/workspace/table/client.ts

@@ -0,0 +1,125 @@
+import { ontology } from "@/ontology";
+import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, UnknownRecord } from "@synnaxlabs/x";
+import { 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 tableZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
+});
+
+export type Table = z.infer<typeof tableZ>;
+
+export const ONTOLOGY_TYPE: ontology.ResourceType = "table";
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+
+const RETRIEVE_ENDPOINT = "/workspace/table/retrieve";
+const CREATE_ENDPOINT = "/workspace/table/create";
+const RENAME_ENDPOINT = "/workspace/table/rename";
+const SET_DATA_ENDPOINT = "/workspace/table/set-data";
+const DELETE_ENDPOINT = "/workspace/table/delete";
+
+export const newTableZ = tableZ.partial({ key: true }).transform((p) => ({
+  ...p,
+  data: JSON.stringify(p.data),
+}));
+
+export type NewTable = z.input<typeof newTableZ>;
+
+export const tableRemoteZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+});
+
+const retrieveReqZ = z.object({ keys: z.string().array() });
+const createReqZ = z.object({ workspace: z.string(), tables: newTableZ.array() });
+const renameReqZ = z.object({ key: z.string(), name: z.string() });
+const setDataReqZ = z.object({ key: z.string(), data: z.string() });
+const deleteReqZ = z.object({ keys: z.string().array() });
+
+const retrieveResZ = z.object({ tables: tableRemoteZ.array() });
+const createResZ = z.object({ tables: tableRemoteZ.array() });
+const emptyResZ = z.object({});
+
+export class Client {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(workspace: string, table: NewTable): Promise<Table>;
+  async create(workspace: string, tables: NewTable[]): Promise<Table[]>;
+  async create(
+    workspace: string,
+    tables: NewTable | NewTable[],
+  ): Promise<Table | Table[]> {
+    const isMany = Array.isArray(tables);
+    const normalized = toArray(tables);
+    const res = await sendRequired(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, tables: normalized },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.tables : res.tables[0];
+  }
+
+  async rename(key: Key, name: string): Promise<void> {
+    await sendRequired(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameReqZ,
+      emptyResZ,
+    );
+  }
+
+  async setData(key: Key, data: UnknownRecord): Promise<void> {
+    await sendRequired(
+      this.client,
+      SET_DATA_ENDPOINT,
+      { key, data: JSON.stringify(data) },
+      setDataReqZ,
+      emptyResZ,
+    );
+  }
+
+  async retrieve(key: Key): Promise<Table>;
+  async retrieve(keys: Key[]): Promise<Table[]>;
+  async retrieve(keys: Params): Promise<Table | Table[]> {
+    const isMany = Array.isArray(keys);
+    const normalized = toArray(keys);
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { keys: normalized },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isMany ? res.tables : res.tables[0];
+  }
+
+  async delete(key: Key): Promise<void>;
+  async delete(keys: Key[]): Promise<void>;
+  async delete(keys: Params): Promise<void> {
+    const normalized = toArray(keys);
+    await sendRequired(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteReqZ,
+      emptyResZ,
+    );
+  }
+}

package/src/workspace/{external.ts → table/index.ts}

@@ -7,5 +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 * from "@/workspace/client";
-export * from "@/workspace/payload";
+export * as table from "@/workspace/table/client";

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

@@ -0,0 +1,65 @@
+// Copyright 2024 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 { NIL as ZERO_UUID } from "uuid";
+import { describe, expect, test } from "vitest";
+
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+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, {
+        name: "Table",
+        data: { one: 1 },
+      });
+      expect(table.name).toEqual("Table");
+      expect(table.key).not.toEqual(ZERO_UUID);
+      expect(table.data.one).toEqual(1);
+    });
+  });
+  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, {
+        name: "Table",
+        data: { one: 1 },
+      });
+      await client.workspaces.table.rename(table.key, "Table2");
+      const res = await client.workspaces.table.retrieve(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, {
+        name: "Table",
+        data: { one: 1 },
+      });
+      await client.workspaces.table.setData(table.key, { two: 2 });
+      const res = await client.workspaces.table.retrieve(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, {
+        name: "Table",
+        data: { one: 1 },
+      });
+      await client.workspaces.table.delete(table.key);
+      await expect(client.workspaces.table.retrieve(table.key)).rejects.toThrow();
+    });
+  });
+});

package/dist/workspace/external.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../src/workspace/external.ts"],"names":[],"mappings":"AASA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/workspace/lineplot/external.d.ts

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

package/dist/workspace/lineplot/external.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../src/workspace/lineplot/external.ts"],"names":[],"mappings":"AASA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC"}

package/dist/workspace/lineplot/retriever.d.ts

@@ -1,9 +0,0 @@
-import { UnaryClient } from '@synnaxlabs/freighter';
-import { LinePlot, Params } from './payload';
-export declare class Retriever {
-    private readonly ENDPOINT;
-    private readonly client;
-    constructor(client: UnaryClient);
-    retrieve(linePlots: Params): Promise<LinePlot[]>;
-}
-//# sourceMappingURL=retriever.d.ts.map

package/dist/workspace/lineplot/retriever.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retriever.d.ts","sourceRoot":"","sources":["../../../src/workspace/lineplot/retriever.ts"],"names":[],"mappings":"AASA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIvE,OAAO,EAAE,KAAK,QAAQ,EAAa,KAAK,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAMrF,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;CAMvD"}

package/dist/workspace/lineplot/writer.d.ts

@@ -1,35 +0,0 @@
-import { UnaryClient } from '@synnaxlabs/freighter';
-import { UnknownRecord } from '@synnaxlabs/x/record';
-import { z } from 'zod';
-import { Key, LinePlot, Params } from './payload';
-export declare const newLinePlotZ: z.ZodEffects<z.ZodObject<{
-    name: z.ZodString;
-    key: z.ZodOptional<z.ZodString>;
-    data: z.ZodUnion<[z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>, z.ZodEffects<z.ZodString, UnknownRecord, string>]>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    data: UnknownRecord | Record<string | number | symbol, unknown>;
-    key?: string | undefined;
-}, {
-    name: string;
-    data: string | Record<string | number | symbol, unknown>;
-    key?: string | undefined;
-}>, {
-    data: string;
-    name: string;
-    key?: string | undefined;
-}, {
-    name: string;
-    data: string | Record<string | number | symbol, unknown>;
-    key?: string | undefined;
-}>;
-export type NewLinePlot = z.input<typeof newLinePlotZ>;
-export declare class Writer {
-    private readonly client;
-    constructor(client: UnaryClient);
-    create(workspace: string, plot: NewLinePlot): Promise<LinePlot>;
-    delete(workspaces: Params): Promise<void>;
-    rename(plot: Key, name: string): Promise<void>;
-    setData(plot: Key, data: UnknownRecord): Promise<void>;
-}
-//# sourceMappingURL=writer.d.ts.map

package/dist/workspace/lineplot/writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/workspace/lineplot/writer.ts"],"names":[],"mappings":"AASA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,KAAK,GAAG,EAER,KAAK,QAAQ,EAEb,KAAK,MAAM,EACZ,MAAM,8BAA8B,CAAC;AAGtC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;EAGtB,CAAC;AAEJ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAoCvD,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAa/D,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWzC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU9C,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAS7D"}

package/dist/workspace/log/external.d.ts

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

package/dist/workspace/log/external.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../src/workspace/log/external.ts"],"names":[],"mappings":"AASA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC"}

package/dist/workspace/log/payload.d.ts

@@ -1,36 +0,0 @@
-import { UnknownRecord } from '@synnaxlabs/x/record';
-import { z } from 'zod';
-import { ontology } from '../../ontology';
-export declare const keyZ: z.ZodString;
-export type Key = z.infer<typeof keyZ>;
-export type Params = Key | Key[];
-export declare const logZ: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodString;
-    data: z.ZodUnion<[z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>, z.ZodEffects<z.ZodString, UnknownRecord, string>]>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    key: string;
-    data: UnknownRecord | Record<string | number | symbol, unknown>;
-}, {
-    name: string;
-    key: string;
-    data: string | Record<string | number | symbol, unknown>;
-}>;
-export declare const logRemoteZ: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodString;
-    data: z.ZodEffects<z.ZodString, UnknownRecord, string>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    key: string;
-    data: UnknownRecord;
-}, {
-    name: string;
-    key: string;
-    data: string;
-}>;
-export type Log = z.infer<typeof logZ>;
-export declare const ONTOLOGY_TYPE: ontology.ResourceType;
-export declare const ontologyID: (key: Key) => ontology.ID;
-//# sourceMappingURL=payload.d.ts.map

package/dist/workspace/log/payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/workspace/log/payload.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,sBAAsB,CAAC;AAC1E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,eAAO,MAAM,IAAI,aAAoB,CAAC;AACtC,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,IAAI;;;;;;;;;;;;EAIf,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;EAIrB,CAAC;AAEH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAEvC,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,YAAoB,CAAC;AAE1D,eAAO,MAAM,UAAU,QAAS,GAAG,KAAG,QAAQ,CAAC,EACA,CAAC"}

package/dist/workspace/log/retriever.d.ts

@@ -1,9 +0,0 @@
-import { UnaryClient } from '@synnaxlabs/freighter';
-import { Log, Params } from './payload';
-export declare class Retriever {
-    private readonly ENDPOINT;
-    private readonly client;
-    constructor(client: UnaryClient);
-    retrieve(logs: Params): Promise<Log[]>;
-}
-//# sourceMappingURL=retriever.d.ts.map