@synnaxlabs/client 0.20.0 → 0.22.0

package/src/ranger/range.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type Series, TimeRange } from "@synnaxlabs/x";
+import { type Series, TimeRange } from "@synnaxlabs/x/telem";
 
 import { type Key, type Params, type Name } from "@/channel/payload";
 import { type Retriever as ChannelRetriever } from "@/channel/retriever";
@@ -28,6 +28,7 @@ export class Range {
   name: string;
   readonly kv: KV;
   readonly timeRange: TimeRange;
+  readonly color: string | undefined;
   readonly channels: ChannelRetriever;
   private readonly aliaser: Aliaser;
   private readonly frameClient: framer.Client;
@@ -37,6 +38,7 @@ export class Range {
     name: string,
     timeRange: TimeRange = TimeRange.ZERO,
     key: string,
+    color: string | undefined,
     _frameClient: framer.Client,
     _kv: KV,
     _aliaser: Aliaser,
@@ -47,6 +49,7 @@ export class Range {
     this.name = name;
     this.timeRange = timeRange;
     this.frameClient = _frameClient;
+    this.color = color;
     this.kv = _kv;
     this.aliaser = _aliaser;
     this.channels = _channels;

package/src/ranger/ranger.spec.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { DataType, Rate, TimeSpan, TimeStamp } from "@synnaxlabs/x";
+import { DataType, Rate, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
 import { describe, expect, it } from "vitest";
 
 import { QueryError } from "@/errors";
@@ -23,9 +23,11 @@ describe("Ranger", () => {
       const range = await client.ranges.create({
         name: "My New One Second Range",
         timeRange,
+        color: "#E774D0",
       });
       expect(range.key).not.toHaveLength(0);
       expect(timeRange).toEqual(range.timeRange);
+      expect(range.color).toEqual("#E774D0");
     });
     it("should create multiple ranges", async () => {
       const ranges: NewPayload[] = [
@@ -95,6 +97,16 @@ describe("Ranger", () => {
       expect(retrieved.length).toBeGreaterThan(0);
       expect(retrieved[0].name).toEqual(range.name);
     });
+    it("should retrieve ranges that overlap with the given time range", async () => {
+      const timeRange = TimeStamp.hours(500).spanRange(TimeSpan.seconds(1));
+      const range = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange,
+      });
+      const retrieved = await client.ranges.retrieve(timeRange);
+      expect(retrieved.length).toBeGreaterThan(0);
+      expect(retrieved.map((r) => r.key)).toContain(range.key);
+    });
   });
 
   describe("KV", () => {
@@ -116,7 +128,17 @@ describe("Ranger", () => {
         timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
       });
       await rng.kv.set({ foo: "bar", baz: "qux" });
-      const res = await rng.kv.get(["foo", "baz"]);
+      const res = await rng.kv.list();
+      expect(res).toEqual({ foo: "bar", baz: "qux" });
+    });
+
+    it("should list all keys", async () => {
+      const rng = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+      });
+      await rng.kv.set({ foo: "bar", baz: "qux" });
+      const res = await rng.kv.list();
       expect(res).toEqual({ foo: "bar", baz: "qux" });
     });
   });

package/src/signals/observable.ts

@@ -7,74 +7,35 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { observe, type Destructor, type change, type Series } from "@synnaxlabs/x";
+import { type change } from "@synnaxlabs/x/change";
+import { type observe } from "@synnaxlabs/x/observe";
+import { type Series } from "@synnaxlabs/x/telem";
 
 import { type channel } from "@/channel";
-import { type framer } from "@/framer";
+import { framer } from "@/framer";
 
 export type Decoder<K, V> = (
   variant: change.Variant,
   data: Series,
 ) => Array<change.Change<K, V>>;
 
-export class Observable<K, V>
-  implements observe.Observable<Array<change.Change<K, V>>>
-{
-  private readonly streamer: framer.Streamer;
-  private readonly decoder: Decoder<K, V>;
-  private readonly base: observe.Observer<Array<change.Change<K, V>>>;
-  private readonly closePromise: Promise<void>;
-  private readonly deleteChannel?: channel.Key | channel.Name;
-  private readonly setChannel?: channel.Key | channel.Name;
-
-  private constructor(
-    streamer: framer.Streamer,
-    ecd: Decoder<K, V>,
-    setChannel?: channel.Key | channel.Name,
-    deleteChannel?: channel.Key | channel.Name,
-  ) {
-    this.streamer = streamer;
-    this.decoder = ecd;
-    this.base = new observe.Observer<Array<change.Change<K, V>>>();
-    this.closePromise = this.stream();
-    this.deleteChannel = deleteChannel;
-    this.setChannel = setChannel;
-  }
-
-  onChange(handler: observe.Handler<Array<change.Change<K, V>>>): Destructor {
-    return this.base.onChange(handler);
-  }
-
-  async close(): Promise<void> {
-    this.streamer.close();
-    return await this.closePromise;
-  }
-
-  async stream(): Promise<void> {
-    for await (const frame of this.streamer) {
-      const changes: Array<change.Change<K, V>> = [];
-      if (this.deleteChannel != null) {
-        const deletes = frame.get(this.deleteChannel);
-        changes.push(...deletes.series.flatMap((s) => this.decoder("delete", s)));
-      }
-      if (this.setChannel != null) {
-        const sets = frame.get(this.setChannel);
-        changes.push(...sets.series.flatMap((s) => this.decoder("set", s)));
-      }
-      this.base.notify(changes);
-    }
-  }
-
-  static async open<K, V>(
-    client: framer.Client,
-    setChannel: channel.Key | channel.Name,
-    deleteChannel: channel.Key | channel.Name,
-    ecd: Decoder<K, V>,
-  ): Promise<Observable<K, V>> {
-    const stream = await client.openStreamer([
-      setChannel,
-      deleteChannel,
-    ] as channel.Keys);
-    return new Observable(stream, ecd, setChannel, deleteChannel);
-  }
-}
+export interface Observable<K, V>
+  extends observe.ObservableAsyncCloseable<Array<change.Change<K, V>>> {}
+
+export const openObservable = async <K, V>(
+  client: framer.Client,
+  setChannel: channel.Key | channel.Name,
+  deleteChannel: channel.Key | channel.Name,
+  ecd: Decoder<K, V>,
+): Promise<Observable<K, V>> => {
+  const stream = await client.openStreamer([setChannel, deleteChannel] as channel.Keys);
+  const transform = (frame: framer.Frame): [Array<change.Change<K, V>>, boolean] => {
+    const changes: Array<change.Change<K, V>> = [];
+    if (deleteChannel != null)
+      changes.push(...frame.get(deleteChannel).series.flatMap((s) => ecd("delete", s)));
+    if (setChannel != null)
+      changes.push(...frame.get(setChannel).series.flatMap((s) => ecd("set", s)));
+    return [changes, changes.length > 0];
+  };
+  return new framer.ObservableStreamer<Array<change.Change<K, V>>>(stream, transform);
+};

package/src/transport.ts

@@ -14,7 +14,8 @@ import {
   type StreamClient,
   type UnaryClient,
 } from "@synnaxlabs/freighter";
-import { binary, type URL } from "@synnaxlabs/x";
+import { binary } from "@synnaxlabs/x/binary";
+import { type URL } from "@synnaxlabs/x/url";
 
 const baseAPIEndpoint = "/api/v1/";
 

package/src/util/retrieve.spec.ts

@@ -0,0 +1,56 @@
+// 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 { it, describe, expect } from "vitest";
+import { type Primitive } from "zod";
+
+import {
+  analyzeParams,
+  type ParamAnalysisResult,
+  type PartialTypeNameRecord,
+} from "@/util/retrieve";
+
+describe("retrieve utils", () => {
+  describe("analyze params", () => {
+    interface Spec {
+      args: Primitive extends any ? any : never;
+      variantMap: PartialTypeNameRecord<Primitive>;
+      expected: ParamAnalysisResult<Primitive, PartialTypeNameRecord<Primitive>>;
+    }
+
+    const SPECS: Spec[] = [
+      {
+        args: "abc",
+        variantMap: { string: "name" },
+        expected: {
+          single: true,
+          variant: "name",
+          normalized: ["abc"],
+          actual: "abc",
+        },
+      },
+      {
+        args: 123,
+        variantMap: { number: "id" },
+        expected: {
+          single: true,
+          variant: "id",
+          normalized: [123],
+          actual: 123,
+        },
+      },
+    ];
+
+    SPECS.forEach(({ args, variantMap, expected }) => {
+      it(`should analyze ${JSON.stringify(args)} with ${JSON.stringify(variantMap)}`, () => {
+        expect(analyzeParams(args, variantMap)).toEqual(expected);
+      });
+    });
+  });
+});

package/src/util/retrieve.ts

@@ -0,0 +1,103 @@
+// 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 { toArray, type Primitive } from "@synnaxlabs/x";
+
+import { MultipleFoundError, NotFoundError } from "@/errors";
+
+export type SingleParamAnalysisResult<
+  T extends Primitive,
+  K extends PartialTypeNameRecord<T>,
+> = T extends any
+  ? {
+      single: true;
+      variant: K[keyof K];
+      normalized: T[];
+      actual: T;
+    }
+  : never;
+
+export type MultiParamAnalysisResult<
+  T extends Primitive,
+  K extends PartialTypeNameRecord<T>,
+> = T extends any
+  ? {
+      single: false;
+      variant: K[keyof K];
+      normalized: T[];
+      actual: T[];
+    }
+  : never;
+
+type TypeName<T> = T extends string
+  ? "string"
+  : T extends number
+    ? "number"
+    : T extends boolean
+      ? "boolean"
+      : T extends undefined
+        ? "undefined"
+        : T extends Function
+          ? "function"
+          : "object";
+
+export type PartialTypeNameRecord<T extends Primitive> = Partial<
+  Record<TypeName<T>, string>
+>;
+
+export type ParamAnalysisResult<
+  T extends Primitive,
+  K extends PartialTypeNameRecord<T> = PartialTypeNameRecord<T>,
+> = SingleParamAnalysisResult<T, K> | MultiParamAnalysisResult<T, K>;
+
+export interface AnalyzeParamsOptions {
+  convertNumericStrings?: boolean;
+}
+
+export const analyzeParams = <
+  T extends Primitive = Primitive,
+  K extends PartialTypeNameRecord<T> = PartialTypeNameRecord<T>,
+>(
+  args: T extends any ? T | T[] : never,
+  variantMap: K,
+  { convertNumericStrings = true }: AnalyzeParamsOptions = {},
+): ParamAnalysisResult<T, K> => {
+  const isSingle = !Array.isArray(args);
+  let normal = toArray(args);
+  const first = normal[0];
+  const t = typeof first;
+  let variant: K[keyof K];
+  if (t === "string" && convertNumericStrings)
+    if (!isNaN(parseInt(first as string)) && "number" in variantMap) {
+      variant = variantMap.number as K[keyof K];
+      normal = normal.map((n) => parseInt(n as string));
+    } else variant = variantMap[t as TypeName<T>];
+  else variant = variantMap[t as TypeName<T>];
+  return {
+    single: isSingle,
+    variant,
+    normalized: normal,
+    actual: args,
+  } as unknown as ParamAnalysisResult<T, K>;
+};
+
+export const checkForMultipleOrNoResults = <T, R>(
+  name: string,
+  params: T | T[],
+  results: R[],
+  isSingle: boolean,
+): void => {
+  if (!isSingle) return;
+  if (results.length === 0)
+    throw new NotFoundError(`${name} not found matching ${JSON.stringify(params)}`);
+  if (results.length > 1)
+    throw new MultipleFoundError(
+      `Expected one ${name} matching ${JSON.stringify(params)}, but found ${results.length}`,
+    );
+};

package/src/util/telem.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type DataType, type TypedArray } from "@synnaxlabs/x";
+import { type DataType, type TypedArray } from "@synnaxlabs/x/telem";
 
 export const randomSeries = (length: number, dataType: DataType): TypedArray => {
   // generate random bytes of the correct length

package/src/util/zod.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+
+
+export const nullableArrayZ = <Z extends z.ZodTypeAny>(item: Z) => z.union([z.null().transform(() => []), item.array()]);

package/src/workspace/client.ts

@@ -8,22 +8,24 @@
 // included in the file licenses/APL.txt.
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord, type AsyncTermSearcher } from "@synnaxlabs/x";
+import { type UnknownRecord } from "@synnaxlabs/x/record";
+import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 
 import { linePlot } from "@/workspace/lineplot";
 import { type Key, type Workspace } from "@/workspace/payload";
-import { pid } from "@/workspace/pid";
+import { schematic } from "@/workspace/schematic";
 import { Retriever } from "@/workspace/retriever";
 import { type NewWorkspace, Writer } from "@/workspace/writer";
 
 export class Client implements AsyncTermSearcher<string, Key, Workspace> {
-  readonly pid: pid.Client;
+  readonly type = "workspace";
+  readonly schematic: schematic.Client;
   readonly linePlot: linePlot.Client;
   private readonly retriever: Retriever;
   private readonly writer: Writer;
 
   constructor(client: UnaryClient) {
-    this.pid = new pid.Client(client);
+    this.schematic = new schematic.Client(client);
     this.linePlot = new linePlot.Client(client);
     this.retriever = new Retriever(client);
     this.writer = new Writer(client);

package/src/workspace/lineplot/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord } from "@synnaxlabs/x";
+import { type UnknownRecord } from "@synnaxlabs/x/record";
 
 import { type LinePlot, type Key, type Params } from "@/workspace/lineplot/payload";
 import { Retriever } from "@/workspace/lineplot/retriever";
@@ -23,8 +23,8 @@ export class Client {
     this.retriever = new Retriever(client);
   }
 
-  async create(workspace: string, pid: NewLinePlot): Promise<LinePlot> {
-    return await this.writer.create(workspace, pid);
+  async create(workspace: string, schematic: NewLinePlot): Promise<LinePlot> {
+    return await this.writer.create(workspace, schematic);
   }
 
   async rename(key: Key, name: string): Promise<void> {

package/src/workspace/lineplot/linePlot.spec.ts

@@ -19,14 +19,14 @@ describe("LinePlot", () => {
   describe("create", () => {
     test("create one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
       const linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "PID",
+        name: "Schematic",
         data: { one: 1 },
       });
-      expect(linePlot.name).toEqual("PID");
+      expect(linePlot.name).toEqual("Schematic");
       expect(linePlot.key).not.toEqual(ZERO_UUID);
       expect(linePlot.data.one).toEqual(1);
     });
@@ -34,26 +34,26 @@ describe("LinePlot", () => {
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
       const linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "PID",
+        name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.linePlot.rename(linePlot.key, "PID2");
+      await client.workspaces.linePlot.rename(linePlot.key, "Schematic2");
       const res = await client.workspaces.linePlot.retrieve(linePlot.key);
-      expect(res.name).toEqual("PID2");
+      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 linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "PID",
+        name: "Schematic",
         data: { one: 1 },
       });
       await client.workspaces.linePlot.setData(linePlot.key, { two: 2 });
@@ -64,11 +64,11 @@ describe("LinePlot", () => {
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({
-        name: "PID",
+        name: "Schematic",
         layout: { one: 1 },
       });
       const linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "PID",
+        name: "Schematic",
         data: { one: 1 },
       });
       await client.workspaces.linePlot.delete(linePlot.key);

package/src/workspace/lineplot/payload.ts

@@ -7,7 +7,7 @@
 // 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();

package/src/workspace/lineplot/retriever.ts

@@ -8,14 +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 LinePlot,
-  type Params,
-  linePlotZ,
-} from "@/workspace/lineplot/payload";
+import { type LinePlot, type Params, linePlotZ } from "@/workspace/lineplot/payload";
 
 const reqZ = z.object({
   keys: z.string().array(),
@@ -37,12 +33,8 @@ export class Retriever {
 
   async retrieve(params: Params): Promise<LinePlot[]> {
     const normalized = toArray(params);
-    return (await sendRequired(
-      this.client, 
-      this.ENDPOINT, 
-      { keys: normalized }, 
-      reqZ, 
-      resZ
-    )).linePlots;
+    return (
+      await sendRequired(this.client, this.ENDPOINT, { keys: normalized }, reqZ, resZ)
+    ).linePlots;
   }
 }

package/src/workspace/lineplot/writer.ts

@@ -8,7 +8,8 @@
 // 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 {
@@ -69,11 +70,11 @@ export class Writer {
   }
 
   async create(workspace: string, plot: NewLinePlot): Promise<LinePlot> {
-    const pid_ = { ...plot, data: JSON.stringify(plot.data) };
+    const schematic_ = { ...plot, data: JSON.stringify(plot.data) };
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
       CREATE_ENDPOINT,
-      { workspace, linePlots: [pid_] },
+      { workspace, linePlots: [schematic_] },
       createReqZ,
       createResZ,
     );
@@ -92,21 +93,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,
       setDataResZ,
     );

package/src/workspace/payload.ts

@@ -7,7 +7,8 @@
 // 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 { binary } from "@synnaxlabs/x/binary";
+import { type UnknownRecord, unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
 export const keyZ = z.string().uuid();
@@ -19,11 +20,13 @@ export type Params = Key | Key[];
 export const workspaceZ = z.object({
   name: z.string(),
   key: keyZ,
-  layout: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
+  layout: unknownRecordZ.or(
+    z.string().transform((s) => binary.JSON_ECD.decodeString(s) as UnknownRecord),
+  ),
 });
 
 export const workspaceRemoteZ = workspaceZ.omit({ layout: true }).extend({
-  layout: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+  layout: z.string().transform((s) => binary.JSON_ECD.decodeString(s) as UnknownRecord),
 });
 
 export type Workspace = z.infer<typeof workspaceZ>;

package/src/workspace/retriever.ts

@@ -8,7 +8,7 @@
 // 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 {

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

@@ -8,11 +8,11 @@
 // included in the file licenses/APL.txt.
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord } from "@synnaxlabs/x";
+import { type UnknownRecord } from "@synnaxlabs/x/record";
 
-import { type Key, type Params, type PID } from "@/workspace/pid/payload";
-import { Retriever } from "@/workspace/pid/retriever";
-import { Writer, type NewPID } from "@/workspace/pid/writer";
+import { type Key, type Params, type Schematic } from "@/workspace/schematic/payload";
+import { Retriever } from "@/workspace/schematic/retriever";
+import { Writer, type NewSchematic } from "@/workspace/schematic/writer";
 
 export class Client {
   private readonly writer: Writer;
@@ -23,8 +23,8 @@ export class Client {
     this.retriever = new Retriever(client);
   }
 
-  async create(workspace: string, pid: NewPID): Promise<PID> {
-    return await this.writer.create(workspace, pid);
+  async create(workspace: string, schematic: NewSchematic): Promise<Schematic> {
+    return await this.writer.create(workspace, schematic);
   }
 
   async rename(key: Key, name: string): Promise<void> {
@@ -35,11 +35,11 @@ export class Client {
     await this.writer.setData(key, data);
   }
 
-  async retrieve(key: Key): Promise<PID>;
+  async retrieve(key: Key): Promise<Schematic>;
 
-  async retrieve(keys: Key[]): Promise<PID[]>;
+  async retrieve(keys: Key[]): Promise<Schematic[]>;
 
-  async retrieve(keys: Params): Promise<PID | PID[]> {
+  async retrieve(keys: Params): Promise<Schematic | Schematic[]> {
     const isMany = Array.isArray(keys);
     const res = await this.retriever.retrieve(keys);
     return isMany ? res : res[0];
@@ -49,7 +49,7 @@ export class Client {
     await this.writer.delete(keys);
   }
 
-  async copy(key: Key, name: string, snapshot: boolean): Promise<PID> {
+  async copy(key: Key, name: string, snapshot: boolean): Promise<Schematic> {
     return await this.writer.copy(key, name, snapshot);
   }
 }