@synnaxlabs/client 0.38.1 → 0.39.0

package/src/framer/client.ts

@@ -17,34 +17,24 @@ import {
   TimeSpan,
 } from "@synnaxlabs/x";
 
-import {
-  type Key,
-  type KeyOrName,
-  type KeysOrNames,
-  type Params,
-} from "@/channel/payload";
-import { analyzeChannelParams, type Retriever } from "@/channel/retriever";
+import { channel } from "@/channel";
 import { Deleter } from "@/framer/deleter";
-import { Frame } from "@/framer/frame";
+import { Frame, ONTOLOGY_TYPE } from "@/framer/frame";
 import { Iterator, type 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 =>
+export const ontologyID = (key: channel.Key): ontology.ID =>
   new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });
 
 export class Client {
   private readonly streamClient: StreamClient;
-  // private readonly unaryClient: UnaryClient;
-  private readonly retriever: Retriever;
+  private readonly retriever: channel.Retriever;
   private readonly deleter: Deleter;
 
-  constructor(stream: StreamClient, unary: UnaryClient, retriever: Retriever) {
+  constructor(stream: StreamClient, unary: UnaryClient, retriever: channel.Retriever) {
     this.streamClient = stream;
-    // this.unaryClient = unary;
     this.retriever = retriever;
     this.deleter = new Deleter(unary);
   }
@@ -59,7 +49,7 @@ export class Client {
    */
   async openIterator(
     tr: CrudeTimeRange,
-    channels: Params,
+    channels: channel.Params,
     opts?: IteratorConfig,
   ): Promise<Iterator> {
     return await Iterator._open(tr, channels, this.retriever, this.streamClient, opts);
@@ -72,9 +62,9 @@ export class Client {
    * writerConfig for more detail.
    * @returns a new {@link Writer}.
    */
-  async openWriter(config: WriterConfig | Params): Promise<Writer> {
+  async openWriter(config: WriterConfig | channel.Params): Promise<Writer> {
     if (Array.isArray(config) || typeof config !== "object")
-      config = { channels: config as Params };
+      config = { channels: config as channel.Params };
     return await Writer._open(this.retriever, this.streamClient, config);
   }
 
@@ -87,7 +77,7 @@ export class Client {
    * @returns a new {@link Streamer} that must be closed when done streaming, otherwise
    * a network socket will remain open.
    */
-  async openStreamer(channels: Params): Promise<Streamer>;
+  async openStreamer(channels: channel.Params): Promise<Streamer>;
 
   /**
    * Opens a new streamer with the provided configuration.
@@ -100,29 +90,29 @@ export class Client {
    * and then will start reading new values.
    *
    */
-  async openStreamer(config: StreamerConfig | Params): Promise<Streamer>;
+  async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer>;
 
-  async openStreamer(config: StreamerConfig | Params): Promise<Streamer> {
+  async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer> {
     if (Array.isArray(config) || typeof config !== "object")
-      config = { channels: config as Params, downsampleFactor: 1 };
+      config = { channels: config as channel.Params, downsampleFactor: 1 };
     return await Streamer._open(this.retriever, this.streamClient, config);
   }
 
   async write(
     start: CrudeTimeStamp,
-    channel: KeyOrName,
+    channel: channel.KeyOrName,
     data: CrudeSeries,
   ): Promise<void>;
 
   async write(
     start: CrudeTimeStamp,
-    channels: KeysOrNames,
+    channels: channel.KeysOrNames,
     data: CrudeSeries[],
   ): Promise<void>;
 
   async write(
     start: CrudeTimeStamp,
-    data: Record<KeyOrName, CrudeSeries>,
+    data: Record<channel.KeyOrName, CrudeSeries>,
   ): Promise<void>;
 
   /**
@@ -136,11 +126,11 @@ export class Client {
    */
   async write(
     start: CrudeTimeStamp,
-    channels: Params | Record<KeyOrName, CrudeSeries>,
+    channels: channel.Params | Record<channel.KeyOrName, CrudeSeries>,
     data?: CrudeSeries | CrudeSeries[],
   ): Promise<void> {
     if (data == null) {
-      const data_ = channels as Record<KeyOrName, CrudeSeries>;
+      const data_ = channels as Record<channel.KeyOrName, CrudeSeries>;
       const w = await this.openWriter({
         start,
         channels: Object.keys(data_),
@@ -156,31 +146,37 @@ export class Client {
     }
     const w = await this.openWriter({
       start,
-      channels: channels as Params,
+      channels: channels as channel.Params,
       mode: WriterMode.Persist,
       errOnUnauthorized: true,
       enableAutoCommit: true,
       autoIndexPersistInterval: TimeSpan.MAX,
     });
     try {
-      await w.write(channels as Params, data);
+      await w.write(channels as channel.Params, data);
     } finally {
       await w.close();
     }
   }
 
-  async read(tr: CrudeTimeRange, channel: KeyOrName): Promise<MultiSeries>;
+  async read(tr: CrudeTimeRange, channel: channel.KeyOrName): Promise<MultiSeries>;
 
-  async read(tr: CrudeTimeRange, channels: Params): Promise<Frame>;
+  async read(tr: CrudeTimeRange, channels: channel.Params): Promise<Frame>;
 
-  async read(tr: CrudeTimeRange, channels: Params): Promise<MultiSeries | Frame> {
-    const { single } = analyzeChannelParams(channels);
+  async read(
+    tr: CrudeTimeRange,
+    channels: channel.Params,
+  ): Promise<MultiSeries | Frame> {
+    const { single } = channel.analyzeParams(channels);
     const fr = await this.readFrame(tr, channels);
-    if (single) return fr.get(channels as KeyOrName);
+    if (single) return fr.get(channels as channel.KeyOrName);
     return fr;
   }
 
-  private async readFrame(tr: CrudeTimeRange, channels: Params): Promise<Frame> {
+  private async readFrame(
+    tr: CrudeTimeRange,
+    channels: channel.Params,
+  ): Promise<Frame> {
     const i = await this.openIterator(tr, channels);
     const frame = new Frame();
     try {
@@ -191,11 +187,11 @@ export class Client {
     return frame;
   }
 
-  async delete(channels: Params, timeRange: TimeRange): Promise<void> {
-    const { normalized, variant } = analyzeChannelParams(channels);
+  async delete(channels: channel.Params, timeRange: TimeRange): Promise<void> {
+    const { normalized, variant } = channel.analyzeParams(channels);
     if (variant === "keys")
       return await this.deleter.delete({
-        keys: normalized as Key[],
+        keys: normalized as channel.Key[],
         bounds: timeRange,
       });
     return await this.deleter.delete({

package/src/framer/deleter.ts

@@ -11,15 +11,14 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { TimeRange } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { keyZ } from "@/channel/payload";
+import { channel } from "@/channel";
 
 const reqZ = z.object({
-  keys: keyZ.array().optional(),
+  keys: channel.keyZ.array().optional(),
   bounds: TimeRange.z,
-  names: z.string().array().optional(),
+  names: channel.nameZ.array().optional(),
 });
-
-type RequestProps = z.infer<typeof reqZ>;
+interface Request extends z.infer<typeof reqZ> {}
 
 const resZ = z.object({});
 
@@ -35,7 +34,7 @@ export class Deleter {
     this.client = client;
   }
 
-  async delete(props: RequestProps): Promise<void> {
+  async delete(props: Request): Promise<void> {
     await sendRequired<typeof reqZ, typeof resZ>(
       this.client,
       ENDPOINT,

package/src/framer/frame.ts

@@ -20,20 +20,17 @@ import {
 } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
-import {
-  type Key,
-  type KeyOrName,
-  type Keys,
-  type Names,
-  type Params,
-} from "@/channel/payload";
+import { type channel } from "@/channel";
 import { UnexpectedError, ValidationError } from "@/errors";
 
+export const ONTOLOGY_TYPE = "framer";
+export type OntologyType = typeof ONTOLOGY_TYPE;
+
 type ColumnType = "key" | "name" | null;
 
-export interface FrameDigest extends Record<KeyOrName, SeriesDigest[]> {}
+export interface Digest extends Record<channel.KeyOrName, SeriesDigest[]> {}
 
-const columnType = (columns: Params): ColumnType => {
+const columnType = (columns: channel.Params): ColumnType => {
   const arrKeys = toArray(columns);
   if (arrKeys.length === 0) return null;
   if (typeof arrKeys[0] === "number") return "key";
@@ -41,7 +38,10 @@ const columnType = (columns: Params): ColumnType => {
   return "name";
 };
 
-const validateMatchedColsAndSeries = (columns: Params, series: Series[]): void => {
+const validateMatchedColsAndSeries = (
+  columns: channel.Params,
+  series: Series[],
+): void => {
   const colsArr = toArray(columns);
   if (colsArr.length === series.length) return;
   const colType = columnType(columns);
@@ -55,11 +55,11 @@ const validateMatchedColsAndSeries = (columns: Params, series: Series[]): void =
   );
 };
 
-export type CrudeFrame =
+export type Crude =
   | Frame
-  | CrudeFramePayload
-  | Map<KeyOrName, Series[] | Series>
-  | Record<KeyOrName, Series[] | Series>;
+  | CrudePayload
+  | Map<channel.KeyOrName, Series[] | Series>
+  | Record<channel.KeyOrName, Series[] | Series>;
 
 /**
  * A frame is a collection of series mapped to a particular channel. Frames
@@ -97,10 +97,13 @@ export type CrudeFrame =
  * and array can be square.
  */
 export class Frame {
-  readonly columns: Keys | Names = [];
+  readonly columns: channel.Keys | channel.Names = [];
   readonly series: Series[] = [];
 
-  constructor(columnsOrData: Params | CrudeFrame = [], series: Series | Series[] = []) {
+  constructor(
+    columnsOrData: channel.Params | Crude = [],
+    series: Series | Series[] = [],
+  ) {
     if (columnsOrData instanceof Frame) {
       this.columns = columnsOrData.columns;
       this.series = columnsOrData.series;
@@ -118,7 +121,7 @@ export class Frame {
     // Construction from a payload.
     if (isObject) {
       if ("keys" in columnsOrData && "series" in columnsOrData) {
-        const data_ = columnsOrData as FramePayload;
+        const data_ = columnsOrData as Payload;
         data_.series ??= [];
         data_.keys ??= [];
         const series = data_.series.map((a) => seriesFromPayload(a));
@@ -139,7 +142,7 @@ export class Frame {
       ["string", "number"].includes(typeof columnsOrData)
     ) {
       const data_ = toArray(series);
-      const cols = toArray(columnsOrData) as Keys | Names;
+      const cols = toArray(columnsOrData) as channel.Keys | channel.Names;
       validateMatchedColsAndSeries(cols, data_);
       data_.forEach((d, i) => this.push(cols[i], d));
       return;
@@ -166,16 +169,16 @@ export class Frame {
    * @returns the channel keys if the frame is keyed by channel key, and throws an error
    * otherwise.
    */
-  get keys(): Keys {
+  get keys(): channel.Keys {
     if (this.colType === "name") throw new UnexpectedError("colType is not key");
-    return (this.columns as Keys) ?? [];
+    return (this.columns as channel.Keys) ?? [];
   }
 
   /**
    * @returns the unique channel keys if the frame is keyed by channel key, and throws an
    * error otherwise.
    */
-  get uniqueKeys(): Keys {
+  get uniqueKeys(): channel.Keys {
     return unique.unique(this.keys);
   }
 
@@ -183,27 +186,27 @@ export class Frame {
    * @returns the channel names if the frame is keyed by channel name, and throws an error
    * otherwise.
    */
-  get names(): Names {
+  get names(): channel.Names {
     if (this.colType === "key") throw new UnexpectedError("colType is not name");
-    return (this.columns as Names) ?? [];
+    return (this.columns as channel.Names) ?? [];
   }
 
   /**
    * @returns the unique channel names if the frame is keyed by channel name, and throws an
    * otherwise.
    */
-  get uniqueNames(): Names {
+  get uniqueNames(): channel.Names {
     return unique.unique(this.names);
   }
 
   /**
    * @returns the unique columns in the frame.
    */
-  get uniqueColumns(): Keys | Names {
+  get uniqueColumns(): channel.Keys | channel.Names {
     return this.colType === "key" ? this.uniqueKeys : this.uniqueNames;
   }
 
-  toPayload(): FramePayload {
+  toPayload(): Payload {
     return {
       series: this.series.map((a) => seriesToPayload(a)),
       keys: this.keys,
@@ -249,7 +252,7 @@ export class Frame {
     return ranges.every((tr) => tr.equals(ranges[0]));
   }
 
-  timeRange(col?: KeyOrName): TimeRange {
+  timeRange(col?: channel.KeyOrName): TimeRange {
     if (col == null) {
       if (this.columns.length === 0) return TimeRange.ZERO;
       const start = TimeStamp.min(...this.series.map((a) => a.timeRange.start));
@@ -273,16 +276,17 @@ export class Frame {
    * @returns lazy series matching the given channel key or name.
    * @param key the channel key or name.
    */
-  get(key: KeyOrName): MultiSeries;
+  get(key: channel.KeyOrName): MultiSeries;
 
   /**
    * @returns a frame with the given channel keys or names.
    * @param keys the channel keys or names.
    */
-  get(keys: Keys | Names): Frame;
+  get(keys: channel.Keys | channel.Names): Frame;
 
-  get(key: KeyOrName | Keys | Names): MultiSeries | Frame {
-    if (Array.isArray(key)) return this.filter((k) => (key as Keys).includes(k as Key));
+  get(key: channel.KeyOrName | channel.Keys | channel.Names): MultiSeries | Frame {
+    if (Array.isArray(key))
+      return this.filter((k) => (key as channel.Keys).includes(k as channel.Key));
     return new MultiSeries(this.series.filter((_, i) => this.columns[i] === key));
   }
 
@@ -292,7 +296,7 @@ export class Frame {
    * @param key the channel key or name;
    * @param v the series to push.
    */
-  push(key: KeyOrName, ...v: Series[]): void;
+  push(key: channel.KeyOrName, ...v: Series[]): void;
 
   /**
    * Pushes the frame onto the current frame.
@@ -301,20 +305,20 @@ export class Frame {
    */
   push(frame: Frame): void;
 
-  push(keyOrFrame: KeyOrName | Frame, ...v: Series[]): void {
+  push(keyOrFrame: channel.KeyOrName | Frame, ...v: Series[]): void {
     if (keyOrFrame instanceof Frame) {
       if (this.colType !== null && keyOrFrame.colType !== this.colType)
         throw new ValidationError("keyVariant must match");
       this.series.push(...keyOrFrame.series);
-      (this.columns as Keys).push(...(keyOrFrame.columns as Keys));
+      (this.columns as channel.Keys).push(...(keyOrFrame.columns as channel.Keys));
     } 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 Keys).push(
-        ...(Array.from({ length: v.length }, () => keyOrFrame) as Keys),
+      (this.columns as channel.Keys).push(
+        ...(Array.from({ length: v.length }, () => keyOrFrame) as channel.Keys),
       );
     }
   }
@@ -324,7 +328,7 @@ export class Frame {
    * provided frame.
    */
   concat(frame: Frame): Frame {
-    return new Frame([...this.columns, ...frame.columns] as Keys, [
+    return new Frame([...this.columns, ...frame.columns] as channel.Keys, [
       ...this.series,
       ...frame.series,
     ]);
@@ -334,10 +338,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: KeyOrName): boolean {
+  has(channel: channel.KeyOrName): boolean {
     if (typeof channel === "string" && this.colType === "key") return false;
     if (typeof channel === "number" && this.colType === "name") return false;
-    return (this.columns as Keys).includes(channel as Key);
+    return (this.columns as channel.Keys).includes(channel as channel.Key);
   }
 
   /**
@@ -345,7 +349,9 @@ export class Frame {
    * @param fn a function that takes a channel key and series and returns a
    * boolean.
    */
-  map(fn: (k: KeyOrName, arr: Series, i: number) => [KeyOrName, Series]): Frame {
+  map(
+    fn: (k: channel.KeyOrName, arr: Series, i: number) => [channel.KeyOrName, Series],
+  ): Frame {
     const frame = new Frame();
     this.forEach((k, arr, i) => frame.push(...fn(k, arr, i)));
     return frame;
@@ -356,19 +362,25 @@ export class Frame {
    *
    * @param fn a function that takes a channel key and series.
    */
-  forEach(fn: (k: KeyOrName, arr: Series, i: number) => void): void {
+  forEach(fn: (k: channel.KeyOrName, arr: Series, i: number) => void): void {
     this.columns.forEach((k, i) => {
       const a = this.series[i];
       fn(k, a, i);
     });
   }
 
-  at(index: number, required: true): Record<KeyOrName, TelemValue>;
+  at(index: number, required: true): Record<channel.KeyOrName, TelemValue>;
 
-  at(index: number, required?: false): Record<KeyOrName, TelemValue | undefined>;
+  at(
+    index: number,
+    required?: false,
+  ): Record<channel.KeyOrName, TelemValue | undefined>;
 
-  at(index: number, required = false): Record<KeyOrName, TelemValue | undefined> {
-    const res: Record<KeyOrName, TelemValue> = {};
+  at(
+    index: number,
+    required = false,
+  ): Record<channel.KeyOrName, TelemValue | undefined> {
+    const res: Record<channel.KeyOrName, TelemValue> = {};
     this.uniqueColumns.forEach((k) => {
       res[k] = this.get(k).at(index, required as true);
     });
@@ -380,7 +392,7 @@ 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: KeyOrName, arr: Series, i: number) => boolean): Frame {
+  filter(fn: (k: channel.KeyOrName, arr: Series, i: number) => boolean): Frame {
     const frame = new Frame();
     this.columns.forEach((k, i) => {
       const a = this.series[i];
@@ -398,8 +410,8 @@ export class Frame {
    * @returns a digest of information about the structure of the frame for debugging
    * purposes.
    */
-  get digest(): FrameDigest {
-    const digest: FrameDigest = {};
+  get digest(): Digest {
+    const digest: Digest = {};
     this.keys.forEach((k, i) => {
       const sd = this.series[i].digest;
       if (k in digest) digest[k].push(sd);
@@ -425,9 +437,9 @@ export const frameZ = z.object({
   ]),
 });
 
-export type FramePayload = z.output<typeof frameZ>;
+export interface Payload extends z.output<typeof frameZ> {}
 
-export type CrudeFramePayload = z.input<typeof frameZ>;
+export interface CrudePayload extends z.input<typeof frameZ> {}
 
 export const seriesFromPayload = (series: SeriesPayload): Series => {
   const { dataType, data, timeRange, alignment } = series;

package/src/framer/iterator.ts

@@ -18,9 +18,8 @@ import {
 } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
-import { type Params } from "@/channel/payload";
-import { type Retriever } from "@/channel/retriever";
-import { ReadFrameAdapter } from "@/framer/adapter";
+import { channel } from "@/channel";
+import { ReadAdapter } from "@/framer/adapter";
 import { Frame, frameZ } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
 
@@ -49,11 +48,10 @@ const reqZ = z.object({
   span: TimeSpan.z.optional(),
   bounds: TimeRange.z.optional(),
   stamp: TimeStamp.z.optional(),
-  keys: z.number().array().optional(),
+  keys: channel.keyZ.array().optional(),
   chunkSize: z.number().optional(),
 });
-
-type Request = z.infer<typeof reqZ>;
+interface Request extends z.infer<typeof reqZ> {}
 
 const resZ = z.object({
   variant: z.nativeEnum(ResponseVariant),
@@ -65,8 +63,8 @@ const resZ = z.object({
 
 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}.
-  */
+   * resulting from a call to next with {@link AUTO_SPAN}.
+   */
   chunkSize?: number;
 }
 
@@ -81,13 +79,10 @@ export interface IteratorConfig {
 export class Iterator {
   private static readonly ENDPOINT = "/frame/iterate";
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
-  private readonly adapter: ReadFrameAdapter;
+  private readonly adapter: ReadAdapter;
   value: Frame;
 
-  private constructor(
-    stream: Stream<typeof reqZ, typeof resZ>,
-    adapter: ReadFrameAdapter,
-  ) {
+  private constructor(stream: Stream<typeof reqZ, typeof resZ>, adapter: ReadAdapter) {
     this.stream = new StreamProxy("Iterator", stream);
     this.value = new Frame();
     this.adapter = adapter;
@@ -106,12 +101,12 @@ export class Iterator {
    */
   static async _open(
     tr: CrudeTimeRange,
-    channels: Params,
-    retriever: Retriever,
+    channels: channel.Params,
+    retriever: channel.Retriever,
     client: StreamClient,
     opts: IteratorConfig = {},
   ): Promise<Iterator> {
-    const adapter = await ReadFrameAdapter.open(retriever, channels);
+    const adapter = await ReadAdapter.open(retriever, channels);
     const stream = await client.stream(Iterator.ENDPOINT, reqZ, resZ);
     const iter = new Iterator(stream, adapter);
     await iter.execute({

package/src/framer/streamer.spec.ts

@@ -239,16 +239,8 @@ describe("Streamer - Calculated Channels", () => {
 
     // Create source channels
     const [channelA, channelB] = await client.channels.create([
-      {
-        name: "multi_test_a",
-        dataType: DataType.FLOAT64,
-        index: timeChannel.key,
-      },
-      {
-        name: "multi_test_b",
-        dataType: DataType.FLOAT64,
-        index: timeChannel.key,
-      },
+      { name: "multi_test_a", dataType: DataType.FLOAT64, index: timeChannel.key },
+      { name: "multi_test_b", dataType: DataType.FLOAT64, index: timeChannel.key },
     ]);
 
     // Create calculated channel with multiple operations

package/src/framer/streamer.ts

@@ -11,50 +11,43 @@ import { EOF, errorZ, type Stream, type StreamClient } from "@synnaxlabs/freight
 import { observe } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { type Key, type Params } from "@/channel/payload";
-import { type Retriever } from "@/channel/retriever";
-import { ReadFrameAdapter } from "@/framer/adapter";
+import { type channel } from "@/channel";
+import { ReadAdapter } from "@/framer/adapter";
 import { Frame, frameZ } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
 
-const reqZ = z.object({ keys: z.number().array() , downsampleFactor: z.number() });
+const reqZ = z.object({ keys: z.number().array(), downsampleFactor: z.number() });
 
-const resZ = z.object({
-  frame: frameZ,
-  error: errorZ.optional().nullable(),
-});
+const resZ = z.object({ frame: frameZ, error: errorZ.optional().nullable() });
 
 const ENDPOINT = "/frame/stream";
 
 export interface StreamerConfig {
-  channels: Params;
+  channels: channel.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 adapter: ReadAdapter;
   private readonly downsampleFactor: number;
 
-  private constructor(
-    stream: Stream<typeof reqZ, typeof resZ>,
-    adapter: ReadFrameAdapter,
-  ) {
+  private constructor(stream: Stream<typeof reqZ, typeof resZ>, adapter: ReadAdapter) {
     this.stream = new StreamProxy("Streamer", stream);
     this.adapter = adapter;
     this.downsampleFactor = 1;
   }
 
-  get keys(): Key[] {
+  get keys(): channel.Key[] {
     return this.adapter.keys;
   }
 
   static async _open(
-    retriever: Retriever,
+    retriever: channel.Retriever,
     client: StreamClient,
     { channels, downsampleFactor }: StreamerConfig,
   ): Promise<Streamer> {
-    const adapter = await ReadFrameAdapter.open(retriever, channels);
+    const adapter = await ReadAdapter.open(retriever, channels);
     const stream = await client.stream(ENDPOINT, reqZ, resZ);
     const streamer = new Streamer(stream, adapter);
     stream.send({ keys: adapter.keys, downsampleFactor: downsampleFactor ?? 1 });
@@ -77,9 +70,12 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
     return this.adapter.adapt(new Frame((await this.stream.receive()).frame));
   }
 
-  async update(channels: Params): Promise<void> {
+  async update(channels: channel.Params): Promise<void> {
     await this.adapter.update(channels);
-    this.stream.send({ keys: this.adapter.keys, downsampleFactor: this.downsampleFactor });
+    this.stream.send({
+      keys: this.adapter.keys,
+      downsampleFactor: this.downsampleFactor,
+    });
   }
 
   close(): void {