@synnaxlabs/client 0.53.0 → 0.54.0

package/src/framer/adapter.ts

@@ -108,7 +108,7 @@ export class WriteAdapter {
     return adapter;
   }
 
-  async adaptParams(data: channel.Params): Promise<channel.Keys> {
+  async adaptParams(data: channel.Params): Promise<channel.Key[]> {
     const arrParams = channel.paramsZ.parse(data);
     const keys = await Promise.all(
       arrParams.map(async (p) => await this.adaptToKey(p)),
@@ -135,14 +135,14 @@ export class WriteAdapter {
   }
 
   private async fetchChannel(
-    ch: channel.KeyOrName | channel.Payload,
+    ch: channel.Key | channel.Name | channel.Payload,
   ): Promise<channel.Payload> {
     const res = await this.retriever.retrieve(ch);
     if (res.length === 0) throw new Error(`Channel ${JSON.stringify(ch)} not found`);
     return res[0];
   }
 
-  private async adaptToKey(k: channel.KeyOrName): Promise<channel.Key> {
+  private async adaptToKey(k: channel.Key | channel.Name): Promise<channel.Key> {
     if (typeof k === "number") return k;
     const res = await this.fetchChannel(k);
     return res.key;
@@ -153,7 +153,10 @@ export class WriteAdapter {
   }
 
   async adapt(
-    columnsOrData: channel.Params | Record<channel.KeyOrName, CrudeSeries> | CrudeFrame,
+    columnsOrData:
+      | channel.Params
+      | Record<channel.Key | channel.Name, CrudeSeries>
+      | CrudeFrame,
     series?: CrudeSeries | CrudeSeries[],
   ): Promise<Frame> {
     if (typeof columnsOrData === "string" || typeof columnsOrData === "number") {

package/src/framer/client.ts

@@ -90,19 +90,19 @@ export class Client {
 
   async write(
     start: CrudeTimeStamp,
-    channel: channel.KeyOrName,
+    channel: channel.Key | channel.Name,
     data: CrudeSeries,
   ): Promise<void>;
 
   async write(
     start: CrudeTimeStamp,
-    channels: channel.KeysOrNames,
+    channels: channel.Key[] | channel.Name[],
     data: CrudeSeries[],
   ): Promise<void>;
 
   async write(
     start: CrudeTimeStamp,
-    data: Record<channel.KeyOrName, CrudeSeries>,
+    data: Record<channel.Key | channel.Name, CrudeSeries>,
   ): Promise<void>;
 
   /**
@@ -116,11 +116,11 @@ export class Client {
    */
   async write(
     start: CrudeTimeStamp,
-    channels: channel.Params | Record<channel.KeyOrName, CrudeSeries>,
+    channels: channel.Params | Record<channel.Key | channel.Name, CrudeSeries>,
     data?: CrudeSeries | CrudeSeries[],
   ): Promise<void> {
     if (data == null) {
-      const data_ = channels as Record<channel.KeyOrName, CrudeSeries>;
+      const data_ = channels as Record<channel.Key | channel.Name, CrudeSeries>;
       const w = await this.openWriter({
         start,
         channels: Object.keys(data_),
@@ -142,7 +142,10 @@ export class Client {
     await w.close();
   }
 
-  async read(tr: CrudeTimeRange, channel: channel.KeyOrName): Promise<MultiSeries>;
+  async read(
+    tr: CrudeTimeRange,
+    channel: channel.Key | channel.Name,
+  ): Promise<MultiSeries>;
   async read(tr: CrudeTimeRange, channels: channel.Params): Promise<Frame>;
   async read(request: ReadRequest): Promise<ReadableStream<Uint8Array>>;
   async read(
@@ -152,7 +155,7 @@ export class Client {
     if (!("start" in tr)) return this.reader.read(tr);
     const { single } = channel.analyzeParams(channels!);
     const fr = await this.readFrame(tr, channels!);
-    if (single) return fr.get(channels as channel.KeyOrName);
+    if (single) return fr.get(channels as channel.Key | channel.Name);
     return fr;
   }
 
@@ -170,7 +173,10 @@ export class Client {
     return frame;
   }
 
-  async readLatest(channel: channel.KeyOrName, n: number): Promise<MultiSeries>;
+  async readLatest(
+    channel: channel.Key | channel.Name,
+    n: number,
+  ): Promise<MultiSeries>;
 
   async readLatest(channels: channel.Params, n: number): Promise<Frame>;
 
@@ -180,7 +186,7 @@ export class Client {
   ): Promise<MultiSeries | Frame> {
     const { single } = channel.analyzeParams(channels);
     const fr = await this.readLatestNFrame(channels, n);
-    if (single) return fr.get(channels as channel.KeyOrName);
+    if (single) return fr.get(channels as channel.Key | channel.Name);
     return fr;
   }
 

package/src/framer/codec.spec.ts

@@ -21,14 +21,14 @@ import {
   WSWriterCodec,
 } from "@/framer/codec";
 import { Frame } from "@/framer/frame";
-import { WriterCommand } from "@/framer/payload";
+import { WriterCommand } from "@/framer/types.gen";
 import { type WriteRequest } from "@/framer/writer";
 
 describe("encoder", () => {
   describe("base codec", () => {
     interface Spec {
       name: string;
-      channels: channel.Keys;
+      channels: channel.Key[];
       dataTypes: DataType[];
       frame: framer.Frame;
     }
@@ -117,7 +117,7 @@ describe("encoder", () => {
         ),
       },
       {
-        name: "Different Time Ranges",
+        name: "All Same Non-Zero Time Range",
         channels: [1, 2],
         dataTypes: [DataType.UINT8, DataType.FLOAT32],
         frame: new framer.Frame(
@@ -126,12 +126,32 @@ describe("encoder", () => {
             new Series({
               dataType: DataType.UINT8,
               data: new Uint8Array([1]),
-              timeRange: new TimeStamp(0).spanRange(5),
+              timeRange: new TimeStamp(1000000000).spanRange(5000000000),
             }),
             new Series({
               dataType: DataType.FLOAT32,
               data: new Float32Array([1, 2, 3, 4]),
-              timeRange: new TimeStamp(0).spanRange(5),
+              timeRange: new TimeStamp(1000000000).spanRange(5000000000),
+            }),
+          ],
+        ),
+      },
+      {
+        name: "Different Non-Zero Time Ranges",
+        channels: [1, 2],
+        dataTypes: [DataType.UINT8, DataType.FLOAT32],
+        frame: new framer.Frame(
+          [1, 2],
+          [
+            new Series({
+              dataType: DataType.UINT8,
+              data: new Uint8Array([1]),
+              timeRange: new TimeStamp(1000000000).spanRange(5000000000),
+            }),
+            new Series({
+              dataType: DataType.FLOAT32,
+              data: new Float32Array([1, 2, 3, 4]),
+              timeRange: new TimeStamp(2000000000).spanRange(3000000000),
             }),
           ],
         ),

package/src/framer/codec.ts

@@ -20,8 +20,8 @@ import { type z } from "zod";
 import { type channel } from "@/channel";
 import { ValidationError } from "@/errors";
 import { type Frame, type Payload } from "@/framer/frame";
-import { WriterCommand } from "@/framer/payload";
 import { type StreamerResponse } from "@/framer/streamer";
+import { WriterCommand } from "@/framer/types.gen";
 import { type WriteRequest } from "@/framer/writer";
 
 const seriesPldLength = (series: SeriesPayload): number =>
@@ -57,7 +57,7 @@ const SEQ_NUM_SIZE = 4;
 const FLAGS_SIZE = 1;
 
 interface CodecState {
-  keys: channel.Keys;
+  keys: channel.Key[];
   keyDataTypes: Map<channel.Key, DataType>;
   hasVariableDataTypes: boolean;
 }
@@ -68,11 +68,11 @@ export class Codec {
   private currState: CodecState | undefined;
   private seqNum: number = 0;
 
-  constructor(keys: channel.Keys = [], dataTypes: DataType[] = []) {
+  constructor(keys: channel.Key[] = [], dataTypes: DataType[] = []) {
     if (keys.length > 0 || dataTypes.length > 0) this.update(keys, dataTypes);
   }
 
-  update(keys: channel.Keys, dataTypes: DataType[]): void {
+  update(keys: channel.Key[], dataTypes: DataType[]): void {
     this.seqNum++;
     const state = {
       keys,
@@ -97,7 +97,7 @@ export class Codec {
       `);
   }
 
-  encode(payload: unknown, startOffset: number = 0): Uint8Array {
+  encode(payload: unknown, startOffset: number = 0): Uint8Array<ArrayBuffer> {
     this.throwIfNotUpdated("encode");
     let src = payload as Payload;
     if (payload != null && typeof payload === "object" && "toPayload" in payload)
@@ -187,8 +187,9 @@ export class Codec {
 
     if (equalTimeRangesFlag && !timeRangesZeroFlag) {
       view.setBigUint64(offset, startTime?.valueOf() ?? 0n, true);
+      offset += TIMESTAMP_SIZE;
       view.setBigUint64(offset, endTime?.valueOf() ?? 0n, true);
-      offset += TIMESTAMP_SIZE * 2;
+      offset += TIMESTAMP_SIZE;
     }
 
     if (equalAlignmentsFlag && !zeroAlignmentsFlag) {
@@ -211,8 +212,9 @@ export class Codec {
       offset += series.data.byteLength;
       if (!equalTimeRangesFlag && !timeRangesZeroFlag) {
         view.setBigUint64(offset, series.timeRange?.start.valueOf() ?? 0n, true);
+        offset += TIMESTAMP_SIZE;
         view.setBigUint64(offset, series.timeRange?.end.valueOf() ?? 0n, true);
-        offset += TIMESTAMP_SIZE * 2;
+        offset += TIMESTAMP_SIZE;
       }
       if (!equalAlignmentsFlag && !zeroAlignmentsFlag) {
         view.setBigUint64(offset, series.alignment ?? 0n, true);
@@ -339,7 +341,7 @@ export class WSWriterCodec implements binary.Codec {
     this.lowPerfCodec = binary.JSON_CODEC;
   }
 
-  encode(payload: unknown): Uint8Array {
+  encode(payload: unknown): Uint8Array<ArrayBuffer> {
     const pld = payload as WebsocketMessage<WriteRequest>;
     if (pld.type == "close" || pld.payload?.command != WriterCommand.Write) {
       const data = this.lowPerfCodec.encode(pld);
@@ -375,7 +377,7 @@ export class WSStreamerCodec implements binary.Codec {
     this.lowPerfCodec = binary.JSON_CODEC;
   }
 
-  encode(payload: unknown): Uint8Array {
+  encode(payload: unknown): Uint8Array<ArrayBuffer> {
     return this.lowPerfCodec.encode(payload);
   }
 

package/src/framer/deleter.spec.ts

@@ -49,21 +49,6 @@ describe("Deleter", () => {
     expect(deletedRes.data.length).toEqual(8);
     expect(Array.from(deletedRes)).toEqual([3, 4, 5, 6, 7, 8, 9, 10]);
   });
-  test("Client - delete name not found", async () => {
-    const [indexCh, dataCh] = await newIndexedPair(client);
-    const data = randomSeries(10, dataCh.dataType);
-    await client.write(TimeStamp.seconds(5), {
-      [indexCh.key]: secondsLinspace(5, 10),
-      [dataCh.key]: data,
-    });
-
-    await expect(
-      client.delete(["nonexistent_channel_name", dataCh.name], TimeRange.MAX),
-    ).rejects.toThrow(NotFoundError);
-
-    const res = await client.read(TimeRange.MAX, dataCh.key);
-    expect(res.data).toEqual(data);
-  });
   test("Client - delete key not found", async () => {
     const [indexCh, dataCh] = await newIndexedPair(client);
     const data = randomSeries(10, dataCh.dataType);

package/src/framer/external.ts

@@ -10,7 +10,7 @@
 export * from "@/framer/client";
 export * from "@/framer/frame";
 export * from "@/framer/iterator";
-export * from "@/framer/payload";
 export * from "@/framer/reader";
 export * from "@/framer/streamer";
+export * from "@/framer/types.gen";
 export * from "@/framer/writer";

package/src/framer/frame.ts

@@ -26,13 +26,13 @@ import { UnexpectedError, ValidationError } from "@/errors";
 
 type ColumnType = "key" | "name" | null;
 
-export interface Digest extends Record<channel.KeyOrName, SeriesDigest[]> {}
+export interface Digest extends Record<channel.Key | channel.Name, SeriesDigest[]> {}
 
 const columnType = (columns: channel.PrimitiveParams): ColumnType => {
   const arrKeys = array.toArray(columns);
   if (arrKeys.length === 0) return null;
   if (typeof arrKeys[0] === "number") return "key";
-  if (!isNaN(parseInt(arrKeys[0]))) return "key";
+  if (!isNaN(parseInt(arrKeys[0], 10))) return "key";
   return "name";
 };
 
@@ -43,21 +43,21 @@ const validateMatchedColsAndSeries = (
   const colsArr = array.toArray(columns);
   if (colsArr.length === series.length) return;
   const colType = columnType(columns);
-  if (columnType === null)
+  if (colType === null)
     throw new ValidationError(
       "[Frame] - channel keys or names must be provided when constructing a frame.",
     );
   throw new ValidationError(
-    `[Frame] - ${colType as string}s and series must be the same length.
-    Got ${colsArr.length} ${colType as string}s and ${series.length} series.`,
+    `[Frame] - ${colType}s and series must be the same length.
+    Got ${colsArr.length} ${colType}s and ${series.length} series.`,
   );
 };
 
 export type CrudeFrame =
   | Frame
   | CrudePayload
-  | Map<channel.KeyOrName, Series[] | Series>
-  | Record<channel.KeyOrName, Series[] | Series>;
+  | Map<channel.Key | channel.Name, Series[] | Series>
+  | Record<channel.Key | channel.Name, Series[] | Series>;
 
 /**
  * A frame is a collection of series mapped to a particular channel. Frames
@@ -95,7 +95,7 @@ export type CrudeFrame =
  * and array can be square.
  */
 export class Frame {
-  readonly columns: channel.KeysOrNames = [];
+  readonly columns: channel.Key[] | channel.Name[] = [];
   readonly series: Series[] = [];
 
   constructor(
@@ -127,7 +127,7 @@ export class Frame {
         data_.keys.forEach((key, i) => this.push(key, series[i]));
       } else
         Object.entries(columnsOrData).forEach(([k, v]) => {
-          const key = parseInt(k);
+          const key = parseInt(k, 10);
           if (!isNaN(key)) return this.push(key, ...array.toArray(v));
           this.push(k, ...array.toArray(v));
         });
@@ -140,7 +140,7 @@ export class Frame {
       ["string", "number"].includes(typeof columnsOrData)
     ) {
       const data_ = array.toArray(series);
-      const cols = array.toArray(columnsOrData) as channel.KeysOrNames;
+      const cols = array.toArray(columnsOrData) as channel.Key[] | channel.Name[];
       validateMatchedColsAndSeries(cols, data_);
       data_.forEach((d, i) => this.push(cols[i], d));
       return;
@@ -167,16 +167,16 @@ export class Frame {
    * @returns the channel keys if the frame is keyed by channel key, and throws an error
    * otherwise.
    */
-  get keys(): channel.Keys {
+  get keys(): channel.Key[] {
     if (this.colType === "name") throw new UnexpectedError("colType is not key");
-    return (this.columns as channel.Keys) ?? [];
+    return (this.columns as channel.Key[]) ?? [];
   }
 
   /**
    * @returns the unique channel keys if the frame is keyed by channel key, and throws an
    * error otherwise.
    */
-  get uniqueKeys(): channel.Keys {
+  get uniqueKeys(): channel.Key[] {
     return unique.unique(this.keys);
   }
 
@@ -200,7 +200,7 @@ export class Frame {
   /**
    * @returns the unique columns in the frame.
    */
-  get uniqueColumns(): channel.KeysOrNames {
+  get uniqueColumns(): channel.Key[] | channel.Name[] {
     return this.colType === "key" ? this.uniqueKeys : this.uniqueNames;
   }
 
@@ -250,7 +250,7 @@ export class Frame {
     return ranges.every((tr) => tr.equals(ranges[0]));
   }
 
-  timeRange(col?: channel.KeyOrName): TimeRange {
+  timeRange(col?: channel.Key | channel.Name): TimeRange {
     if (col == null) {
       if (this.columns.length === 0) return TimeRange.ZERO;
       const start = TimeStamp.min(...this.series.map((a) => a.timeRange.start));
@@ -274,17 +274,17 @@ export class Frame {
    * @returns lazy series matching the given channel key or name.
    * @param key the channel key or name.
    */
-  get(key: channel.KeyOrName): MultiSeries;
+  get(key: channel.Key | channel.Name): MultiSeries;
 
   /**
    * @returns a frame with the given channel keys or names.
    * @param keys the channel keys or names.
    */
-  get(keys: channel.KeysOrNames): Frame;
+  get(keys: channel.Key[] | channel.Name[]): Frame;
 
   get(key: channel.PrimitiveParams): MultiSeries | Frame {
     if (Array.isArray(key))
-      return this.filter((k) => (key as channel.Keys).includes(k as channel.Key));
+      return this.filter((k) => (key as channel.Key[]).includes(k as channel.Key));
     return new MultiSeries(this.series.filter((_, i) => this.columns[i] === key));
   }
 
@@ -294,7 +294,7 @@ export class Frame {
    * @param key the channel key or name;
    * @param v the series to push.
    */
-  push(key: channel.KeyOrName, ...v: Series[]): void;
+  push(key: channel.Key | channel.Name, ...v: Series[]): void;
 
   /**
    * Pushes the frame onto the current frame.
@@ -303,7 +303,7 @@ export class Frame {
    */
   push(frame: Frame): void;
 
-  push(keyOrFrame: channel.KeyOrName | Frame, ...v: Series[]): void {
+  push(keyOrFrame: channel.Key | channel.Name | Frame, ...v: Series[]): void {
     if (keyOrFrame instanceof Frame) {
       if (
         keyOrFrame.colType != null &&
@@ -312,15 +312,15 @@ export class Frame {
       )
         throw new ValidationError("keyVariant must match");
       this.series.push(...keyOrFrame.series);
-      (this.columns as channel.Keys).push(...(keyOrFrame.columns as channel.Keys));
+      (this.columns as channel.Key[]).push(...(keyOrFrame.columns as channel.Key[]));
     } else {
       this.series.push(...v);
       if (typeof keyOrFrame === "string" && this.colType === "key")
         throw new ValidationError("keyVariant must match");
       else if (typeof keyOrFrame !== "string" && this.colType === "name")
         throw new ValidationError("keyVariant must match");
-      (this.columns as channel.Keys).push(
-        ...(Array.from({ length: v.length }, () => keyOrFrame) as channel.Keys),
+      (this.columns as channel.Key[]).push(
+        ...(Array.from({ length: v.length }, () => keyOrFrame) as channel.Key[]),
       );
     }
   }
@@ -330,7 +330,7 @@ export class Frame {
    * provided frame.
    */
   concat(frame: Frame): Frame {
-    return new Frame([...this.columns, ...frame.columns] as channel.Keys, [
+    return new Frame([...this.columns, ...frame.columns] as channel.Key[], [
       ...this.series,
       ...frame.series,
     ]);
@@ -340,10 +340,10 @@ export class Frame {
    * @returns true if the frame contains the provided channel key or name.
    * @param channel the channel key or name to check.
    */
-  has(channel: channel.KeyOrName): boolean {
+  has(channel: channel.Key | channel.Name): boolean {
     if (typeof channel === "string" && this.colType === "key") return false;
     if (typeof channel === "number" && this.colType === "name") return false;
-    return (this.columns as channel.Keys).includes(channel as channel.Key);
+    return (this.columns as channel.Key[]).includes(channel as channel.Key);
   }
 
   /**
@@ -352,7 +352,11 @@ export class Frame {
    * boolean.
    */
   map(
-    fn: (k: channel.KeyOrName, arr: Series, i: number) => [channel.KeyOrName, Series],
+    fn: (
+      k: channel.Key | channel.Name,
+      arr: Series,
+      i: number,
+    ) => [channel.Key | channel.Name, Series],
   ): Frame {
     const frame = new Frame();
     this.forEach((k, arr, i) => frame.push(...fn(k, arr, i)));
@@ -361,10 +365,10 @@ export class Frame {
 
   mapFilter(
     fn: (
-      k: channel.KeyOrName,
+      k: channel.Key | channel.Name,
       arr: Series,
       i: number,
-    ) => [channel.KeyOrName, Series, boolean],
+    ) => [channel.Key | channel.Name, Series, boolean],
   ): Frame {
     const frame = new Frame();
     this.forEach((k, arr, i) => {
@@ -379,7 +383,7 @@ export class Frame {
    *
    * @param fn a function that takes a channel key and series.
    */
-  forEach(fn: (k: channel.KeyOrName, arr: Series, i: number) => void): void {
+  forEach(fn: (k: channel.Key | channel.Name, arr: Series, i: number) => void): void {
     this.columns.forEach((k, i) => {
       const a = this.series[i];
       fn(k, a, i);
@@ -390,22 +394,24 @@ export class Frame {
    * Iterates over all unique columns in the frame.
    * @param fn a function that takes a channel key, multi-series, and index.
    */
-  forEachUnique(fn: (k: channel.KeyOrName, ms: MultiSeries, i: number) => void): void {
+  forEachUnique(
+    fn: (k: channel.Key | channel.Name, ms: MultiSeries, i: number) => void,
+  ): void {
     this.uniqueColumns.forEach((k, i) => fn(k, this.get(k), i));
   }
 
-  at(index: number, required: true): Record<channel.KeyOrName, TelemValue>;
+  at(index: number, required: true): Record<channel.Key | channel.Name, TelemValue>;
 
   at(
     index: number,
     required?: false,
-  ): Record<channel.KeyOrName, TelemValue | undefined>;
+  ): Record<channel.Key | channel.Name, TelemValue | undefined>;
 
   at(
     index: number,
     required = false,
-  ): Record<channel.KeyOrName, TelemValue | undefined> {
-    const res: Record<channel.KeyOrName, TelemValue> = {};
+  ): Record<channel.Key | channel.Name, TelemValue | undefined> {
+    const res: Record<channel.Key | channel.Name, TelemValue> = {};
     this.uniqueColumns.forEach((k) => {
       res[k] = this.get(k).at(index, required as true);
     });
@@ -417,7 +423,9 @@ export class Frame {
    * the provided filter function.
    * @param fn a function that takes a channel key and series and returns a boolean.
    */
-  filter(fn: (k: channel.KeyOrName, arr: Series, i: number) => boolean): Frame {
+  filter(
+    fn: (k: channel.Key | channel.Name, arr: Series, i: number) => boolean,
+  ): Frame {
     const frame = new Frame();
     this.columns.forEach((k, i) => {
       const a = this.series[i];

package/src/framer/reader.spec.ts

@@ -281,7 +281,7 @@ describe("Reader", () => {
     it("should handle large amounts of channels", async () => {
       const numGroups = 5;
       const channelsPerGroup = 3;
-      const dataKeys: channel.Keys = [];
+      const dataKeys: channel.Key[] = [];
       const expectedColumns = numGroups * (1 + channelsPerGroup);
 
       // Store timestamps written per group for building expected rows later
@@ -298,7 +298,7 @@ describe("Reader", () => {
           dataType: DataType.TIMESTAMP,
           isIndex: true,
         });
-        const groupChannels: channel.Keys = [index.key];
+        const groupChannels: channel.Key[] = [index.key];
         for (let c = 0; c < channelsPerGroup; c++) {
           const data = await client.channels.create({
             name: id.create(),

package/src/framer/reader.ts

@@ -18,7 +18,7 @@ import { Iterator, type IteratorConfig } from "@/framer/iterator";
 export interface ReadRequest {
   channels: channel.Params;
   timeRange: CrudeTimeRange;
-  channelNames?: Record<channel.KeyOrName, string>;
+  channelNames?: Record<channel.Key | channel.Name, string>;
   responseType: "csv";
   iteratorConfig?: IteratorConfig;
 }
@@ -70,7 +70,7 @@ export class Reader {
 interface CreateCSVExportStreamParams {
   iterator: Iterator;
   channelPayloads: channel.Payload[];
-  headers?: Record<channel.KeyOrName, string>;
+  headers?: Record<channel.Key | channel.Name, string>;
 }
 
 const createCSVReadableStream = ({
@@ -198,8 +198,8 @@ const createCSVReadableStream = ({
 
 const groupChannelsByIndex = (
   channels: channel.Payload[],
-): Map<channel.Key, channel.Keys> => {
-  const groupMap = new Map<channel.Key, channel.Keys>();
+): Map<channel.Key, channel.Key[]> => {
+  const groupMap = new Map<channel.Key, channel.Key[]>();
   for (const ch of channels) {
     if (ch.index === 0) continue;
     let group = groupMap.get(ch.index);
@@ -225,8 +225,8 @@ interface ColumnMetaResult {
 
 const buildColumnMeta = (
   channels: channel.Payload[],
-  groups: Map<channel.Key, channel.Keys>,
-  headers?: Record<channel.KeyOrName, string>,
+  groups: Map<channel.Key, channel.Key[]>,
+  headers?: Record<channel.Key | channel.Name, string>,
 ): ColumnMetaResult => {
   const channelMap = new Map(channels.map((ch) => [ch.key, ch]));
   const columns: ColumnMeta[] = [];