@synnaxlabs/client 0.30.0 → 0.31.0

package/src/access/policy/writer.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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import {
+  type Key,
+  keyZ,
+  type NewPolicy,
+  newPolicyZ,
+  type Policy,
+  policyZ,
+} from "@/access/policy/payload";
+
+const createReqZ = z.object({ policies: policyZ.partial({ key: true }).array() });
+const createResZ = z.object({ policies: policyZ.array() });
+
+const deleteReqZ = z.object({ keys: keyZ.array() });
+const deleteResZ = z.object({});
+
+const CREATE_ENDPOINT = "/access/policy/create";
+const DELETE_ENDPOINT = "/access/policy/delete";
+
+export class Writer {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(policies: NewPolicy | NewPolicy[]): Promise<Policy[]> {
+    const parsedPolicies = newPolicyZ.array().parse(toArray(policies));
+    const req = parsedPolicies.map((policy) => ({
+      objects: toArray(policy.objects),
+      actions: toArray(policy.actions),
+      subjects: toArray(policy.subjects),
+    }));
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { policies: req },
+      createReqZ,
+      createResZ,
+    );
+    return res.policies;
+  }
+
+  async delete(keys: Key | Key[]): Promise<void> {
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: toArray(keys) },
+      deleteReqZ,
+      deleteResZ,
+    );
+  }
+}

package/src/auth/auth.ts

@@ -7,36 +7,43 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type Middleware, type UnaryClient } from "@synnaxlabs/freighter";
+import { type Middleware, sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
 import { InvalidTokenError } from "@/errors";
 import { user } from "@/user";
 
-export const insecureCredentialsZ = z.object({
+const insecureCredentialsZ = z.object({
   username: z.string(),
   password: z.string(),
 });
-export type InsecureCredentials = z.infer<typeof insecureCredentialsZ>;
+type InsecureCredentials = z.infer<typeof insecureCredentialsZ>;
 
-export const tokenResponseZ = z.object({
+const tokenResponseZ = z.object({
   token: z.string(),
-  user: user.payloadZ,
+  user: user.userZ,
 });
 
-export type TokenResponse = z.infer<typeof tokenResponseZ>;
-
 const LOGIN_ENDPOINT = "/auth/login";
 
 const MAX_RETRIES = 3;
 
+const CHANGE_PASSWORD_ENDPOINT = "/auth/change-password";
+
+const changePasswordReqZ = z.object({
+  username: z.string(),
+  password: z.string(),
+  newPassword: z.string().min(1),
+});
+const changePasswordResZ = z.object({});
+
 export class Client {
   token: string | undefined;
   private readonly client: UnaryClient;
   private readonly credentials: InsecureCredentials;
-  private authenticating: Promise<Error | null> | undefined;
+  authenticating: Promise<Error | null> | undefined;
   authenticated: boolean;
-  user: user.Payload | undefined;
+  user: user.User | undefined;
   private retryCount: number;
 
   constructor(client: UnaryClient, credentials: InsecureCredentials) {
@@ -46,6 +53,22 @@ export class Client {
     this.retryCount = 0;
   }
 
+  async changePassword(newPassword: string): Promise<void> {
+    if (!this.authenticated) throw new Error("Not authenticated");
+    await sendRequired<typeof changePasswordReqZ, typeof changePasswordResZ>(
+      this.client,
+      CHANGE_PASSWORD_ENDPOINT,
+      {
+        username: this.credentials.username,
+        password: this.credentials.password,
+        newPassword,
+      },
+      changePasswordReqZ,
+      changePasswordResZ,
+    );
+    this.credentials.password = newPassword;
+  }
+
   middleware(): Middleware {
     const mw: Middleware = async (reqCtx, next) => {
       if (!this.authenticated && !reqCtx.target.endsWith(LOGIN_ENDPOINT)) {
@@ -54,7 +77,6 @@ export class Client {
             this.client
               .send(
                 LOGIN_ENDPOINT,
-
                 this.credentials,
                 insecureCredentialsZ,
                 tokenResponseZ,

package/src/channel/payload.ts

@@ -48,7 +48,7 @@ export const newPayload = payload.extend({
 
 export type NewPayload = z.input<typeof newPayload>;
 
-export const ChannelOntologyType = "channel" as ontology.ResourceType;
+export const ONTOLOGY_TYPE: ontology.ResourceType = "channel";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ChannelOntologyType, key: key.toString() });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });

package/src/framer/client.ts

@@ -24,6 +24,12 @@ import { Frame } from "@/framer/frame";
 import { Iterator, IteratorConfig } from "@/framer/iterator";
 import { Streamer, type StreamerConfig } from "@/framer/streamer";
 import { Writer, type WriterConfig, WriterMode } from "@/framer/writer";
+import { ontology } from "@/ontology";
+
+export const ONTOLOGY_TYPE: ontology.ResourceType = "framer";
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });
 
 export class Client {
   private readonly streamClient: StreamClient;
@@ -93,7 +99,7 @@ export class Client {
 
   async openStreamer(config: StreamerConfig | Params): Promise<Streamer> {
     if (Array.isArray(config) || typeof config !== "object")
-      config = { channels: config as Params };
+      config = { channels: config as Params, downsampleFactor: 1 };
     return await Streamer._open(this.retriever, this.streamClient, config);
   }
 

package/src/framer/frame.spec.ts

@@ -75,19 +75,28 @@ describe("framer.Frame", () => {
         expect(f.colType).toEqual("name");
       });
 
-      test("from payload", () => {
-        const f = new framer.Frame({
-          keys: [12],
-          series: [
-            {
-              dataType: new DataType("float32"),
-              data: new SharedArrayBuffer(12),
-            },
-          ],
+      describe("payload parsing", () => {
+        it("should correctly parse a series payload", () => {
+          const f = new framer.Frame({
+            keys: [12],
+            series: [
+              { dataType: new DataType("float32"), data: new SharedArrayBuffer(12) },
+            ],
+          });
+          expect(f.length.valueOf()).toEqual(3);
+          expect(f.columns.length).toEqual(1);
+          expect(f.series.length).toEqual(1);
+        });
+
+        it("should correctly parse a series with null data", () => {
+          const f = new framer.Frame({
+            keys: [12],
+            series: [{ dataType: "float32", data: null }],
+          });
+          expect(f.length.valueOf()).toEqual(0);
+          expect(f.columns.length).toEqual(1);
+          expect(f.series.length).toEqual(1);
         });
-        expect(f.length.valueOf()).toEqual(3);
-        expect(f.columns.length).toEqual(1);
-        expect(f.series.length).toEqual(1);
       });
 
       test("from record", () => {

package/src/framer/frame.ts

@@ -8,9 +8,9 @@
 // included in the file licenses/APL.txt.
 
 import {
-  DataType,
   MultiSeries,
   Series,
+  SeriesPayload,
   Size,
   type TelemValue,
   TimeRange,
@@ -55,7 +55,7 @@ const validateMatchedColsAndSeries = (columns: Params, series: Series[]): void =
 
 export type CrudeFrame =
   | Frame
-  | FramePayload
+  | CrudeFramePayload
   | Map<KeyOrName, Series[] | Series>
   | Record<KeyOrName, Series[] | Series>;
 
@@ -117,6 +117,8 @@ export class Frame {
     if (isObject) {
       if ("keys" in columnsOrData && "series" in columnsOrData) {
         const data_ = columnsOrData as FramePayload;
+        data_.series ??= [];
+        data_.keys ??= [];
         const series = data_.series.map((a) => seriesFromPayload(a));
         validateMatchedColsAndSeries(data_.keys, series);
         data_.keys.forEach((key, i) => this.push(key, series[i]));
@@ -396,37 +398,20 @@ export class Frame {
   }
 }
 
-export const series = z.object({
-  timeRange: TimeRange.z.optional(),
-  alignment: z
-    .bigint()
-    .or(z.string().transform((s) => BigInt(s)))
-    .optional(),
-  dataType: DataType.z,
-  data: z.string().transform(
-    (s) =>
-      new Uint8Array(
-        atob(s)
-          .split("")
-          .map((c) => c.charCodeAt(0)),
-      ).buffer,
-  ),
-});
-
-export type SeriesPayload = z.infer<typeof series>;
-
 export const frameZ = z.object({
   keys: z.union([
     z.null().transform(() => [] as number[]),
     z.number().array().optional().default([]),
   ]),
   series: z.union([
-    z.null().transform(() => [] as Array<z.infer<typeof series>>),
-    series.array().optional().default([]),
+    z.null().transform(() => [] as Array<z.infer<typeof Series.crudeZ>>),
+    Series.crudeZ.array().optional().default([]),
   ]),
 });
 
-export type FramePayload = z.infer<typeof frameZ>;
+export type FramePayload = z.output<typeof frameZ>;
+
+export type CrudeFramePayload = z.input<typeof frameZ>;
 
 export const seriesFromPayload = (series: SeriesPayload): Series => {
   const { dataType, data, timeRange, alignment } = series;

package/src/framer/streamer.spec.ts

@@ -50,4 +50,52 @@ describe("Streamer", () => {
   it("should throw an error when the streamer is opened with a channel that does not exist", async () => {
     await expect(client.openStreamer([5678])).rejects.toThrow("not found");
   });
+  test("downsample factor of 1", async () => {
+    const ch = await newChannel();
+    const streamer = await client.openStreamer({channels: ch.key, downsampleFactor: 1});
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const writer = await client.openWriter({
+      start: TimeStamp.now(),
+      channels: ch.key,
+    });
+    try {
+      await writer.write(ch.key, new Float64Array([1, 2, 3, 4, 5]));
+    } finally {
+      await writer.close();
+    }
+    const d = await streamer.read();
+    expect(Array.from(d.get(ch.key))).toEqual([1, 2, 3, 4, 5]);
+  });
+test("downsample factor of 2", async () => {
+    const ch = await newChannel();
+    const streamer = await client.openStreamer({channels: ch.key, downsampleFactor: 2});
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const writer = await client.openWriter({
+      start: TimeStamp.now(),
+      channels: ch.key,
+    });
+    try {
+      await writer.write(ch.key, new Float64Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));
+    } finally {
+      await writer.close();
+    }
+    const d = await streamer.read();
+    expect(Array.from(d.get(ch.key))).toEqual([1, 3, 5, 7, 9]);
+  });
+test("downsample factor of 10", async () => {
+    const ch = await newChannel();
+    const streamer = await client.openStreamer({channels: ch.key, downsampleFactor: 10});
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const writer = await client.openWriter({
+      start: TimeStamp.now(),
+      channels: ch.key,
+    });
+    try {
+      await writer.write(ch.key, new Float64Array([1, 2, 3, 4, 5, 6,7,8,9,10]));
+    } finally {
+      await writer.close();
+    }
+    const d = await streamer.read();
+    expect(Array.from(d.get(ch.key))).toEqual([1]);
+  });
 });

package/src/framer/streamer.ts

@@ -17,7 +17,7 @@ import { ReadFrameAdapter } from "@/framer/adapter";
 import { Frame, frameZ } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
 
-const reqZ = z.object({ keys: z.number().array() });
+const reqZ = z.object({ keys: z.number().array() , downsampleFactor: z.number() });
 
 const resZ = z.object({
   frame: frameZ,
@@ -28,11 +28,13 @@ const ENDPOINT = "/frame/stream";
 
 export interface StreamerConfig {
   channels: Params;
+  downsampleFactor?: number;
 }
 
 export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
   private readonly adapter: ReadFrameAdapter;
+  private readonly downsampleFactor: number;
 
   private constructor(
     stream: Stream<typeof reqZ, typeof resZ>,
@@ -40,6 +42,7 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
   ) {
     this.stream = new StreamProxy("Streamer", stream);
     this.adapter = adapter;
+    this.downsampleFactor = 1;
   }
 
   get keys(): Key[] {
@@ -49,12 +52,12 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
   static async _open(
     retriever: Retriever,
     client: StreamClient,
-    { channels }: StreamerConfig,
+    { channels, downsampleFactor }: StreamerConfig,
   ): Promise<Streamer> {
     const adapter = await ReadFrameAdapter.open(retriever, channels);
     const stream = await client.stream(ENDPOINT, reqZ, resZ);
     const streamer = new Streamer(stream, adapter);
-    stream.send({ keys: adapter.keys });
+    stream.send({ keys: adapter.keys, downsampleFactor: downsampleFactor ?? 1 });
     const [, err] = await stream.receive();
     if (err != null) throw err;
     return streamer;
@@ -76,7 +79,7 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
 
   async update(channels: Params): Promise<void> {
     await this.adapter.update(channels);
-    this.stream.send({ keys: this.adapter.keys });
+    this.stream.send({ keys: this.adapter.keys, downsampleFactor: this.downsampleFactor });
   }
 
   close(): void {

package/src/framer/writer.ts

@@ -231,7 +231,6 @@ export class Writer {
     series?: CrudeSeries | CrudeSeries[],
   ): Promise<boolean> {
     const frame = await this.adapter.adapt(channelsOrData, series);
-    // @ts-expect-error - zod issues
     this.stream.send({ command: Command.Write, frame: frame.toPayload() });
     return true;
   }
@@ -298,7 +297,6 @@ export class Writer {
   }
 
   async execute(req: Request): Promise<Response> {
-    // @ts-expect-error - frame payload adjustments
     this.stream.send(req);
     while (true) {
       const res = await this.stream.receive();

package/src/hardware/device/payload.ts

@@ -47,7 +47,7 @@ export type NewDevice<P extends UnknownRecord = UnknownRecord> = Omit<
   "properties"
 > & { properties: P };
 
-export const DeviceOntologyType = "device" as ontology.ResourceType;
+export const ONTOLOGY_TYPE: ontology.ResourceType = "device";
 
 export const ontologyID = (key: DeviceKey): ontology.ID =>
-  new ontology.ID({ type: DeviceOntologyType, key: key.toString() });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });

package/src/hardware/rack/payload.ts

@@ -26,7 +26,7 @@ export const newRackZ = rackZ.partial({ key: true });
 
 export type NewRack = z.input<typeof newRackZ>;
 
-export const RackOntologyType = "rack" as ontology.ResourceType;
+export const ONTOLOGY_TYPE: ontology.ResourceType = "rack";
 
 export const ontologyID = (key: RackKey): ontology.ID =>
-  new ontology.ID({ type: RackOntologyType, key: key.toString() });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });

package/src/hardware/task/payload.ts

@@ -96,7 +96,7 @@ export const commandZ = z.object({
 export type StateObservable<D extends UnknownRecord = UnknownRecord> =
   observe.ObservableAsyncCloseable<State<D>>;
 
-export const DeviceOntologyType = "task" as ontology.ResourceType;
+export const ONTOLOGY_TYPE: ontology.ResourceType = "task";
 
 export const ontologyID = (key: TaskKey): ontology.ID =>
-  new ontology.ID({ type: DeviceOntologyType, key: key.toString() });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });

package/src/index.ts

@@ -7,6 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+export { access } from "@/access";
+export { policy } from "@/access/policy";
 export * from "@/channel";
 export { Channel } from "@/channel/client";
 export { default as Synnax, type SynnaxProps, synnaxPropsZ } from "@/client";
@@ -32,29 +34,30 @@ export { label } from "@/label";
 export { ontology } from "@/ontology";
 export { ranger } from "@/ranger";
 export { signals } from "@/signals";
+export { user } from "@/user";
 export { workspace } from "@/workspace";
-export type {
-  CrudeDataType,
-  CrudeDensity,
-  CrudeRate,
-  CrudeSize,
-  CrudeTimeSpan,
-  CrudeTimeStamp,
-  NumericTelemValue,
-  TelemValue,
-  TimeStampStringFormat,
-  TypedArray,
-  TZInfo,
-} from "@synnaxlabs/x/telem";
+export { linePlot } from "@/workspace/lineplot";
+export { schematic } from "@/workspace/schematic";
 export {
+  type CrudeDataType,
+  type CrudeDensity,
+  type CrudeRate,
+  type CrudeSize,
+  type CrudeTimeSpan,
+  type CrudeTimeStamp,
   DataType,
   Density,
   MultiSeries,
+  type NumericTelemValue,
   Rate,
   Series,
+  type TelemValue,
   TimeRange,
   TimeSpan,
   TimeStamp,
+  type TimeStampStringFormat,
+  type TypedArray,
+  type TZInfo,
 } from "@synnaxlabs/x/telem";
 import { control } from "@synnaxlabs/x";
 export const Authority = control.Authority;

package/src/label/payload.ts

@@ -25,7 +25,7 @@ export const labelZ = z.object({
 
 export type Label = z.infer<typeof labelZ>;
 
-export const LabelOntologyType = "label" as ontology.ResourceType;
+export const ONTOLOGY_TYPE: ontology.ResourceType = "label";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: LabelOntologyType, key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/ontology/client.ts

@@ -13,19 +13,18 @@ import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { z } from "zod";
 
 import { QueryError } from "@/errors";
-import { framer } from "@/framer";
-import { Frame } from "@/framer/frame";
+import { type framer } from "@/framer";
 import { group } from "@/ontology/group";
 import {
-  CrudeID,
+  type CrudeID,
   ID,
-  IDPayload,
+  type IDPayload,
   idZ,
   parseRelationship,
-  RelationshipChange,
-  RelationshipDirection,
+  type RelationshipChange,
+  type RelationshipDirection,
   type Resource,
-  ResourceChange,
+  type ResourceChange,
   resourceSchemaZ,
   resourceTypeZ,
 } from "@/ontology/payload";
@@ -92,12 +91,12 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Retrieves the resource in the ontology with the given ID.
-   * @param id The ID of the resource to retrieve.
-   * @param options Additional options for the retrieval.
-   * @param options.includeSchema Whether to include the schema of the resource in the
+   * @param id - The ID of the resource to retrieve.
+   * @param options - Additional options for the retrieval.
+   * @param options.includeSchema - Whether to include the schema of the resource in the
    * results.
-   * @param options.excludeFieldData Whether to exclude the field data of the resource in
-   * the results.
+   * @param options.excludeFieldData - Whether to exclude the field data of the resource
+   * in the results.
    * @returns The resource with the given ID.
    * @throws {QueryError} If no resource is found with the given ID.
    */
@@ -105,12 +104,13 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Retrieves the resources in the ontology with the given IDs.
-   * @param ids The IDs of the resources to retrieve.
-   * @param options Additional options for the retrieval.
-   * @param options.includeSchema Whether to include the schema of the resources in the
-   * results.
-   * @param options.excludeFieldData Whether to exclude the field data of the resources in
+   *
+   * @param ids - The IDs of the resources to retrieve.
+   * @param options - Additional options for the retrieval.
+   * @param options.includeSchema - Whether to include the schema of the resources in
    * the results.
+   * @param options.excludeFieldData - Whether to exclude the field data of the
+   * resources in the results.
    * @returns The resources with the given IDs.
    * @throws {QueryError} If no resource is found with any of the given IDs.
    */
@@ -164,10 +164,12 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
   /**
    * Retrieves the parents of the resources with the given IDs.
    *
-   * @param ids the IDs of the resources whose parents to retrieve
-   * @param options additional options for the retrieval
-   * @param options.includeSchema whether to include the schema of the parents in the results
-   * @param options.excludeFieldData whether to exclude the field data of the parents in the results
+   * @param ids - the IDs of the resources whose parents to retrieve
+   * @param options - additional options for the retrieval
+   * @param options.includeSchema - whether to include the schema of the parents in the
+   * results
+   * @param options.excludeFieldData - whether to exclude the field data of the parents
+   * in the results
    * @returns the parents of the resources with the given IDs
    */
   async retrieveParents(
@@ -179,8 +181,8 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Adds children to a resource in the ontology.
-   * @param id The ID of the resource to add children to.
-   * @param children The IDs of the children to add.
+   * @param id - The ID of the resource to add children to.
+   * @param children - The IDs of the children to add.
    */
   async addChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
     return await this.writer.addChildren(id, ...children);
@@ -188,9 +190,8 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Removes children from a resource in the ontology.
-   * @param id The ID of the resource to remove children from.
-   * @param children The IDs of the children
-   * to remove.
+   * @param id - The ID of the resource to remove children from.
+   * @param children - The IDs of the children to remove.
    */
   async removeChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
     return await this.writer.removeChildren(id, ...children);
@@ -198,9 +199,9 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
 
   /**
    * Moves children from one resource to another in the ontology.
-   * @param from The ID of the resource to move children from.
-   * @param to The ID of the resource to move children to.
-   * @param children The IDs of the children to move.
+   * @param from - The ID of the resource to move children from.
+   * @param to - The ID of the resource to move children to.
+   * @param children - The IDs of the children to move.
    */
   async moveChildren(
     from: CrudeID,
@@ -294,7 +295,7 @@ export class ChangeTracker {
     }
   }
 
-  private async update(frame: Frame): Promise<void> {
+  private async update(frame: framer.Frame): Promise<void> {
     const resSets = await this.parseResourceSets(frame);
     const resDeletes = this.parseResourceDeletes(frame);
     const allResources = resSets.concat(resDeletes);
@@ -306,7 +307,7 @@ export class ChangeTracker {
       this.relationshipObs.notify(relSets.concat(relDeletes));
   }
 
-  private parseRelationshipSets(frame: Frame): RelationshipChange[] {
+  private parseRelationshipSets(frame: framer.Frame): RelationshipChange[] {
     const relationships = frame.get(RELATIONSHIP_SET_NAME);
     if (relationships.length === 0) return [];
     return Array.from(relationships.as("string")).map((rel) => ({
@@ -316,7 +317,7 @@ export class ChangeTracker {
     }));
   }
 
-  private parseRelationshipDeletes(frame: Frame): RelationshipChange[] {
+  private parseRelationshipDeletes(frame: framer.Frame): RelationshipChange[] {
     const relationships = frame.get(RELATIONSHIP_DELETE_NAME);
     if (relationships.length === 0) return [];
     return Array.from(relationships.as("string")).map((rel) => ({
@@ -325,7 +326,7 @@ export class ChangeTracker {
     }));
   }
 
-  private async parseResourceSets(frame: Frame): Promise<ResourceChange[]> {
+  private async parseResourceSets(frame: framer.Frame): Promise<ResourceChange[]> {
     const sets = frame.get(RESOURCE_SET_NAME);
     if (sets.length === 0) return [];
     // We should only ever get one series of sets
@@ -343,7 +344,7 @@ export class ChangeTracker {
     }
   }
 
-  private parseResourceDeletes(frame: Frame): ResourceChange[] {
+  private parseResourceDeletes(frame: framer.Frame): ResourceChange[] {
     const deletes = frame.get(RESOURCE_DELETE_NAME);
     if (deletes.length === 0) return [];
     // We should only ever get one series of deletes