@synnaxlabs/client 0.17.6 → 0.18.1

package/dist/framer/client.d.ts

@@ -1,10 +1,10 @@
 import { type StreamClient } from "@synnaxlabs/freighter";
-import { type TypedArray, type Series, type TimeRange, type CrudeTimeStamp, TimeStamp } from "@synnaxlabs/x";
+import { type Series, type TimeRange, type CrudeTimeStamp, type CrudeSeries } from "@synnaxlabs/x";
 import { type KeyOrName, type Params } from '../channel/payload';
 import { type Retriever } from '../channel/retriever';
 import { Frame } from './frame';
 import { Iterator } from './iterator';
-import { Streamer } from './streamer';
+import { Streamer, type StreamerConfig } from './streamer';
 import { Writer, type WriterConfig } from './writer';
 export declare class Client {
     private readonly stream;
@@ -17,7 +17,7 @@ export declare class Client {
      * @param keys - A list of channel keys to iterate over.
      * @returns a new {@link TypedIterator}.
      */
-    newIterator(tr: TimeRange, channels: Params): Promise<Iterator>;
+    openIterator(tr: TimeRange, channels: Params): Promise<Iterator>;
     /**
      * Opens a new writer on the given channels.
      *
@@ -26,18 +26,39 @@ export declare class Client {
      * for more information.
      * @returns a new {@link RecordWriter}.
      */
-    newWriter({ start, channels, controlSubject, authorities, mode, }: WriterConfig): Promise<Writer>;
-    newStreamer(params: Params, from?: TimeStamp): Promise<Streamer>;
+    openWriter(config: WriterConfig): Promise<Writer>;
+    /***
+     * Opens a new streamer on the given channels.
+     *
+     * @param channels - A key, name, list of keys, or list of names of the channels to
+     * stream values from.
+     * @throws a QueryError if any of the given channels do not exist.
+     * @returns a new {@link Streamer} that must be closed when done streaming, otherwise
+     * a network socket will remain open.
+     */
+    openStreamer(channels: Params): Promise<Streamer>;
+    /**
+     * Opens a new streamer with the provided configuration.
+     *
+     * @param config - Configuration parameters for the streamer.
+     * @param config.channels - The channels to stream values from. Can be a key, name,
+     * list of keys, or list of names.
+     * @param config.from - If this parameter is set and is before the current time,
+     * the streamer will first read and receive historical data from before this point
+     * and then will start reading new values.
+     *
+     */
+    openStreamer(config: StreamerConfig): Promise<Streamer>;
     /**
      * Writes telemetry to the given channel starting at the given timestamp.
      *
-     * @param to - The key of the channel to write to.
+     * @param channel - The key of the channel to write to.
      * @param start - The starting timestamp of the first sample in data.
      * @param data  - The telemetry to write. This telemetry must have the same
      * data type as the channel.
      * @throws if the channel does not exist.
      */
-    write(to: KeyOrName, start: CrudeTimeStamp, data: TypedArray): Promise<void>;
+    write(channel: KeyOrName, start: CrudeTimeStamp, data: CrudeSeries): Promise<void>;
     read(tr: TimeRange, channel: KeyOrName): Promise<Series>;
     read(tr: TimeRange, channels: Params): Promise<Frame>;
     private readFrame;

package/dist/framer/frame.d.ts

@@ -1,4 +1,4 @@
-import { Size, Series, TimeRange, DataType, TimeStamp, type TelemValue } from "@synnaxlabs/x";
+import { Size, Series, TimeRange, DataType, TimeStamp, type TelemValue, MultiSeries } from "@synnaxlabs/x";
 import { z } from "zod";
 import { type KeyOrName, type Keys, type Names, type Params } from '../channel/payload';
 type ColumnType = "key" | "name" | null;
@@ -98,13 +98,13 @@ export declare class Frame {
      */
     get isWeaklyAligned(): boolean;
     timeRange(col?: KeyOrName): TimeRange;
-    latest(): Record<string, TelemValue>;
+    latest(): Record<string, TelemValue | undefined>;
     get timeRanges(): TimeRange[];
     /**
      * @returns lazy arrays matching the given channel key or name.
      * @param key the channel key or name.
      */
-    get(key: KeyOrName): Series[];
+    get(key: KeyOrName): MultiSeries;
     /**
      * @returns a frame with the given channel keys or names.
      * @param keys the channel keys or names.
@@ -145,6 +145,8 @@ export declare class Frame {
      * @param fn a function that takes a channel key and typed array.
      */
     forEach(fn: (k: KeyOrName, arr: Series, i: number) => void): void;
+    at(index: number, required: true): Record<KeyOrName, TelemValue>;
+    at(index: number, required?: false): Record<KeyOrName, TelemValue | undefined>;
     /**
      * @returns a new frame containing all typed arrays in the current frame that pass
      * the provided filter function.

package/dist/framer/streamer.d.ts

@@ -3,12 +3,16 @@ import { type CrudeTimeStamp } from "@synnaxlabs/x";
 import { type Key, type Params } from '../channel/payload';
 import { type Retriever } from '../channel/retriever';
 import { Frame } from './frame';
+export interface StreamerConfig {
+    channels: Params;
+    from?: CrudeTimeStamp;
+}
 export declare class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
     private readonly stream;
     private readonly adapter;
     private constructor();
     get keys(): Key[];
-    static _open(start: CrudeTimeStamp, channels: Params, retriever: Retriever, client: StreamClient): Promise<Streamer>;
+    static _open(retriever: Retriever, client: StreamClient, { channels, from }: StreamerConfig): Promise<Streamer>;
     next(): Promise<IteratorResult<Frame, any>>;
     read(): Promise<Frame>;
     update(params: Params): Promise<void>;

package/dist/framer/writer.d.ts

@@ -378,43 +378,43 @@ declare const resZ: z.ZodObject<{
 }>;
 type Response = z.infer<typeof resZ>;
 export interface WriterConfig {
-    start: CrudeTimeStamp;
     channels: Params;
+    start?: CrudeTimeStamp;
     controlSubject?: ControlSubject;
     authorities?: Authority | Authority[];
     mode?: WriterMode;
 }
 /**
  * Writer is used to write telemetry to a set of channels in time order.
- * It should not be instantiated directly, and should instead be instantited via the
+ * It should not be instantiated directly, and should instead be instantiated via the
  * FramerClient {@link FrameClient#openWriter}.
  *
- * The writer is a streaming protocol that is heavily optimized for prerformance. This
- * comes at the cost of icnreased complexity, and should only be used directly when
- * writing large volumes of data (such as recording telemetry from a sensor or ingsting
- * data froma file). Simpler methods (such as the frame client's write method) should
+ * The writer is a streaming protocol that is heavily optimized for performance. This
+ * comes at the cost of increased complexity, and should only be used directly when
+ * writing large volumes of data (such as recording telemetry from a sensor or ingesting
+ * data from file). Simpler methods (such as the frame client's write method) should
  * be used for most use cases.
  *
  * The protocol is as follows:
  *
  * 1. The writer is opened with a starting timestamp and a list of channel keys. The
- * writer will fail to open if the starting timstamp overlaps with any existing telemetry
- * for any channels specified. If the writer opens successfuly, the caller is then
+ * writer will fail to open if the starting timestamp overlaps with any existing telemetry
+ * for any channels specified. If the writer opens successfully, the caller is then
  * free to write frames to the writer.
  *
  * 2. To write a frame, the caller can use the write method and follow the validation
  * rules described in its method's documentation. This process is asynchronous, meaning
  * that write calls may return before teh frame has been written to the cluster. This
  * also means that the writer can accumulate an error after write is called. If the writer
- * accumulates an erorr, all subsequent write and commit calls will return False. The
- * caller can check for errors by calling the error mehtod, which returns the accumulated
+ * accumulates an error, all subsequent write and commit calls will return False. The
+ * caller can check for errors by calling the error method, which returns the accumulated
  * error and resets the writer for future use. The caller can also check for errors by
  * closing the writer, which will throw any accumulated error.
  *
  * 3. To commit the written frames to the cluster, the caller can call the commit method.
  * Unlike write, commit is synchronous, meaning that it will not return until the frames
- * have been written to the cluster. If the writer has accumulated an erorr, commit will
- * return false. After the caller acknowledges the erorr, they can attempt to commit again.
+ * have been written to the cluster. If the writer has accumulated an error, commit will
+ * return false. After the caller acknowledges the error, they can attempt to commit again.
  * Commit can be called several times throughout a writer's lifetime, and will only
  * commit the frames that have been written since the last commit.
  *
@@ -427,7 +427,7 @@ export declare class Writer {
     private readonly stream;
     private readonly adapter;
     private constructor();
-    static _open(retriever: Retriever, client: StreamClient, { channels, authorities, controlSubject: subject, start, mode, }: WriterConfig): Promise<Writer>;
+    static _open(retriever: Retriever, client: StreamClient, { channels, start, authorities, controlSubject: subject, mode, }: WriterConfig): Promise<Writer>;
     write(channel: KeyOrName, data: CrudeSeries): Promise<boolean>;
     write(channel: KeysOrNames, data: CrudeSeries[]): Promise<boolean>;
     write(frame: CrudeFrame): Promise<boolean>;

package/dist/index.d.ts

@@ -9,8 +9,8 @@ export { Frame } from './framer/frame';
 export { ontology } from './ontology';
 export { control } from './control';
 export { Authority } from './control/authority';
-export { DataType, Density, Rate, Series, TimeRange, TimeSpan, TimeStamp, } from "@synnaxlabs/x";
-export type { TypedArray, CrudeDataType, CrudeDensity, CrudeRate, CrudeSize, CrudeTimeSpan, CrudeTimeStamp, SampleValue, TimeStampStringFormat, TZInfo, } from "@synnaxlabs/x";
+export { DataType, Density, Rate, Series, TimeRange, TimeSpan, TimeStamp, MultiSeries, } from "@synnaxlabs/x";
+export type { TypedArray, CrudeDataType, CrudeDensity, CrudeRate, CrudeSize, CrudeTimeSpan, CrudeTimeStamp, TelemValue, NumericTelemValue, TimeStampStringFormat, TZInfo, } from "@synnaxlabs/x";
 export { workspace } from './workspace';
 export { ranger } from './ranger';
 export { label } from './label';

package/examples/node/liveStream.js

@@ -24,15 +24,16 @@ const read_from = [
     "stream_write_example_data_2"
 ]
 
-const streamer = await client.telem.newStreamer(read_from);
+const streamer = await client.telem.openStreamer(read_from);
 
 // It's very important that we close the streamer when we're done with it to release 
 // network connections and other resources, so we wrap the streaming loop in a try-finally
 // block.
 try {
     // Loop through the frames in the streamer. Each iteration will block until a new 
-    // frame is available, and then we'll just print it out.
-    for await (const frame of streamer) console.log(frame.latest());
+    // frame is available, and then we'll just print out the last sample for each
+    // channel in the frame.
+    for await (const frame of streamer) console.log(frame.at(-1));
 } finally {
     streamer.close();
     // Close the client when we're done with it.

package/examples/node/package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@synnaxlabs/client": "^0.17.5"
+        "@synnaxlabs/client": "^0.18.0"
       }
     },
     "node_modules/@grpc/grpc-js": {
@@ -3653,23 +3653,23 @@
       }
     },
     "node_modules/@synnaxlabs/client": {
-      "version": "0.17.5",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.17.5.tgz",
-      "integrity": "sha512-HyQ/lzX4lekh5pg84A59tNjMHAYact3uvV+DUUJma+C3w4fgl4hT0U1DZ3IABiI02pNJEaiahMszg+2E9g358A==",
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.18.0.tgz",
+      "integrity": "sha512-o53rR0awYUCcdSCENzo+6VjsEEt30ExHG0B1FLOk3+865eIJkvazS4RrRYpitrIxuzAGIK12v0vZ/qj8sGzlfA==",
       "dependencies": {
-        "@synnaxlabs/freighter": "0.9.2",
-        "@synnaxlabs/x": "0.14.2",
+        "@synnaxlabs/freighter": "0.9.3",
+        "@synnaxlabs/x": "0.15.0",
         "async-mutex": "^0.4.0",
         "zod": "3.22.4"
       }
     },
     "node_modules/@synnaxlabs/freighter": {
-      "version": "0.9.2",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/freighter/-/freighter-0.9.2.tgz",
-      "integrity": "sha512-GJ63tGtSKlqiDLI+82keEIKwKmCsMI7y5ibI1DGKS/cXgeYJFUmG4BjJFM4HfVQxt56o94UP+qP4acZcLDZwGg==",
+      "version": "0.9.3",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/freighter/-/freighter-0.9.3.tgz",
+      "integrity": "sha512-H8a4HePVykwlkQMw8yClJ/BpydMDieBD2HHC2bBcvfJKZ3w32uiAqvhqezy14aU2XgNG92hU65IBi2FT6esBng==",
       "dependencies": {
         "@synnaxlabs/alamos": "0.3.0",
-        "@synnaxlabs/x": "0.14.2",
+        "@synnaxlabs/x": "0.15.0",
         "js-convert-case": "^4.2.0",
         "node-fetch": "2.6.11",
         "ws": "^8.15.1",
@@ -3680,9 +3680,9 @@
       }
     },
     "node_modules/@synnaxlabs/x": {
-      "version": "0.14.2",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.14.2.tgz",
-      "integrity": "sha512-Js5czEi7oMhaQkDe3xGuGLbho7xBMoNIWJmrXI20lu+VbB/FyO1wVtfcdIIIZOLc3tUAdNw9ceuZXMOieRoH1g==",
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.15.0.tgz",
+      "integrity": "sha512-baowvPsc0oKeMscKHh/5u0WVRB7J3ylIYzkx8feyP67QkjE8PCQpf0gmdThMGg6r0HwUbubzTcD0N64TNvahWw==",
       "dependencies": {
         "async-mutex": "^0.4.0",
         "js-convert-case": "^4.2.0",
@@ -3886,9 +3886,9 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "20.12.3",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.3.tgz",
-      "integrity": "sha512-sD+ia2ubTeWrOu+YMF+MTAB7E+O7qsMqAbMfW7DG3K1URwhZ5hN1pLlRVGbf4wDFzSfikL05M17EyorS86jShw==",
+      "version": "20.12.4",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.4.tgz",
+      "integrity": "sha512-E+Fa9z3wSQpzgYQdYmme5X3OTuejnnTx88A6p6vkkJosR3KBz+HpE3kqNm98VE6cfLFcISx7zW7MsJkH6KwbTw==",
       "dependencies": {
         "undici-types": "~5.26.4"
       }

package/examples/node/package.json

@@ -11,6 +11,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@synnaxlabs/client": "^0.17.5"
+    "@synnaxlabs/client": "^0.18.0"
   }
 }

package/examples/node/seriesAndFrames.js

@@ -0,0 +1,37 @@
+import { Series } from "@synnaxlabs/client";
+
+// Construct a series from an array of numbers. In this case, the series will 
+// automatically be of type float64.
+let series = new Series([1, 2, 3, 4, 5]);
+
+// Construct a series from an array of numbers, but this time we specify the type
+// explicitly.
+series = new Series({ data: [1, 2, 3, 4, 5], dataType: "float32" });
+
+// Construct a series from an array of strings. In this case, the series will
+// automatically be of type string.
+series = new Series(["apple", "banana", "cherry"]);
+
+// Construct a series from a Float32Array. This is the most efficient way to
+// construct a series from a large amount of data.
+series = new Series(new Float32Array([1, 2, 3, 4, 5]));
+
+// Construct a series from a JSON object. This is useful when you have a series
+// that has been serialized to JSON.
+series = new Series([{ red: "cherry" }, { yellow: "banana" }, {orange: "orange" }]);
+
+series = new Series([1, "a", 3, "b", 5]);
+
+series = new Series([1, 2, 3, 4, 5]);
+
+console.log(series.at(0)); // 1
+console.log(series.at(-1)); // 5
+
+series = new Series([1, 2, 3, 4, 5]);
+// Is it a number? Is it a string? Who knows?
+let v = series.at(0);
+
+series = new Series([1, 2, 3, 4, 5]);
+let easierSeries = series.as("number");
+// Now we have a guarantee that this is a series of numbers.
+v = easierSeries.at(0);

package/examples/node/streamWrite.js

@@ -48,7 +48,7 @@ const roughRate = Rate.hz(40);
 // historical reads every 500 samples.
 const commitInterval = 500;
 
-const writer = await client.telem.newWriter({
+const writer = await client.telem.openWriter({
     start, 
     channels: [timeChannel.key, dataChannel1.key, dataChannel2.key]
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.17.6",
+  "version": "0.18.1",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -18,8 +18,8 @@
   "dependencies": {
     "async-mutex": "^0.4.0",
     "zod": "3.22.4",
-    "@synnaxlabs/freighter": "0.9.2",
-    "@synnaxlabs/x": "0.14.2"
+    "@synnaxlabs/freighter": "0.9.3",
+    "@synnaxlabs/x": "0.15.1"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
@@ -29,8 +29,8 @@
     "vite": "^5.1.2",
     "vitest": "^1.2.2",
     "@synnaxlabs/tsconfig": "0.0.2",
-    "@synnaxlabs/vite-plugin": "0.0.1",
-    "eslint-config-synnaxlabs": "0.0.1"
+    "eslint-config-synnaxlabs": "0.0.1",
+    "@synnaxlabs/vite-plugin": "0.0.1"
   },
   "main": "dist/client.cjs",
   "module": "dist/client.js",

package/src/control/state.ts

@@ -111,7 +111,7 @@ export class StateTracker implements observe.Observable<Transfer[]> {
   }
 
   static async open(client: FrameClient): Promise<StateTracker> {
-    const streamer = await client.newStreamer("sy_node_1_control");
+    const streamer = await client.openStreamer("sy_node_1_control");
     return new StateTracker(streamer);
   }
 

package/src/framer/adapter.spec.ts

@@ -41,8 +41,8 @@ describe("WriteFrameAdapter", () => {
     expect(res.series).toHaveLength(2);
     expect(res.get(timeCh.key)).toHaveLength(1);
     expect(res.get(dataCh.key)).toHaveLength(1);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a record of names to single values", async () => {
@@ -55,8 +55,8 @@ describe("WriteFrameAdapter", () => {
     expect(res2.series).toHaveLength(2);
     expect(res2.get(timeCh.key)).toHaveLength(1);
     expect(res2.get(dataCh.key)).toHaveLength(1);
-    expect(res2.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res2.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res2.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res2.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a single name to a single series", async () => {
@@ -64,7 +64,7 @@ describe("WriteFrameAdapter", () => {
     expect(res3.columns).toHaveLength(1);
     expect(res3.series).toHaveLength(1);
     expect(res3.get(dataCh.key)).toHaveLength(1);
-    expect(res3.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res3.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt multiple names to multiple series", async () => {
@@ -75,8 +75,8 @@ describe("WriteFrameAdapter", () => {
     );
     expect(res4.get(timeCh.key)).toHaveLength(1);
     expect(res4.get(dataCh.key)).toHaveLength(1);
-    expect(res4.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res4.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res4.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res4.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a frame keyed by name", async () => {
@@ -88,8 +88,8 @@ describe("WriteFrameAdapter", () => {
     const res = await adapter.adapt(fr);
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should not modify a frame keyed by key", async () => {
@@ -101,8 +101,8 @@ describe("WriteFrameAdapter", () => {
     const res = await adapter.adapt(fr);
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a map of series", async () => {
@@ -113,6 +113,6 @@ describe("WriteFrameAdapter", () => {
     expect(res.columns).toHaveLength(1);
     expect(res.series).toHaveLength(1);
     expect(res.get(timeCh.key)).toHaveLength(1);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
   });
 });

package/src/framer/client.ts

@@ -9,19 +9,17 @@
 
 import { type StreamClient } from "@synnaxlabs/freighter";
 import {
-  type TypedArray,
   type Series,
   type TimeRange,
   type CrudeTimeStamp,
-  TimeStamp,
+  type CrudeSeries,
 } from "@synnaxlabs/x";
 
 import { type KeyOrName, type Params } from "@/channel/payload";
 import { type Retriever, analyzeParams } from "@/channel/retriever";
-import { Authority } from "@/control/authority";
 import { Frame } from "@/framer/frame";
 import { Iterator } from "@/framer/iterator";
-import { Streamer } from "@/framer/streamer";
+import { Streamer, type StreamerConfig } from "@/framer/streamer";
 import { Writer, WriterMode, type WriterConfig } from "@/framer/writer";
 
 export class Client {
@@ -40,7 +38,7 @@ export class Client {
    * @param keys - A list of channel keys to iterate over.
    * @returns a new {@link TypedIterator}.
    */
-  async newIterator(tr: TimeRange, channels: Params): Promise<Iterator> {
+  async openIterator(tr: TimeRange, channels: Params): Promise<Iterator> {
     return await Iterator._open(tr, channels, this.retriever, this.stream);
   }
 
@@ -52,46 +50,61 @@ export class Client {
    * for more information.
    * @returns a new {@link RecordWriter}.
    */
-  async newWriter({
-    start,
-    channels,
-    controlSubject,
-    authorities = Authority.Absolute,
-    mode = WriterMode.PersistStream,
-  }: WriterConfig): Promise<Writer> {
-    return await Writer._open(this.retriever, this.stream, {
-      start: start ?? TimeStamp.now(),
-      controlSubject,
-      channels,
-      authorities,
-      mode,
-    });
+  async openWriter(config: WriterConfig): Promise<Writer> {
+    return await Writer._open(this.retriever, this.stream, config);
   }
 
-  async newStreamer(
-    params: Params,
-    from: TimeStamp = TimeStamp.now(),
-  ): Promise<Streamer> {
-    return await Streamer._open(from, params, this.retriever, this.stream);
+  /***
+   * Opens a new streamer on the given channels.
+   *
+   * @param channels - A key, name, list of keys, or list of names of the channels to
+   * stream values from.
+   * @throws a QueryError if any of the given channels do not exist.
+   * @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>;
+
+  /**
+   * Opens a new streamer with the provided configuration.
+   *
+   * @param config - Configuration parameters for the streamer.
+   * @param config.channels - The channels to stream values from. Can be a key, name,
+   * list of keys, or list of names.
+   * @param config.from - If this parameter is set and is before the current time,
+   * the streamer will first read and receive historical data from before this point
+   * and then will start reading new values.
+   *
+   */
+  async openStreamer(config: StreamerConfig): Promise<Streamer>;
+
+  async openStreamer(config: StreamerConfig | Params): Promise<Streamer> {
+    const isObject = typeof config === "object";
+    if (Array.isArray(config) || !isObject) config = { channels: config as Params };
+    return await Streamer._open(this.retriever, this.stream, config as StreamerConfig);
   }
 
   /**
    * Writes telemetry to the given channel starting at the given timestamp.
    *
-   * @param to - The key of the channel to write to.
+   * @param channel - The key of the channel to write to.
    * @param start - The starting timestamp of the first sample in data.
    * @param data  - The telemetry to write. This telemetry must have the same
    * data type as the channel.
    * @throws if the channel does not exist.
    */
-  async write(to: KeyOrName, start: CrudeTimeStamp, data: TypedArray): Promise<void> {
-    const w = await this.newWriter({
+  async write(
+    channel: KeyOrName,
+    start: CrudeTimeStamp,
+    data: CrudeSeries,
+  ): Promise<void> {
+    const w = await this.openWriter({
       start,
-      channels: to,
+      channels: channel,
       mode: WriterMode.PersistOnly,
     });
     try {
-      await w.write(to, data);
+      await w.write(channel, data);
       await w.commit();
     } finally {
       await w.close();
@@ -110,7 +123,7 @@ export class Client {
   }
 
   private async readFrame(tr: TimeRange, params: Params): Promise<Frame> {
-    const i = await this.newIterator(tr, params);
+    const i = await this.openIterator(tr, params);
     const frame = new Frame();
     try {
       for await (const f of i) frame.push(f);