@synnaxlabs/client 0.1.0 → 0.1.2

package/build/module/lib/channel/registry.js

@@ -0,0 +1,36 @@
+export default class Registry {
+    retriever;
+    channels;
+    constructor(retriever) {
+        this.retriever = retriever;
+        this.channels = new Map();
+    }
+    async get(key) {
+        let channel = this.channels.get(key);
+        if (channel === undefined) {
+            channel = (await this.retriever.retrieveByKeys(key))[0];
+            this.channels.set(key, channel);
+        }
+        return channel;
+    }
+    async getN(...keys) {
+        const results = [];
+        const retrieveKeys = [];
+        keys.forEach((key) => {
+            const channel = this.channels.get(key);
+            if (channel === undefined)
+                retrieveKeys.push(key);
+            else
+                results.push(channel);
+        });
+        if (retrieveKeys.length > 0) {
+            const channels = await this.retriever.retrieveByKeys(...retrieveKeys);
+            channels.forEach((channel) => {
+                this.channels.set(channel.key, channel);
+                results.push(channel);
+            });
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NoYW5uZWwvcmVnaXN0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxDQUFDLE9BQU8sT0FBTyxRQUFRO0lBQ25CLFNBQVMsQ0FBWTtJQUNyQixRQUFRLENBQThCO0lBRTlDLFlBQVksU0FBb0I7UUFDOUIsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFFRCxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQVc7UUFDbkIsSUFBSSxPQUFPLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDckMsSUFBSSxPQUFPLEtBQUssU0FBUyxFQUFFO1lBQ3pCLE9BQU8sR0FBRyxDQUFDLE1BQU0sSUFBSSxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUN4RCxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUM7U0FDakM7UUFDRCxPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLElBQWM7UUFDMUIsTUFBTSxPQUFPLEdBQXFCLEVBQUUsQ0FBQztRQUNyQyxNQUFNLFlBQVksR0FBYSxFQUFFLENBQUM7UUFDbEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1lBQ25CLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3ZDLElBQUksT0FBTyxLQUFLLFNBQVM7Z0JBQUUsWUFBWSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQzs7Z0JBQzdDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDN0IsQ0FBQyxDQUFDLENBQUM7UUFDSCxJQUFJLFlBQVksQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFO1lBQzNCLE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsR0FBRyxZQUFZLENBQUMsQ0FBQztZQUN0RSxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUU7Z0JBQzNCLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFhLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0JBQ2xELE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDeEIsQ0FBQyxDQUFDLENBQUM7U0FDSjtRQUNELE9BQU8sT0FBTyxDQUFDO0lBQ2pCLENBQUM7Q0FDRiJ9

package/build/module/lib/channel/retriever.d.ts

@@ -0,0 +1,11 @@
+import Transport from '../transport';
+import { ChannelPayload } from './payload';
+export default class Retriever {
+    private static ENDPOINT;
+    private client;
+    constructor(transport: Transport);
+    private execute;
+    retrieveByKeys(...keys: string[]): Promise<ChannelPayload[]>;
+    retrieveByNames(...names: string[]): Promise<ChannelPayload[]>;
+    retrieveByNodeID(nodeId: number): Promise<ChannelPayload[]>;
+}

package/build/module/lib/channel/retriever.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { ChannelPayloadSchema } from './payload';
+const RequestSchema = z.object({
+    keys: z.string().array().optional(),
+    nodeId: z.number().optional(),
+    names: z.string().array().optional(),
+});
+const ResponseSchema = z.object({
+    channels: ChannelPayloadSchema.array(),
+});
+export default class Retriever {
+    static ENDPOINT = '/channel/retrieve';
+    client;
+    constructor(transport) {
+        this.client = transport.getClient();
+    }
+    async execute(request) {
+        const [res, err] = await this.client.send(Retriever.ENDPOINT, request, 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        ResponseSchema);
+        if (err) {
+            throw err;
+        }
+        return res?.channels;
+    }
+    async retrieveByKeys(...keys) {
+        return await this.execute({ keys });
+    }
+    async retrieveByNames(...names) {
+        return await this.execute({ names });
+    }
+    async retrieveByNodeID(nodeId) {
+        return await this.execute({ nodeId: nodeId });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cmlldmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9jaGFubmVsL3JldHJpZXZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBSXhCLE9BQU8sRUFBa0Isb0JBQW9CLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFakUsTUFBTSxhQUFhLEdBQUcsQ0FBQyxDQUFDLE1BQU0sQ0FBQztJQUM3QixJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUNuQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUM3QixLQUFLLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDLFFBQVEsRUFBRTtDQUNyQyxDQUFDLENBQUM7QUFJSCxNQUFNLGNBQWMsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzlCLFFBQVEsRUFBRSxvQkFBb0IsQ0FBQyxLQUFLLEVBQUU7Q0FDdkMsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLE9BQU8sT0FBTyxTQUFTO0lBQ3BCLE1BQU0sQ0FBQyxRQUFRLEdBQUcsbUJBQW1CLENBQUM7SUFDdEMsTUFBTSxDQUFjO0lBRTVCLFlBQVksU0FBb0I7UUFDOUIsSUFBSSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDdEMsQ0FBQztJQUVPLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBZ0I7UUFDcEMsTUFBTSxDQUFDLEdBQUcsRUFBRSxHQUFHLENBQUMsR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUN2QyxTQUFTLENBQUMsUUFBUSxFQUNsQixPQUFPO1FBQ1AsNkRBQTZEO1FBQzdELGFBQWE7UUFDYixjQUFjLENBQ2YsQ0FBQztRQUNGLElBQUksR0FBRyxFQUFFO1lBQ1AsTUFBTSxHQUFHLENBQUM7U0FDWDtRQUNELE9BQU8sR0FBRyxFQUFFLFFBQTRCLENBQUM7SUFDM0MsQ0FBQztJQUVELEtBQUssQ0FBQyxjQUFjLENBQUMsR0FBRyxJQUFjO1FBQ3BDLE9BQU8sTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBRUQsS0FBSyxDQUFDLGVBQWUsQ0FBQyxHQUFHLEtBQWU7UUFDdEMsT0FBTyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7SUFFRCxLQUFLLENBQUMsZ0JBQWdCLENBQUMsTUFBYztRQUNuQyxPQUFPLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ2hELENBQUMifQ==

package/build/module/lib/client.d.ts

@@ -0,0 +1,23 @@
+import ChannelClient from './channel/client';
+import SegmentClient from './segment/client';
+import Transport from './transport';
+export declare type ClientProps = {
+    host: string;
+    port: number;
+};
+/**
+ * Client to perform operations against a Synnax cluster.
+ *
+ * @property channel - Channel client for creating and retrieving channels.
+ * @property data - Data client for reading and writing telemetry.
+ */
+export default class Synnax {
+    transport: Transport;
+    data: SegmentClient;
+    channel: ChannelClient;
+    /**
+     * @param host - Hostname of a node in the cluster.
+     * @param port - Port of the node in the cluster.
+     */
+    constructor({ host, port }: ClientProps);
+}

package/build/module/lib/client.js

@@ -0,0 +1,31 @@
+import { URL } from '@synnaxlabs/freighter';
+import ChannelClient from './channel/client';
+import ChannelCreator from './channel/creator';
+import Registry from './channel/registry';
+import ChannelRetriever from './channel/retriever';
+import SegmentClient from './segment/client';
+import Transport from './transport';
+/**
+ * Client to perform operations against a Synnax cluster.
+ *
+ * @property channel - Channel client for creating and retrieving channels.
+ * @property data - Data client for reading and writing telemetry.
+ */
+export default class Synnax {
+    transport;
+    data;
+    channel;
+    /**
+     * @param host - Hostname of a node in the cluster.
+     * @param port - Port of the node in the cluster.
+     */
+    constructor({ host, port }) {
+        this.transport = new Transport(new URL({ host, port }));
+        const chRetriever = new ChannelRetriever(this.transport);
+        const chCreator = new ChannelCreator(this.transport);
+        const chRegistry = new Registry(chRetriever);
+        this.data = new SegmentClient(this.transport, chRegistry);
+        this.channel = new ChannelClient(this.data, chRetriever, chCreator);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTVDLE9BQU8sYUFBYSxNQUFNLGtCQUFrQixDQUFDO0FBQzdDLE9BQU8sY0FBYyxNQUFNLG1CQUFtQixDQUFDO0FBQy9DLE9BQU8sUUFBUSxNQUFNLG9CQUFvQixDQUFDO0FBQzFDLE9BQU8sZ0JBQWdCLE1BQU0scUJBQXFCLENBQUM7QUFDbkQsT0FBTyxhQUFhLE1BQU0sa0JBQWtCLENBQUM7QUFDN0MsT0FBTyxTQUFTLE1BQU0sYUFBYSxDQUFDO0FBT3BDOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sT0FBTyxNQUFNO0lBQ3pCLFNBQVMsQ0FBWTtJQUNyQixJQUFJLENBQWdCO0lBQ3BCLE9BQU8sQ0FBZ0I7SUFFdkI7OztPQUdHO0lBQ0gsWUFBWSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQWU7UUFDckMsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLFNBQVMsQ0FBQyxJQUFJLEdBQUcsQ0FBQyxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDeEQsTUFBTSxXQUFXLEdBQUcsSUFBSSxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDekQsTUFBTSxTQUFTLEdBQUcsSUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3JELE1BQU0sVUFBVSxHQUFHLElBQUksUUFBUSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQzdDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxhQUFhLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMxRCxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksYUFBYSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsV0FBVyxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7Q0FDRiJ9

package/build/module/lib/errors.d.ts

@@ -0,0 +1,53 @@
+import { BaseTypedError } from '@synnaxlabs/freighter';
+export declare type Field = {
+    field: string;
+    message: string;
+};
+declare class BaseError extends BaseTypedError {
+    constructor(message: string);
+}
+/**
+ * Raised when a validation error occurs.
+ */
+export declare class ValidationError extends BaseError {
+    fields: Field[];
+    constructor(fieldsOrMessage: string | Field[] | Field);
+}
+/**
+ * GeneralError is raised when a general error occurs.
+ */
+export declare class GeneralError extends BaseError {
+}
+/**
+ * ParseError is raised when a parse error occurs.
+ */
+export declare class ParseError extends BaseError {
+}
+/**
+ * AuthError is raised when an authentication error occurs.
+ */
+export declare class AuthError extends BaseError {
+}
+/**
+ * UnexpectedError is raised when an unexpected error occurs.
+ */
+export declare class UnexpectedError extends BaseError {
+}
+/**
+ * QueryError is raised when a query error occurs.
+ */
+export declare class QueryError extends BaseError {
+}
+/**
+ * RouteError is raised when a routing error occurs.
+ */
+export declare class RouteError extends BaseError {
+    path: string;
+    constructor(message: string, path: string);
+}
+/**
+ * Raised when time-series data is not contiguous.
+ */
+export declare class ContiguityError extends BaseError {
+}
+export {};

package/build/module/lib/errors.js

@@ -0,0 +1,113 @@
+import { BaseTypedError, registerError } from '@synnaxlabs/freighter';
+import { z } from 'zod';
+const _FREIGHTER_EXCEPTION_TYPE = 'synnax.api.errors';
+const APIErrorPayloadSchema = z.object({
+    type: z.string(),
+    error: z.record(z.unknown()),
+});
+var APIErrorType;
+(function (APIErrorType) {
+    APIErrorType["General"] = "general";
+    APIErrorType["Nil"] = "nil";
+    APIErrorType["Parse"] = "parse";
+    APIErrorType["Auth"] = "auth";
+    APIErrorType["Unexpected"] = "unexpected";
+    APIErrorType["Validation"] = "validation";
+    APIErrorType["Query"] = "query";
+    APIErrorType["Route"] = "route";
+})(APIErrorType || (APIErrorType = {}));
+class BaseError extends BaseTypedError {
+    constructor(message) {
+        super(message, _FREIGHTER_EXCEPTION_TYPE);
+    }
+}
+/**
+ * Raised when a validation error occurs.
+ */
+export class ValidationError extends BaseError {
+    fields;
+    constructor(fieldsOrMessage) {
+        if (typeof fieldsOrMessage === 'string') {
+            super(fieldsOrMessage);
+            this.fields = [];
+        }
+        else if (Array.isArray(fieldsOrMessage)) {
+            super(fieldsOrMessage
+                .map((field) => `${field.field}: ${field.message}`)
+                .join('\n'));
+            this.fields = fieldsOrMessage;
+        }
+        else {
+            super(`${fieldsOrMessage.field}: ${fieldsOrMessage.message}`);
+            this.fields = [fieldsOrMessage];
+        }
+    }
+}
+/**
+ * GeneralError is raised when a general error occurs.
+ */
+export class GeneralError extends BaseError {
+}
+/**
+ * ParseError is raised when a parse error occurs.
+ */
+export class ParseError extends BaseError {
+}
+/**
+ * AuthError is raised when an authentication error occurs.
+ */
+export class AuthError extends BaseError {
+}
+/**
+ * UnexpectedError is raised when an unexpected error occurs.
+ */
+export class UnexpectedError extends BaseError {
+}
+/**
+ * QueryError is raised when a query error occurs.
+ */
+export class QueryError extends BaseError {
+}
+/**
+ * RouteError is raised when a routing error occurs.
+ */
+export class RouteError extends BaseError {
+    path;
+    constructor(message, path) {
+        super(message);
+        this.path = path;
+    }
+}
+/**
+ * Raised when time-series data is not contiguous.
+ */
+export class ContiguityError extends BaseError {
+}
+const parsePayload = (payload) => {
+    switch (payload.type) {
+        case APIErrorType.General:
+            return new GeneralError(payload.error.message);
+        case APIErrorType.Parse:
+            return new ParseError(payload.error.message);
+        case APIErrorType.Auth:
+            return new AuthError(payload.error.message);
+        case APIErrorType.Unexpected:
+            return new UnexpectedError(JSON.stringify(payload.error));
+        case APIErrorType.Validation:
+            return new ValidationError(payload.error.fields);
+        case APIErrorType.Query:
+            return new QueryError(payload.error.message);
+        case APIErrorType.Route:
+            return new RouteError(payload.error.path, payload.error.message);
+        default:
+            return undefined;
+    }
+};
+const decode = (encoded) => {
+    return parsePayload(APIErrorPayloadSchema.parse(JSON.parse(encoded)));
+};
+const encode = () => {
+    throw new Error('Not implemented');
+};
+registerError({ type: _FREIGHTER_EXCEPTION_TYPE, encode, decode });
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/segment/client.d.ts

@@ -0,0 +1,62 @@
+import Registry from '../channel/registry';
+import { TimeRange, TypedArray, UnparsedTimeStamp } from '../telem';
+import Transport from '../transport';
+import { TypedIterator } from './iterator';
+import TypedSegment from './typed';
+import { TypedWriter } from './writer';
+export default class SegmentClient {
+    private transport;
+    private channels;
+    constructor(transport: Transport, channels: Registry);
+    /**
+     * Opens a new iterator over the given channels within the provided time range.
+     *
+     * @param tr - A time range to iterate over.
+     * @param keys - A list of channel keys to iterate over.
+     * @param aggregate - Whether to accumulate iteration results or reset them
+     * on every iterator method call.
+     * @returns a new {@link TypedIterator}.
+     */
+    newIterator(tr: TimeRange, keys: string[], aggregate: boolean): Promise<TypedIterator>;
+    /**
+     * Opens a new writer on the given channels.
+     *
+     * @param keys - The keys of the channels to write to. A writer cannot write to
+     * a channel that is not in this list. See the {@link TypedWriter} documentation
+     * for more information.
+     * @returns a new {@link TypedWriter}.
+     */
+    newWriter(keys: string[]): Promise<TypedWriter>;
+    /**
+     * Writes telemetry to the given channel starting at the given timestamp.
+     *
+     * @param to - 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: string, start: UnparsedTimeStamp, data: TypedArray): Promise<boolean>;
+    /**
+     * Reads telemetry from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @param start - The starting timestamp of the range to read from.
+     * @param end - The ending timestamp of the range to read from.
+     * @returns a typed array containing the retrieved telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    read(from: string, start: UnparsedTimeStamp, end: UnparsedTimeStamp): Promise<TypedArray>;
+    /**
+     * Reads a segment from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @param start - The starting timestamp of the range to read from.
+     * @param end - The ending timestamp of the range to read from.
+     * @returns a segment containing the retrieved telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    readSegment(from: string, start: UnparsedTimeStamp, end: UnparsedTimeStamp): Promise<TypedSegment>;
+}

package/build/module/lib/segment/client.js

@@ -0,0 +1,94 @@
+import { TimeRange } from '../telem';
+import { TypedIterator } from './iterator';
+import { TypedWriter } from './writer';
+export default class SegmentClient {
+    transport;
+    channels;
+    constructor(transport, channels) {
+        this.transport = transport;
+        this.channels = channels;
+    }
+    /**
+     * Opens a new iterator over the given channels within the provided time range.
+     *
+     * @param tr - A time range to iterate over.
+     * @param keys - A list of channel keys to iterate over.
+     * @param aggregate - Whether to accumulate iteration results or reset them
+     * on every iterator method call.
+     * @returns a new {@link TypedIterator}.
+     */
+    async newIterator(tr, keys, aggregate) {
+        const iter = new TypedIterator(this.transport.streamClient, this.channels, aggregate);
+        await iter.open(tr, keys);
+        return iter;
+    }
+    /**
+     * Opens a new writer on the given channels.
+     *
+     * @param keys - The keys of the channels to write to. A writer cannot write to
+     * a channel that is not in this list. See the {@link TypedWriter} documentation
+     * for more information.
+     * @returns a new {@link TypedWriter}.
+     */
+    async newWriter(keys) {
+        const writer = new TypedWriter(this.transport.streamClient, this.channels);
+        await writer.open(keys);
+        return writer;
+    }
+    /**
+     * Writes telemetry to the given channel starting at the given timestamp.
+     *
+     * @param to - 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, start, data) {
+        const writer = await this.newWriter([to]);
+        try {
+            return await writer.write(to, start, data);
+        }
+        finally {
+            await writer.close();
+        }
+    }
+    /**
+     * Reads telemetry from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @param start - The starting timestamp of the range to read from.
+     * @param end - The ending timestamp of the range to read from.
+     * @returns a typed array containing the retrieved telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    async read(from, start, end) {
+        return (await this.readSegment(from, start, end)).view;
+    }
+    /**
+     * Reads a segment from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @param start - The starting timestamp of the range to read from.
+     * @param end - The ending timestamp of the range to read from.
+     * @returns a segment containing the retrieved telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    async readSegment(from, start, end) {
+        const iter = await this.newIterator(new TimeRange(start, end), [from], true);
+        let seg;
+        try {
+            await iter.first();
+            // eslint-disable-next-line no-empty
+            while (await iter.next()) { }
+            seg = (await iter.value())[from];
+        }
+        finally {
+            await iter.close();
+        }
+        return seg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/segment/iterator.d.ts

@@ -0,0 +1,134 @@
+import { StreamClient } from '@synnaxlabs/freighter';
+import Registry from '../channel/registry';
+import { TimeRange } from '../telem';
+import { SegmentPayload } from './payload';
+import TypedSegment from './typed';
+/**
+ * Used to iterate over a clusters telemetry in time-order. It should not be
+ * instantiated directly, and should instead be instantiated via the SegmentClient.
+ *
+ * Using an iterator is ideal when querying/processing large ranges of data, but
+ * is relatively complex and difficult to use. If you're looking to retrieve
+ *  telemetry between two timestamps, see the SegmentClient.read method.
+ */
+export declare class CoreIterator {
+    private static ENDPOINT;
+    private client;
+    private stream;
+    private readonly aggregate;
+    values: SegmentPayload[];
+    constructor(client: StreamClient, aggregate?: boolean);
+    /**
+     * Opens the iterator, configuring it to iterate over the telemetry in the
+     * channels with the given keys within the provided time range.
+     *
+     * @param tr - The time range to iterate over.
+     * @param keys - The keys of the channels to iterate over.
+     */
+    open(tr: TimeRange, keys: string[]): Promise<void>;
+    /**
+     * Reads the next segment for each channel in the iterator.
+     *
+     * @returns false if the next segment can't be found for one or more channels or
+     * the iterator has accumulated an error.
+     */
+    next(): Promise<boolean>;
+    /**
+     * Reads the previous segment for each channel in the iterator.
+     *
+     * @returns false if the next segment can't be found for one or more channels or
+     * the iterator has accumulated an error.
+     */
+    prev(): Promise<boolean>;
+    /**
+     * Seeks to the beginning of the time range and reads the first segment of each
+     * channel in the iterator.
+     *
+     * @returns false if no segments exists in the time range for a particular channel
+     * or the iterator has accumulated an error.
+     */
+    first(): Promise<boolean>;
+    /**
+     * Seeks to the end of the time range and reads the last segment of each channel
+     * in the iterator.
+     *
+     * @returns false if no segments exists in the time range for a particular channel,
+     * or the iterator has accumulated an error.
+     */
+    last(): Promise<boolean>;
+    /**
+     * Reads the next time span of telemetry for each channel in the iterator.
+     *
+     * @returns false if a segment satisfying the request can't be found for a
+     * particular channel or the iterator has accumulated an error.
+     */
+    nextSpan(span: number): Promise<boolean>;
+    /**
+     * Reads the previous time span of telemetry for each channel in the iterator.
+     *
+     * @returns false if a segment satisfying the request can't be found for a particular
+     * channel or the iterator has accumulated an error.
+     */
+    prevSpan(span: number): Promise<boolean>;
+    /**
+     * Seeks the iterator to the start of the time range and reads the telemetry within
+     * the range for each channel.
+     *
+     * @returns: False if a segment satisfying the request can't be found for a particular
+     * channel or the iterator has accumulated an error.
+     */
+    nextRange(range: TimeRange): Promise<boolean>;
+    /**
+     * Seeks the iterator to the first segment in the time range, but does not read
+     * it. Also invalidates the iterator. The iterator will not be considered valid
+     * until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekFirst(): Promise<boolean>;
+    /** Seeks the iterator to the last segment in the time range, but does not read it.
+     * Also invalidates the iterator. The iterator will not be considered valid
+     * until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekLast(): Promise<boolean>;
+    /**
+     * Seeks the iterator to the first segment whose start is less than or equal to
+     * the provided timestamp. Also invalidates the iterator. The iterator will not be
+     * considered valid until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekLT(stamp: number): Promise<boolean>;
+    /**
+     * Seeks the iterator to the first segment whose start is greater than or equal to
+     * the provided timestamp. Also invalidates the iterator. The iterator will not be
+     * considered valid until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekGE(stamp: number): Promise<boolean>;
+    /**
+     * @returns true if the iterator value contains a valid segment, and fale otherwise.
+     * valid most commonly returns false when the iterator is exhausted or has
+     * accumulated an error.
+     */
+    valid(): Promise<boolean>;
+    /**
+     * Closes the iterator. An iterator MUST be closed after use, and this method
+     * should probably be placed in a 'finally' block. If the iterator is not closed,
+     * it may leak resources.
+     */
+    close(): Promise<void>;
+    private execute;
+}
+export declare class TypedIterator extends CoreIterator {
+    channels: Registry;
+    constructor(client: StreamClient, channels: Registry, aggregate?: boolean);
+    value(): Promise<Record<string, TypedSegment>>;
+}