@synnaxlabs/client 0.2.0 → 0.13.5

package/{build/module/lib/segment → dist/framer}/iterator.d.ts

@@ -1,8 +1,9 @@
-import { StreamClient } from '@synnaxlabs/freighter';
-import Registry from '../channel/registry';
-import { TimeRange } from '../telem';
-import { SegmentPayload } from './payload';
-import TypedSegment from './typed';
+import { type StreamClient } from "@synnaxlabs/freighter";
+import { type CrudeTimeSpan, type CrudeTimeStamp, TimeRange, TimeSpan } from "@synnaxlabs/x";
+import { type Params } from '../channel/payload';
+import { type Retriever } from '../channel/retriever';
+import { Frame } from '../framer/frame';
+export declare const AUTO_SPAN: TimeSpan;
 /**
  * Used to iterate over a clusters telemetry in time-order. It should not be
  * instantiated directly, and should instead be instantiated via the SegmentClient.
@@ -11,13 +12,12 @@ import TypedSegment from './typed';
  * 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);
+export declare class Iterator {
+    private static readonly ENDPOINT;
+    private readonly stream;
+    private readonly adapter;
+    value: Frame;
+    private constructor();
     /**
      * Opens the iterator, configuring it to iterate over the telemetry in the
      * channels with the given keys within the provided time range.
@@ -25,63 +25,35 @@ export declare class CoreIterator {
      * @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>;
+    static _open(tr: TimeRange, channels: Params, retriever: Retriever, client: StreamClient): Promise<Iterator>;
     /**
      * Reads the next time span of telemetry for each channel in the iterator.
      *
+     * @param span - The time span to read. A negative span is equivalent
+     * to calling prev with the absolute value of the span. If the span is
+     * AUTO_SPAN, the iterator will automatically determine the span to read.
+     * This is useful for iterating over an entire range efficiently.
+     *
      * @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>;
+    next(span?: CrudeTimeSpan): 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.
+     * @param span - The time span to read. A negative span is equivalent
+     * to calling next with the absolute value of the span. If the span is
+     * AUTO_SPAN, the iterator will automatically determine the span to read.
+     * This is useful for iterating over an entire range efficiently.
      *
-     * @returns: False if a segment satisfying the request can't be found for a particular
+     * @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>;
+    prev(span?: CrudeTimeSpan): 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.
+     * until a call to next or prev.
      *
      * @returns false if the iterator is not pointing to a valid segment for a particular
      * channel or has accumulated an error.
@@ -89,7 +61,7 @@ export declare class CoreIterator {
     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.
+     * until a call to next or prev.
      *
      * @returns false if the iterator is not pointing to a valid segment for a particular
      * channel or has accumulated an error.
@@ -98,21 +70,21 @@ export declare class CoreIterator {
     /**
      * 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.
+     * considered valid until a call to next or prev.
      *
      * @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>;
+    seekLE(stamp: CrudeTimeStamp): 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.
+     * considered valid until a call to next or prev.
      *
      * @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>;
+    seekGE(stamp: CrudeTimeStamp): 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
@@ -125,10 +97,6 @@ export declare class CoreIterator {
      * it may leak resources.
      */
     close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<Frame, any, undefined>;
     private execute;
 }
-export declare class TypedIterator extends CoreIterator {
-    channels: Registry;
-    constructor(client: StreamClient, channels: Registry, aggregate?: boolean);
-    value(): Promise<Record<string, TypedSegment>>;
-}

package/dist/framer/streamProxy.d.ts

@@ -0,0 +1,12 @@
+import { type Stream } from "@synnaxlabs/freighter";
+import { type z } from "zod";
+export declare class StreamProxy<RQ extends z.ZodTypeAny, RS extends z.ZodTypeAny> {
+    readonly name: string;
+    private readonly stream;
+    constructor(name: string, stream: Stream<RQ, RS>);
+    receive(): Promise<z.output<RS>>;
+    received(): boolean;
+    closeAndAck(): Promise<void>;
+    closeSend(): void;
+    send(req: z.input<RQ>): void;
+}

package/dist/framer/streamer.d.ts

@@ -0,0 +1,17 @@
+import { type StreamClient } from "@synnaxlabs/freighter";
+import { type CrudeTimeStamp } from "@synnaxlabs/x";
+import { type Key, type Params } from '../channel/payload';
+import { type Retriever } from '../channel/retriever';
+import { Frame } from '../framer/frame';
+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>;
+    next(): Promise<IteratorResult<Frame, any>>;
+    read(): Promise<Frame>;
+    update(params: Params): Promise<void>;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<Frame, any, undefined>;
+}

package/dist/framer/writer.d.ts

@@ -0,0 +1,257 @@
+import type { StreamClient } from "@synnaxlabs/freighter";
+import { type NativeTypedArray, TimeStamp, type CrudeTimeStamp } from "@synnaxlabs/x";
+import { z } from "zod";
+import { type Key, type KeyOrName, type Params } from '../channel/payload';
+import { type Retriever } from '../channel/retriever';
+import { Authority } from '../control/authority';
+import { type Subject as ControlSubject } from '../control/state';
+import { type CrudeFrame } from '../framer/frame';
+declare enum Command {
+    Open = 0,
+    Write = 1,
+    Commit = 2,
+    Error = 3,
+    SetAuthority = 4
+}
+declare const reqZ: z.ZodObject<{
+    command: z.ZodNativeEnum<typeof Command>;
+    config: z.ZodOptional<z.ZodObject<{
+        start: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>>;
+        controlSubject: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            key: string;
+        }, {
+            name: string;
+            key: string;
+        }>>;
+        keys: z.ZodArray<z.ZodNumber, "many">;
+        authorities: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<Authority, z.ZodTypeDef, Authority>, z.ZodEffects<z.ZodNumber, Authority, number>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, Authority, Number>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        keys: number[];
+        start?: TimeStamp | undefined;
+        controlSubject?: {
+            name: string;
+            key: string;
+        } | undefined;
+        authorities?: Authority[] | undefined;
+    }, {
+        keys: number[];
+        start?: number | Number | TimeStamp | undefined;
+        controlSubject?: {
+            name: string;
+            key: string;
+        } | undefined;
+        authorities?: (number | Number | Authority)[] | undefined;
+    }>>;
+    frame: z.ZodOptional<z.ZodObject<{
+        keys: z.ZodUnion<[z.ZodEffects<z.ZodNull, number[], null>, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>]>;
+        series: z.ZodUnion<[z.ZodEffects<z.ZodNull, {
+            dataType: import("@synnaxlabs/x").DataType;
+            data: (ArrayBuffer | SharedArrayBuffer) & (ArrayBuffer | SharedArrayBuffer | undefined);
+            timeRange?: import("@synnaxlabs/x").TimeRange | undefined;
+            alignment?: number | undefined;
+        }[], null>, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            timeRange: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+                start: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+                end: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+            }, "strip", z.ZodTypeAny, {
+                start: TimeStamp;
+                end: TimeStamp;
+            }, {
+                start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+                end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+            }>, import("@synnaxlabs/x").TimeRange, {
+                start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+                end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+            }>, z.ZodType<import("@synnaxlabs/x").TimeRange, z.ZodTypeDef, import("@synnaxlabs/x").TimeRange>]>>;
+            alignment: z.ZodOptional<z.ZodNumber>;
+            dataType: z.ZodUnion<[z.ZodEffects<z.ZodString, import("@synnaxlabs/x").DataType, string>, z.ZodType<import("@synnaxlabs/x").DataType, z.ZodTypeDef, import("@synnaxlabs/x").DataType>]>;
+            data: z.ZodEffects<z.ZodString, ArrayBuffer | SharedArrayBuffer, string>;
+        }, "strip", z.ZodTypeAny, {
+            dataType: import("@synnaxlabs/x").DataType;
+            data: (ArrayBuffer | SharedArrayBuffer) & (ArrayBuffer | SharedArrayBuffer | undefined);
+            timeRange?: import("@synnaxlabs/x").TimeRange | undefined;
+            alignment?: number | undefined;
+        }, {
+            dataType: (string | import("@synnaxlabs/x").DataType) & (string | import("@synnaxlabs/x").DataType | undefined);
+            data: string;
+            timeRange?: import("@synnaxlabs/x").TimeRange | {
+                start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+                end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+            } | undefined;
+            alignment?: number | undefined;
+        }>, "many">>>]>;
+    }, "strip", z.ZodTypeAny, {
+        keys: number[];
+        series: {
+            dataType: import("@synnaxlabs/x").DataType;
+            data: (ArrayBuffer | SharedArrayBuffer) & (ArrayBuffer | SharedArrayBuffer | undefined);
+            timeRange?: import("@synnaxlabs/x").TimeRange | undefined;
+            alignment?: number | undefined;
+        }[];
+    }, {
+        keys?: number[] | null | undefined;
+        series?: {
+            dataType: (string | import("@synnaxlabs/x").DataType) & (string | import("@synnaxlabs/x").DataType | undefined);
+            data: string;
+            timeRange?: import("@synnaxlabs/x").TimeRange | {
+                start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+                end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+            } | undefined;
+            alignment?: number | undefined;
+        }[] | null | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    command: Command;
+    config?: {
+        keys: number[];
+        start?: TimeStamp | undefined;
+        controlSubject?: {
+            name: string;
+            key: string;
+        } | undefined;
+        authorities?: Authority[] | undefined;
+    } | undefined;
+    frame?: {
+        keys: number[];
+        series: {
+            dataType: import("@synnaxlabs/x").DataType;
+            data: (ArrayBuffer | SharedArrayBuffer) & (ArrayBuffer | SharedArrayBuffer | undefined);
+            timeRange?: import("@synnaxlabs/x").TimeRange | undefined;
+            alignment?: number | undefined;
+        }[];
+    } | undefined;
+}, {
+    command: Command;
+    config?: {
+        keys: number[];
+        start?: number | Number | TimeStamp | undefined;
+        controlSubject?: {
+            name: string;
+            key: string;
+        } | undefined;
+        authorities?: (number | Number | Authority)[] | undefined;
+    } | undefined;
+    frame?: {
+        keys?: number[] | null | undefined;
+        series?: {
+            dataType: (string | import("@synnaxlabs/x").DataType) & (string | import("@synnaxlabs/x").DataType | undefined);
+            data: string;
+            timeRange?: import("@synnaxlabs/x").TimeRange | {
+                start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+                end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+            } | undefined;
+            alignment?: number | undefined;
+        }[] | null | undefined;
+    } | undefined;
+}>;
+type Request = z.infer<typeof reqZ>;
+declare const resZ: z.ZodObject<{
+    ack: z.ZodBoolean;
+    command: z.ZodNativeEnum<typeof Command>;
+    error: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        data: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        data: string;
+    }, {
+        type: string;
+        data: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    command: Command;
+    ack: boolean;
+    error?: {
+        type: string;
+        data: string;
+    } | null | undefined;
+}, {
+    command: Command;
+    ack: boolean;
+    error?: {
+        type: string;
+        data: string;
+    } | null | undefined;
+}>;
+type Response = z.infer<typeof resZ>;
+export interface WriterConfig {
+    start: CrudeTimeStamp;
+    channels: Params;
+    controlSubject?: ControlSubject;
+    authorities?: Authority | Authority[];
+}
+/**
+ * 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
+ * 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
+ * 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
+ * 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
+ * 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.
+ * 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.
+ *
+ * 4. A writer MUST be closed after use in order to prevent resource leaks. Close should
+ * typically be called in a 'finally' block. If the writer has accumulated an error,
+ * close will throw the error.
+ */
+export declare class Writer {
+    private static readonly ENDPOINT;
+    private readonly stream;
+    private readonly adapter;
+    private constructor();
+    static _open(retriever: Retriever, client: StreamClient, { channels, authorities, controlSubject: subject, start, }: WriterConfig): Promise<Writer>;
+    write(channel: KeyOrName, data: NativeTypedArray): Promise<boolean>;
+    write(frame: CrudeFrame): Promise<boolean>;
+    setAuthority(value: Record<Key, Authority>): Promise<boolean>;
+    /**
+     * Commits the written frames to the database. Commit is synchronous, meaning that it
+     * will not return until all frames have been commited to the database.
+     *
+     * @returns false if the commit failed due to an error. In this case, the caller
+     * should acknowledge the error by calling the error method or closing the writer.
+     * After the caller acknowledges the error, they can attempt to commit again.
+     */
+    commit(): Promise<boolean>;
+    /**
+     * @returns  The accumulated error, if any. This method will clear the writer's error
+     * state, allowing the writer to be used again.
+     */
+    error(): Promise<Error | null>;
+    /**
+     * Closes the writer, raising any accumulated error encountered during operation.
+     * A writer MUST be closed after use, and this method should probably be placed
+     * in a 'finally' block.
+     */
+    close(): Promise<void>;
+    execute(req: Request): Promise<Response>;
+    private get errorAccumulated();
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from './channel';
+export { default as Synnax, synnaxPropsZ } from './client';
+export type { SynnaxProps } from './client';
+export * from './connection';
+export { Channel } from './channel/client';
+export { AuthError, ContiguityError, GeneralError, ParseError, QueryError, RouteError, UnexpectedError, ValidationError, } from './errors';
+export { framer } from './framer';
+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 { NativeTypedArray, CrudeDataType, CrudeDensity, CrudeRate, CrudeSize, CrudeTimeSpan, CrudeTimeStamp, SampleValue, TimeStampStringFormat, TZInfo, } from "@synnaxlabs/x";
+export { workspace } from './workspace';
+export { ranger } from './ranger';
+export { label } from './label';

package/dist/label/client.d.ts

@@ -0,0 +1,25 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type AsyncTermSearcher } from "@synnaxlabs/x";
+import { type framer } from '../framer';
+import { type Key, type Label } from '../label/payload';
+import { type NewLabelPayload } from '../label/writer';
+import { type ontology } from '../ontology';
+import { signals } from '../signals';
+export declare class Client implements AsyncTermSearcher<string, Key, Label> {
+    private readonly retriever;
+    private readonly writer;
+    private readonly frameClient;
+    constructor(client: UnaryClient, frameClient: framer.Client);
+    search(term: string): Promise<Label[]>;
+    retrieve(key: Key): Promise<Label>;
+    retrieve(keys: Key[]): Promise<Label[]>;
+    retrieveFor(id: ontology.ID): Promise<Label[]>;
+    label(id: ontology.ID, labels: Key[]): Promise<void>;
+    removeLabels(id: ontology.ID, labels: Key[]): Promise<void>;
+    page(offset: number, limit: number): Promise<Label[]>;
+    create(label: NewLabelPayload): Promise<Label>;
+    create(labels: NewLabelPayload[]): Promise<Label[]>;
+    delete(key: Key): Promise<void>;
+    delete(keys: Key[]): Promise<void>;
+    openChangeTracker(): Promise<signals.Observable<string, Label>>;
+}

package/dist/label/external.d.ts

@@ -0,0 +1,4 @@
+export * from '../label/client';
+export * from '../label/writer';
+export * from '../label/retriever';
+export * from '../label/payload';

package/dist/label/index.d.ts

@@ -0,0 +1 @@
+export * as label from '../label/external';

package/dist/label/payload.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { ontology } from '../ontology';
+export declare const keyZ: z.ZodString;
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+export declare const labelZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    color: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    color: string;
+}, {
+    name: string;
+    key: string;
+    color: string;
+}>;
+export type Label = z.infer<typeof labelZ>;
+export declare const ontologyID: (key: Key) => ontology.ID;

package/dist/label/retriever.d.ts

@@ -0,0 +1,13 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type Label, type Params } from '../label/payload';
+import { ontology } from '../ontology';
+export declare class Retriever {
+    private static readonly ENDPOINT;
+    private readonly client;
+    constructor(client: UnaryClient);
+    retrieve(params: Params): Promise<Label[]>;
+    retrieveFor(id: ontology.ID): Promise<Label[]>;
+    search(term: string): Promise<Label[]>;
+    page(offset: number, limit: number): Promise<Label[]>;
+    private execute;
+}

package/dist/label/writer.d.ts

@@ -0,0 +1,26 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+import { type Key, type Label } from '../label/payload';
+import { ontology } from '../ontology';
+export declare const newLabelPayloadZ: z.ZodObject<{
+    name: z.ZodString;
+    color: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    color: string;
+    key?: string | undefined;
+}, {
+    name: string;
+    color: string;
+    key?: string | undefined;
+}>;
+export type NewLabelPayload = z.infer<typeof newLabelPayloadZ>;
+export declare class Writer {
+    private readonly client;
+    constructor(client: UnaryClient);
+    create(labels: NewLabelPayload | NewLabelPayload[]): Promise<Label[]>;
+    delete(keys: Key | Key[]): Promise<void>;
+    set(id: ontology.ID, labels: Key[]): Promise<void>;
+    remove(id: ontology.ID, labels: Key[]): Promise<void>;
+}

package/dist/ontology/cdc.d.ts

@@ -0,0 +1,25 @@
+import { observe, type change } from "@synnaxlabs/x";
+import { type Client as FrameClient } from '../framer/client';
+import { type Streamer as FrameStreamer } from '../framer/streamer';
+import { ID, type Relationship, type Resource } from '../ontology/payload';
+import { type Retriever } from '../ontology/retriever';
+export type ResourceChange = change.Change<ID, Resource>;
+export type RelationshipChange = change.Change<Relationship, undefined>;
+export declare class ChangeTracker {
+    private readonly resourceObs;
+    private readonly relationshipObs;
+    readonly relationships: observe.Observable<RelationshipChange[]>;
+    readonly resources: observe.Observable<ResourceChange[]>;
+    private readonly streamer;
+    private readonly retriever;
+    private readonly closePromise;
+    constructor(streamer: FrameStreamer, retriever: Retriever);
+    close(): Promise<void>;
+    private start;
+    private update;
+    private parseRelationshipSets;
+    private parseRelationshipDeletes;
+    private parseResourceSets;
+    private parseResourceDeletes;
+    static open(client: FrameClient, retriever: Retriever): Promise<ChangeTracker>;
+}

package/dist/ontology/client.d.ts

@@ -0,0 +1,25 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type AsyncTermSearcher } from "@synnaxlabs/x";
+import { type Client as FrameClient } from '../framer/client';
+import { group } from '../ontology/group';
+import { type ID, type Resource } from '../ontology/payload';
+import { Retriever } from '../ontology/retriever';
+import { ChangeTracker } from '../ontology/signals';
+/** The core client class for executing queries against a Synnax cluster ontology */
+export declare class Client implements AsyncTermSearcher<string, string, Resource> {
+    groups: group.Client;
+    retriever: Retriever;
+    private readonly writer;
+    private readonly framer;
+    constructor(unary: UnaryClient, framer: FrameClient);
+    search(term: string): Promise<Resource[]>;
+    retrieve(id: ID | string, includeSchema?: boolean, includeFieldData?: boolean): Promise<Resource>;
+    retrieve(ids: ID[] | string[], includeSchema?: boolean, includeFieldData?: boolean): Promise<Resource[]>;
+    page(offset: number, limit: number): Promise<Resource[]>;
+    retrieveChildren(IDs: ID | ID[], includeSchema?: boolean, includeFieldData?: boolean): Promise<Resource[]>;
+    retrieveParents(IDs: ID | ID[], includeSchema?: boolean, includeFieldData?: boolean): Promise<Resource[]>;
+    addChildren(id: ID, ...children: ID[]): Promise<void>;
+    removeChildren(id: ID, ...children: ID[]): Promise<void>;
+    moveChildren(from: ID, to: ID, ...children: ID[]): Promise<void>;
+    openChangeTracker(): Promise<ChangeTracker>;
+}

package/dist/ontology/external.d.ts

@@ -0,0 +1,3 @@
+export * from '../ontology/client';
+export * from '../ontology/payload';
+export * from '../ontology/signals';

package/dist/ontology/group/client.d.ts

@@ -0,0 +1,11 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type ID } from '../../ontology/payload';
+import { Group } from "./group";
+export declare class Client {
+    private readonly creator;
+    constructor(unary: UnaryClient);
+    create(parent: ID, name: string): Promise<Group>;
+    rename(key: string, name: string): Promise<void>;
+    delete(...keys: string[]): Promise<void>;
+    private sugar;
+}

package/dist/ontology/group/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../../ontology/group/group';
+export * from '../../ontology/group/client';

package/dist/ontology/group/group.d.ts

@@ -0,0 +1,7 @@
+import { ontology } from '../../ontology';
+export declare class Group {
+    key: string;
+    name: string;
+    constructor(name: string, key: string);
+    get ontologyID(): ontology.ID;
+}

package/dist/ontology/group/index.d.ts

@@ -0,0 +1 @@
+export * as group from '../../ontology/group/external';