@synnaxlabs/client 0.55.0 → 0.56.1

package/src/framer/iterator.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 Stream, type StreamClient } from "@synnaxlabs/freighter";
+import { type Stream, type WebSocketClient } from "@synnaxlabs/freighter";
 import {
   type CrudeTimeRange,
   type CrudeTimeSpan,
@@ -21,31 +21,15 @@ import { z } from "zod";
 
 import { channel } from "@/channel";
 import { ReadAdapter } from "@/framer/adapter";
+import { WSIteratorCodec } from "@/framer/codec";
 import { Frame, frameZ } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
+import { IteratorCommand, IteratorResponseVariant } from "@/framer/types.gen";
 
 export const AUTO_SPAN = new TimeSpan(-1);
 
-enum Command {
-  Open = 0,
-  Next = 1,
-  Prev = 2,
-  SeekFirst = 3,
-  SeekLast = 4,
-  SeekLE = 5,
-  SeekGE = 6,
-  Valid = 7,
-  Error = 8,
-}
-
-enum ResponseVariant {
-  None = 0,
-  Ack = 1,
-  Data = 2,
-}
-
-const reqZ = z.object({
-  command: z.enum(Command),
+export const iteratorReqZ = z.object({
+  command: z.enum(IteratorCommand),
   span: TimeSpan.z.optional(),
   bounds: TimeRange.z.optional(),
   stamp: TimeStamp.z.optional(),
@@ -53,16 +37,19 @@ const reqZ = z.object({
   chunkSize: z.number().optional(),
   downsampleFactor: z.int().optional(),
 });
-interface Request extends z.infer<typeof reqZ> {}
 
-const resZ = z.object({
-  variant: z.enum(ResponseVariant),
+export interface IteratorRequest extends z.infer<typeof iteratorReqZ> {}
+
+export const iteratorResZ = z.object({
+  variant: z.enum(IteratorResponseVariant),
   ack: z.boolean(),
-  command: z.enum(Command),
+  command: z.enum(IteratorCommand),
   error: errors.payloadZ.optional().nullable(),
   frame: frameZ.optional(),
 });
 
+export interface IteratorResponse extends z.infer<typeof iteratorResZ> {}
+
 export interface IteratorConfig {
   /** chunkSize is the maximum number of samples contained per channel in the frame
    * resulting from a call to next with {@link AUTO_SPAN}.
@@ -84,11 +71,14 @@ export interface IteratorConfig {
  *  telemetry between two timestamps, see the SegmentClient.read method.
  */
 export class Iterator {
-  private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
+  private readonly stream: StreamProxy<typeof iteratorReqZ, typeof iteratorResZ>;
   private readonly adapter: ReadAdapter;
   value: Frame;
 
-  private constructor(stream: Stream<typeof reqZ, typeof resZ>, adapter: ReadAdapter) {
+  private constructor(
+    stream: Stream<typeof iteratorReqZ, typeof iteratorResZ>,
+    adapter: ReadAdapter,
+  ) {
     this.stream = new StreamProxy("Iterator", stream);
     this.value = new Frame();
     this.adapter = adapter;
@@ -109,14 +99,15 @@ export class Iterator {
     tr: CrudeTimeRange,
     channels: channel.Params,
     retriever: channel.Retriever,
-    client: StreamClient,
+    client: WebSocketClient,
     opts: IteratorConfig = {},
   ): Promise<Iterator> {
     const adapter = await ReadAdapter.open(retriever, channels);
-    const stream = await client.stream("/frame/iterate", reqZ, resZ);
+    client = client.withCodec(new WSIteratorCodec(adapter.codec));
+    const stream = await client.stream("/frame/iterate", iteratorReqZ, iteratorResZ);
     const iter = new Iterator(stream, adapter);
     await iter.execute({
-      command: Command.Open,
+      command: IteratorCommand.Open,
       keys: Array.from(adapter.keys),
       bounds: new TimeRange(tr),
       chunkSize: opts.chunkSize ?? 1e5,
@@ -137,7 +128,10 @@ export class Iterator {
    * particular channel or the iterator has accumulated an error.
    */
   async next(span: CrudeTimeSpan = AUTO_SPAN): Promise<boolean> {
-    return await this.execute({ command: Command.Next, span: new TimeSpan(span) });
+    return await this.execute({
+      command: IteratorCommand.Next,
+      span: new TimeSpan(span),
+    });
   }
 
   /**
@@ -152,7 +146,10 @@ export class Iterator {
    * channel or the iterator has accumulated an error.
    */
   async prev(span: CrudeTimeSpan = AUTO_SPAN): Promise<boolean> {
-    return await this.execute({ command: Command.Prev, span: new TimeSpan(span) });
+    return await this.execute({
+      command: IteratorCommand.Prev,
+      span: new TimeSpan(span),
+    });
   }
 
   /**
@@ -164,7 +161,7 @@ export class Iterator {
    * channel or has accumulated an error.
    */
   async seekFirst(): Promise<boolean> {
-    return await this.execute({ command: Command.SeekFirst });
+    return await this.execute({ command: IteratorCommand.SeekFirst });
   }
 
   /** Seeks the iterator to the last segment in the time range, but does not read it.
@@ -175,7 +172,7 @@ export class Iterator {
    * channel or has accumulated an error.
    */
   async seekLast(): Promise<boolean> {
-    return await this.execute({ command: Command.SeekLast });
+    return await this.execute({ command: IteratorCommand.SeekLast });
   }
 
   /**
@@ -187,7 +184,10 @@ export class Iterator {
    * channel or has accumulated an error.
    */
   async seekLE(stamp: CrudeTimeStamp): Promise<boolean> {
-    return await this.execute({ command: Command.SeekLE, stamp: new TimeStamp(stamp) });
+    return await this.execute({
+      command: IteratorCommand.SeekLE,
+      stamp: new TimeStamp(stamp),
+    });
   }
 
   /**
@@ -199,7 +199,10 @@ export class Iterator {
    * channel or has accumulated an error.
    */
   async seekGE(stamp: CrudeTimeStamp): Promise<boolean> {
-    return await this.execute({ command: Command.SeekGE, stamp: new TimeStamp(stamp) });
+    return await this.execute({
+      command: IteratorCommand.SeekGE,
+      stamp: new TimeStamp(stamp),
+    });
   }
 
   /**
@@ -208,7 +211,7 @@ export class Iterator {
    * an error.
    */
   async valid(): Promise<boolean> {
-    return await this.execute({ command: Command.Valid });
+    return await this.execute({ command: IteratorCommand.Valid });
   }
 
   /**
@@ -224,12 +227,12 @@ export class Iterator {
     return new IteratorIterator(this);
   }
 
-  private async execute(request: Request): Promise<boolean> {
+  private async execute(request: IteratorRequest): Promise<boolean> {
     this.stream.send(request);
     this.value = new Frame();
     while (true) {
       const res = await this.stream.receive();
-      if (res.variant === ResponseVariant.Ack) return res.ack;
+      if (res.variant === IteratorResponseVariant.Ack) return res.ack;
       this.value.push(this.adapter.adapt(new Frame(res.frame)));
     }
   }
@@ -255,7 +258,7 @@ class IteratorIterator implements AsyncIterator<Frame> {
       return { done: !ok, value: this.iter.value };
     } catch (e) {
       await this.iter.close();
-      throw e;
+      throw errors.fromUnknown(e);
     }
   }
 }

package/src/framer/streamProxy.ts

@@ -8,8 +8,11 @@
 // included in the file licenses/APL.txt.
 
 import { EOF, type Stream } from "@synnaxlabs/freighter";
+import { errors } from "@synnaxlabs/x";
 import { type z } from "zod";
 
+import { UnexpectedError } from "@/errors";
+
 export class StreamProxy<RQ extends z.ZodType, RS extends z.ZodType> {
   readonly name: string;
   private readonly stream: Stream<RQ, RS>;
@@ -20,9 +23,7 @@ export class StreamProxy<RQ extends z.ZodType, RS extends z.ZodType> {
   }
 
   async receive(): Promise<z.infer<RS>> {
-    const [res, err] = await this.stream.receive();
-    if (err != null) throw err;
-    return res;
+    return await this.stream.receive();
   }
 
   received(): boolean {
@@ -32,16 +33,16 @@ export class StreamProxy<RQ extends z.ZodType, RS extends z.ZodType> {
   async closeAndAck(): Promise<void> {
     this.stream.closeSend();
     while (true) {
-      const [res, err] = await this.stream.receive();
-      if (res != null)
-        console.warn(
-          `${this.name} received unexpected response on ${JSON.stringify(res)} closure.
-        Please report this error to the Synnax team.`,
-        );
-      if (err != null) {
+      let res: z.infer<RS>;
+      try {
+        res = await this.stream.receive();
+      } catch (err) {
         if (EOF.matches(err)) return;
-        throw err;
+        throw errors.fromUnknown(err);
       }
+      throw new UnexpectedError(
+        `${this.name} received unexpected response ${JSON.stringify(res)} on closure.`,
+      );
     }
   }
 
@@ -50,7 +51,6 @@ export class StreamProxy<RQ extends z.ZodType, RS extends z.ZodType> {
   }
 
   send(req: z.input<RQ>): void {
-    const err = this.stream.send(req);
-    if (err != null) throw err;
+    this.stream.send(req);
   }
 }

package/src/framer/streamer.spec.ts

@@ -8,7 +8,16 @@
 // included in the file licenses/APL.txt.
 
 import { EOF, Unreachable } from "@synnaxlabs/freighter";
-import { DataType, id, Rate, Series, sleep, TimeSpan, TimeStamp } from "@synnaxlabs/x";
+import {
+  DataType,
+  errors,
+  id,
+  Rate,
+  Series,
+  sleep,
+  TimeSpan,
+  TimeStamp,
+} from "@synnaxlabs/x";
 import { describe, expect, it, test, vi } from "vitest";
 
 import { type channel } from "@/channel";
@@ -552,7 +561,7 @@ describe("Streamer", () => {
         return { done: false, value: fr };
       } catch (err) {
         if (EOF.matches(err)) return { done: true, value: undefined };
-        throw err;
+        throw errors.fromUnknown(err);
       }
     }
 
@@ -565,7 +574,7 @@ describe("Streamer", () => {
     it("should correctly call the underlying streamer methods", async () => {
       const streamer = new MockStreamer();
       const openMock = vi.fn();
-      const config = { channels: [1, 2, 3], useHighPerformanceCodec: true };
+      const config = { channels: [1, 2, 3] };
       const fr = new Frame({ 1: new Series([1]) });
       const hardened = await HardenedStreamer.open(
         async (cfg) => {

package/src/framer/streamer.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { EOF, type Stream, type WebSocketClient } from "@synnaxlabs/freighter";
-import { breaker, observe, Rate, TimeSpan } from "@synnaxlabs/x";
+import { breaker, errors, observe, Rate, TimeSpan } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type channel } from "@/channel";
@@ -46,9 +46,6 @@ const intermediateStreamerConfigZ = z.object({
   downsampleFactor: z.int().default(1),
   /** Optional throttle rate in Hz to limit the rate of frames sent to the client. Defaults to 0 (no throttling). */
   throttleRate: Rate.z.default(new Rate(0)),
-  /** useHighPerformanceCodec sets whether the writer will use the Synnax frame encoder
-   as opposed to the standard JSON encoding mechanisms for frames. */
-  useHighPerformanceCodec: z.boolean().default(true),
   /** excludeGroups sets writer group IDs whose frames should be filtered out by the
    Core. Used for telemetry bypass deduplication. */
   excludeGroups: z.uint32().array().default([]),
@@ -112,8 +109,7 @@ export const createStreamOpener =
   async (config) => {
     const cfg = streamerConfigZ.parse(config);
     const adapter = await ReadAdapter.open(retriever, cfg.channels);
-    if (cfg.useHighPerformanceCodec)
-      client = client.withCodec(new WSStreamerCodec(adapter.codec));
+    client = client.withCodec(new WSStreamerCodec(adapter.codec));
     const stream = await client.stream("/frame/stream", reqZ, resZ);
     const streamer = new BaseStreamer(
       stream,
@@ -128,8 +124,7 @@ export const createStreamOpener =
       throttleRate: cfg.throttleRate,
       excludeGroups: cfg.excludeGroups,
     });
-    const [, err] = await stream.receive();
-    if (err != null) throw err;
+    await stream.receive();
     return streamer;
   };
 
@@ -177,7 +172,7 @@ class BaseStreamer implements Streamer {
       return { done: false, value: frame };
     } catch (err) {
       if (EOF.matches(err)) return { done: true, value: undefined };
-      throw err;
+      throw errors.fromUnknown(err);
     }
   }
 
@@ -256,7 +251,7 @@ export class HardenedStreamer implements Streamer {
         return;
       } catch (e) {
         this.wrapped_ = null;
-        if (!(await this.breaker.wait())) throw e;
+        if (!(await this.breaker.wait())) throw errors.fromUnknown(e);
         console.error("failed to open streamer", e);
         continue;
       }
@@ -282,7 +277,7 @@ export class HardenedStreamer implements Streamer {
       return { done: false, value: await this.read() };
     } catch (e) {
       if (EOF.matches(e)) return { done: true, value: undefined };
-      throw e;
+      throw errors.fromUnknown(e);
     }
   }
 
@@ -292,7 +287,7 @@ export class HardenedStreamer implements Streamer {
       this.breaker.reset();
       return fr;
     } catch (e) {
-      if (EOF.matches(e)) throw e;
+      if (EOF.matches(e)) throw errors.fromUnknown(e);
       await this.runStreamer();
       return await this.read();
     }

package/src/framer/types.gen.ts

@@ -18,3 +18,23 @@ export enum WriterCommand {
   SetAuthority = 3,
 }
 export const writerCommandZ = z.enum(WriterCommand);
+
+export enum IteratorCommand {
+  Open = 0,
+  Next = 1,
+  Prev = 2,
+  SeekFirst = 3,
+  SeekLast = 4,
+  SeekLE = 5,
+  SeekGE = 6,
+  Valid = 7,
+  Error = 8,
+}
+export const iteratorCommandZ = z.enum(IteratorCommand);
+
+export enum IteratorResponseVariant {
+  None = 0,
+  Ack = 1,
+  Data = 2,
+}
+export const iteratorResponseVariantZ = z.enum(IteratorResponseVariant);

package/src/framer/writer.spec.ts

@@ -115,6 +115,83 @@ describe("Writer", () => {
       expect(true).toBe(true);
     });
 
+    test("auto-index generates server-side timestamps for data-only writes", async () => {
+      const [index, data] = await newIndexedPair(client);
+      const before = TimeStamp.now();
+      const writer = await client.openWriter({
+        start: before,
+        channels: [data.key],
+        autoIndex: true,
+      });
+      try {
+        await writer.write(data.key, randomSeries(5, data.dataType));
+        await writer.commit();
+      } finally {
+        await writer.close();
+      }
+      const f = await client.read(
+        new TimeRange(before, TimeStamp.now().add(TimeSpan.seconds(1))),
+        index.key,
+      );
+      expect(f.length).toEqual(5);
+    });
+
+    test("auto-index mixes user-provided and generated timestamps in one writer", async () => {
+      const [index, data] = await newIndexedPair(client);
+      const userStamps = secondsLinspace(200, 2);
+      const beforeAuto = TimeStamp.now();
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(200),
+        channels: [index.key, data.key],
+        autoIndex: true,
+      });
+      try {
+        await writer.write({
+          [index.key]: userStamps,
+          [data.key]: randomSeries(2, data.dataType),
+        });
+        await writer.write(data.key, randomSeries(3, data.dataType));
+        await writer.commit();
+      } finally {
+        await writer.close();
+      }
+      const userF = await client.read(
+        new TimeRange(TimeStamp.seconds(200), TimeStamp.seconds(202)),
+        index.key,
+      );
+      expect(userF.data).toEqual(new BigInt64Array(userStamps.map((v) => v.valueOf())));
+      const autoF = await client.read(
+        new TimeRange(beforeAuto, TimeStamp.now().add(TimeSpan.seconds(1))),
+        index.key,
+      );
+      expect(autoF.length).toEqual(3);
+    });
+
+    test("auto-index leaves user-provided index data untouched", async () => {
+      const [index, data] = await newIndexedPair(client);
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(200),
+        channels: [index.key, data.key],
+        autoIndex: true,
+      });
+      try {
+        await writer.write({
+          [index.key]: secondsLinspace(200, 3),
+          [data.key]: randomSeries(3, data.dataType),
+        });
+        await writer.commit();
+      } finally {
+        await writer.close();
+      }
+      const f = await client.read(
+        new TimeRange(TimeStamp.seconds(200), TimeStamp.seconds(203)),
+        index.key,
+      );
+      expect(f.data).toEqual(
+        new BigInt64Array(secondsLinspace(200, 3).map((v) => v.valueOf())),
+      );
+    });
+
     test("write with auto commit and a set interval", async () => {
       const channels = await newIndexedPair(client);
       const writer = await client.openWriter({

package/src/framer/writer.ts

@@ -60,14 +60,14 @@ const baseWriterConfigZ = z.object({
   /** controlSubject sets the control subject of the writer. */
   controlSubject: control.subjectZ.optional(),
   /** authorities set the control authority to set for each channel on the writer.
-   * Defaults to absolute authority. If not working with concurrent control,
-   * it's best to leave this as the default.
+   * Defaults to absolute authority. If not working with concurrent control, it's best
+   * to leave this as the default.
    */
   authorities: z
     .union([control.authorityZ.transform((a) => [a]), control.authorityZ.array()])
     .default([control.ABSOLUTE_AUTHORITY]),
-  /** mode sets the persistence and streaming mode of the writer. The default
-   * mode is WriterModePersistStream.
+  /** mode sets the persistence and streaming mode of the writer. The default mode is
+   * WriterModePersistStream.
    */
   mode: writerModeZ.default(WriterMode.PersistStream),
   /**
@@ -76,19 +76,23 @@ const baseWriterConfigZ = z.object({
    */
   errOnUnauthorized: z.boolean().default(false),
   /**
-   * enableAutoCommit determines whether the writer will automatically commit.
-   * If enableAutoCommit is true, then the writer will commit after each write, and
-   * will flush that commit to index after the specified autoIndexPersistInterval.
+   * enableAutoCommit determines whether the writer will automatically commit. If
+   * enableAutoCommit is true, then the writer will commit after each write, and will
+   * flush that commit to index after the specified autoIndexPersistInterval.
    */
   enableAutoCommit: z.boolean().default(true),
   /** autoIndexPersistInterval sets the interval at which commits will be flushed to
    * disk. */
   autoIndexPersistInterval: TimeSpan.z.default(TimeSpan.SECOND),
-  /*
-   * useHighPerformanceCodec sets whether the writer will use the synnax frame
-   * encoder as opposed to the standard JSON encoding mechanisms for frames.
+  /**
+   * autoIndex causes Synnax to automatically generate timestamps for any index channel
+   * that is not included in a write call. The first sample in each write is stamped at
+   * the time the write is received, and subsequent samples are spaced 1 nanosecond
+   * apart. Generated timestamps are guaranteed to be strictly monotonic across all
+   * writes on the writer. If the writer is opened with data channels whose index
+   * channels are not included, those index channels are added implicitly.
    */
-  useHighPerformanceCodec: z.boolean().default(true),
+  autoIndex: z.boolean().default(false),
 });
 
 const netWriterConfigZ = baseWriterConfigZ.extend({
@@ -212,8 +216,7 @@ export class Writer {
   ): Promise<Writer> {
     const cfg = zod.parse(writerConfigZ, config);
     const adapter = await WriteAdapter.open(retriever, cfg.channels);
-    if (cfg.useHighPerformanceCodec)
-      client = client.withCodec(new WSWriterCodec(adapter.codec));
+    client = client.withCodec(new WSWriterCodec(adapter.codec));
     const stream = await client.stream("/frame/write", reqZ, resZ);
     const writer = new Writer(stream, adapter);
     await writer.execute({
@@ -245,13 +248,14 @@ export class Writer {
    * @param frame - The frame to write to the database. The frame must:
    *
    *    1. Have exactly one array for each key in the list of keys provided to the
-   *    writer's open method.
+   *       writer's open method.
    *    2. Have equal length arrays for each key.
    *    3. When writing to an index (i.e. TimeStamp) channel, the values must be
-   *    monotonically increasing.
+   *       monotonically increasing.
    *
-   * @returns false if the writer has accumulated an error. In this case, the caller
-   * should acknowledge the error by calling the error method or closing the writer.
+   * @throws if the writer has accumulated an error. Once write throws, all subsequent
+   * calls to write and commit will also throw, and the writer must be closed and
+   * re-opened to continue writing.
    */
   async write(
     channelsOrData:
@@ -263,7 +267,11 @@ export class Writer {
     if (this.closeErr != null) throw this.closeErr;
     if (this.stream.received()) return await this.close();
     const frame = await this.adapter.adapt(channelsOrData, series);
-    this.stream.send({ command: WriterCommand.Write, frame: frame.toPayload() });
+    try {
+      this.stream.send({ command: WriterCommand.Write, frame: frame.toPayload() });
+    } catch (err) {
+      if (!EOF.matches(err)) throw errors.fromUnknown(err);
+    }
   }
 
   async setAuthority(
@@ -283,9 +291,9 @@ export class Writer {
    * Commits the written frames to the database. Commit is synchronous, meaning that it
    * will not return until all frames have been committed to the database.
    *
-   * @returns false if the commit failed due to an error. In this case, the caller
-   * should acknowledge the error by calling the error method or closing the writer.
-   * After the caller acknowledges the error, they can attempt to commit again.
+   * @returns the timestamp of the last sample written to the writer.
+   * @throws if the commit fails or any previous writer method has thrown. Once commit
+   * throws, the writer must be closed and re-opened to continue use.
    */
   async commit(): Promise<TimeStamp> {
     if (this.closeErr != null) throw this.closeErr;
@@ -315,18 +323,33 @@ export class Writer {
         if (WriterClosedError.matches(this.closeErr)) return null;
         throw this.closeErr;
       }
-      const [res, err] = await this.stream.receive();
-      if (err != null) this.closeErr = EOF.matches(err) ? new WriterClosedError() : err;
-      else this.closeErr = errors.decode(res?.err);
+      try {
+        const res = await this.stream.receive();
+        this.closeErr = errors.decode(res?.err);
+      } catch (err) {
+        const e = errors.fromUnknown(err);
+        this.closeErr = EOF.matches(e) ? new WriterClosedError() : e;
+      }
     }
   }
 
   private async execute(req: WriteRequest): Promise<Response> {
-    const err = this.stream.send(req);
-    if (err != null) await this.closeInternal(err);
+    try {
+      this.stream.send(req);
+    } catch (err) {
+      // A send failure is always EOF or StreamClosed, never WriterClosedError, so
+      // closeInternal re-throws here and the receive loop below is reached only when
+      // the send succeeds.
+      await this.closeInternal(errors.fromUnknown(err));
+    }
     while (true) {
-      const [res, err] = await this.stream.receive();
-      if (err != null) await this.closeInternal(err);
+      let res: Response;
+      try {
+        res = await this.stream.receive();
+      } catch (err) {
+        await this.closeInternal(errors.fromUnknown(err));
+        continue;
+      }
       const resErr = errors.decode(res?.err);
       if (resErr != null) await this.closeInternal(resErr);
       if (res?.command == req.command) return res;

package/src/group/client.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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
 import z from "zod";
 
@@ -39,8 +39,7 @@ export class Client {
   }
 
   async create(args: CreateArgs): Promise<Group> {
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/ontology/create-group",
       args,
       createReqZ,
@@ -50,8 +49,7 @@ export class Client {
   }
 
   async rename(key: Key, name: string): Promise<void> {
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/ontology/rename-group",
       { key, name },
       renameReqZ,
@@ -60,8 +58,7 @@ export class Client {
   }
 
   async delete(keys: Key | Key[]): Promise<void> {
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/ontology/delete-group",
       { keys: array.toArray(keys) },
       deleteReqZ,

package/src/index.ts

@@ -8,6 +8,7 @@
 // included in the file licenses/APL.txt.
 
 export { access } from "@/access";
+export { actions } from "@/actions";
 export { arc } from "@/arc";
 export { channel } from "@/channel";
 export { Channel, isCalculated } from "@/channel/client";
@@ -67,7 +68,7 @@ export {
   TimeRange,
   TimeSpan,
   TimeStamp,
-  type TimeStampStringFormat,
+  type TimestampFormat,
+  type TimeZone,
   type TypedArray,
-  type TZInfo,
 } from "@synnaxlabs/x";