@synnaxlabs/client 0.2.0 → 0.13.5

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const keyZ: z.ZodString;
+export type Key = z.infer<typeof keyZ>;
+export type Name = string;
+export type Keys = Key[];
+export type Names = Name[];
+export type Params = Key | Name | Keys | Names;
+export declare const payloadZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+}, {
+    name: string;
+    key: string;
+}>;
+export type Payload = z.infer<typeof payloadZ>;
+export type ParamAnalysisResult = {
+    single: true;
+    variant: "keys";
+    normalized: Keys;
+    actual: Key;
+} | {
+    single: true;
+    variant: "names";
+    normalized: Names;
+    actual: Name;
+} | {
+    single: false;
+    variant: "keys";
+    normalized: Keys;
+    actual: Keys;
+} | {
+    single: false;
+    variant: "names";
+    normalized: Names;
+    actual: Names;
+};
+export declare const analyzeParams: (params: Params) => ParamAnalysisResult;

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

@@ -0,0 +1,13 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type Payload } from '../../ontology/group/payload';
+import { type ID } from '../../ontology/payload';
+export declare class Writer {
+    private static readonly ENDPOINT;
+    private static readonly ENDPOINT_RENAME;
+    private static readonly ENDPOINT_DELETE;
+    client: UnaryClient;
+    constructor(client: UnaryClient);
+    create(parent: ID, name: string): Promise<Payload>;
+    rename(key: string, name: string): Promise<void>;
+    delete(keys: string[]): Promise<void>;
+}

package/dist/ontology/index.d.ts

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

package/dist/ontology/ontology.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ontology/payload.d.ts

@@ -0,0 +1,235 @@
+import { z } from "zod";
+declare const resourceTypeZ: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+export type ResourceType = z.infer<typeof resourceTypeZ>;
+export declare const idZ: z.ZodObject<{
+    type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+}, {
+    key: string;
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+}>;
+export declare const stringIDZ: z.ZodEffects<z.ZodString, {
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    key: string;
+}, string>;
+export declare const crudeIDZ: z.ZodUnion<[z.ZodEffects<z.ZodString, {
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    key: string;
+}, string>, z.ZodObject<{
+    type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+}, {
+    key: string;
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+}>]>;
+export declare class ID {
+    type: ResourceType;
+    key: string;
+    constructor(args: z.input<typeof crudeIDZ> | ID);
+    toString(): string;
+    get payload(): z.infer<typeof idZ>;
+    static readonly z: z.ZodEffects<z.ZodUnion<[z.ZodUnion<[z.ZodEffects<z.ZodString, {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        key: string;
+    }, string>, z.ZodObject<{
+        type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>]>, z.ZodType<ID, z.ZodTypeDef, ID>]>, ID, string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>;
+}
+export declare const Root: ID;
+export declare const schemaFieldZ: z.ZodObject<{
+    type: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: number;
+}, {
+    type: number;
+}>;
+export type SchemaField = z.infer<typeof schemaFieldZ>;
+export declare const schemaZ: z.ZodObject<{
+    type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: number;
+    }, {
+        type: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    fields: Record<string, {
+        type: number;
+    }>;
+}, {
+    type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    fields: Record<string, {
+        type: number;
+    }>;
+}>;
+export type Schema = z.infer<typeof schemaZ>;
+export declare const resourceSchemaZ: z.ZodEffects<z.ZodObject<{
+    id: z.ZodEffects<z.ZodUnion<[z.ZodUnion<[z.ZodEffects<z.ZodString, {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        key: string;
+    }, string>, z.ZodObject<{
+        type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>]>, z.ZodType<ID, z.ZodTypeDef, ID>]>, ID, string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>;
+    name: z.ZodString;
+    schema: z.ZodOptional<z.ZodObject<{
+        type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type: number;
+        }, {
+            type: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        fields: Record<string, {
+            type: number;
+        }>;
+    }, {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        fields: Record<string, {
+            type: number;
+        }>;
+    }>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: ID;
+    schema?: {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        fields: Record<string, {
+            type: number;
+        }>;
+    } | undefined;
+    data?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    id: (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }) & (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    } | undefined);
+    schema?: {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        fields: Record<string, {
+            type: number;
+        }>;
+    } | undefined;
+    data?: Record<string, unknown> | undefined;
+}>, {
+    name: string;
+    id: ID;
+    schema?: {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        fields: Record<string, {
+            type: number;
+        }>;
+    } | undefined;
+    data?: Record<string, unknown> | undefined;
+    key: string;
+}, {
+    name: string;
+    id: (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }) & (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    } | undefined);
+    schema?: {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        fields: Record<string, {
+            type: number;
+        }>;
+    } | undefined;
+    data?: Record<string, unknown> | undefined;
+}>;
+export type Resource = z.infer<typeof resourceSchemaZ>;
+export declare const relationshipSchemaZ: z.ZodObject<{
+    from: z.ZodEffects<z.ZodUnion<[z.ZodUnion<[z.ZodEffects<z.ZodString, {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        key: string;
+    }, string>, z.ZodObject<{
+        type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>]>, z.ZodType<ID, z.ZodTypeDef, ID>]>, ID, string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>;
+    type: z.ZodString;
+    to: z.ZodEffects<z.ZodUnion<[z.ZodUnion<[z.ZodEffects<z.ZodString, {
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+        key: string;
+    }, string>, z.ZodObject<{
+        type: z.ZodUnion<[z.ZodLiteral<"label">, z.ZodLiteral<"builtin">, z.ZodLiteral<"cluster">, z.ZodLiteral<"channel">, z.ZodLiteral<"node">, z.ZodLiteral<"group">, z.ZodLiteral<"range">, z.ZodLiteral<"range-alias">, z.ZodLiteral<"user">, z.ZodLiteral<"workspace">, z.ZodLiteral<"pid">, z.ZodLiteral<"lineplot">]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }, {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>]>, z.ZodType<ID, z.ZodTypeDef, ID>]>, ID, string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    from: ID;
+    to: ID;
+}, {
+    type: string;
+    from: (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }) & (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    } | undefined);
+    to: (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    }) & (string | ID | {
+        key: string;
+        type: "user" | "label" | "builtin" | "cluster" | "channel" | "node" | "group" | "range" | "range-alias" | "workspace" | "pid" | "lineplot";
+    } | undefined);
+}>;
+export type Relationship = z.infer<typeof relationshipSchemaZ>;
+export declare const parseRelationship: (str: string) => Relationship;
+export {};

package/dist/ontology/retriever.d.ts

@@ -0,0 +1,12 @@
+import type { UnaryClient } from "@synnaxlabs/freighter";
+import { ID, type Resource } from '../ontology/payload';
+export declare class Retriever {
+    private static readonly ENDPOINT;
+    private readonly client;
+    constructor(unary: UnaryClient);
+    search(term: string): Promise<Resource[]>;
+    retrieve(ids: ID | ID[] | string | string[], includeSchema?: boolean, includeFieldData?: boolean): Promise<Resource[]>;
+    retrieveChildren(ids: ID | ID[], includeSchema?: boolean, includeFieldData?: boolean): Promise<Resource[]>;
+    retrieveParents(ids: ID | ID[], includeSchema?: boolean, includeFieldData?: boolean): Promise<Resource[]>;
+    private execute;
+}

package/dist/ontology/signals.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/writer.d.ts

@@ -0,0 +1,9 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type ID } from '../ontology/payload';
+export declare class Writer {
+    client: UnaryClient;
+    constructor(client: UnaryClient);
+    addChildren(id: ID, ...children: ID[]): Promise<void>;
+    removeChildren(id: ID, ...children: ID[]): Promise<void>;
+    moveChildren(from: ID, to: ID, ...children: ID[]): Promise<void>;
+}

package/dist/ranger/active.d.ts

@@ -0,0 +1,9 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type Payload, type Key } from "./payload";
+export declare class Active {
+    private readonly client;
+    constructor(client: UnaryClient);
+    setActive(range: Key): Promise<void>;
+    retrieveActive(): Promise<Payload | null>;
+    clearActive(range: Key): Promise<void>;
+}

package/dist/ranger/alias.d.ts

@@ -0,0 +1,32 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type change } from "@synnaxlabs/x";
+import { type channel } from '../channel';
+import { type Key as ChannelKey } from '../channel/payload';
+import { type Client as FrameClient } from '../framer/client';
+import { type Key } from '../ranger/payload';
+import { signals } from '../signals';
+export declare const ALIAS_SET_NAME = "sy_range_alias_set";
+export declare const ALIAS_DELETE_NAME = "sy_range_alias_delete";
+export declare class Aliaser {
+    private static readonly SET_ENDPOINT;
+    private static readonly RESOLVE_ENDPOINT;
+    private static readonly LIST_ENDPOINT;
+    private static readonly DELETE_ENDPOINT;
+    private readonly frameClient;
+    private readonly cache;
+    private readonly client;
+    private readonly rangeKey;
+    constructor(rangeKey: Key, frameClient: FrameClient, client: UnaryClient);
+    resolve(aliases: string): Promise<ChannelKey>;
+    resolve(aliases: string[]): Promise<Record<string, ChannelKey>>;
+    set(aliases: Record<ChannelKey, string>): Promise<void>;
+    list(): Promise<Record<ChannelKey, string>>;
+    delete(aliases: ChannelKey[]): Promise<void>;
+    openChangeTracker(): Promise<signals.Observable<string, Alias>>;
+}
+export interface Alias {
+    range: Key;
+    channel: channel.Key;
+    alias: string;
+}
+export type AliasChange = change.Change<string, Alias>;

package/dist/ranger/client.d.ts

@@ -0,0 +1,31 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type AsyncTermSearcher } from "@synnaxlabs/x";
+import { type Retriever as ChannelRetriever } from '../channel/retriever';
+import { type framer } from '../framer';
+import { type label } from '../label';
+import { type NewPayload, type Key, type Keys, type Name, type Names } from '../ranger/payload';
+import { Range } from '../ranger/range';
+import { type Retriever } from '../ranger/retriever';
+import { type Writer } from '../ranger/writer';
+export declare class Client implements AsyncTermSearcher<string, Key, Range> {
+    private readonly frameClient;
+    private readonly retriever;
+    private readonly writer;
+    private readonly unaryClient;
+    private readonly channels;
+    private readonly active;
+    private readonly labelClient;
+    constructor(frameClient: framer.Client, retriever: Retriever, writer: Writer, unary: UnaryClient, channels: ChannelRetriever, labelClient: label.Client);
+    create(range: NewPayload): Promise<Range>;
+    create(ranges: NewPayload[]): Promise<Range[]>;
+    rename(key: Key, name: Name): Promise<void>;
+    delete(key: Key | Keys): Promise<void>;
+    search(term: string): Promise<Range[]>;
+    page(offset: number, limit: number): Promise<Range[]>;
+    retrieve(range: Key | Name): Promise<Range>;
+    retrieve(params: Keys | Names): Promise<Range[]>;
+    setActive(range: Key): Promise<void>;
+    retrieveActive(): Promise<Range | null>;
+    clearActive(range: Key): Promise<void>;
+    private sugar;
+}

package/dist/ranger/external.d.ts

@@ -0,0 +1,6 @@
+export * from '../ranger/client';
+export * from '../ranger/writer';
+export * from '../ranger/payload';
+export * from '../ranger/range';
+export * from '../ranger/retriever';
+export type { Alias, AliasChange } from '../ranger/alias';

package/dist/ranger/index.d.ts

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

package/dist/ranger/kv.d.ts

@@ -0,0 +1,50 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+import { type Key } from '../ranger/payload';
+declare const getReqZ: z.ZodObject<{
+    range: z.ZodString;
+    keys: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    keys: string[];
+    range: string;
+}, {
+    keys: string[];
+    range: string;
+}>;
+export type GetRequest = z.infer<typeof getReqZ>;
+declare const setReqZ: z.ZodObject<{
+    range: z.ZodString;
+    pairs: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    range: string;
+    pairs: Record<string, string>;
+}, {
+    range: string;
+    pairs: Record<string, string>;
+}>;
+export type SetRequest = z.infer<typeof setReqZ>;
+declare const deleteReqZ: z.ZodObject<{
+    range: z.ZodString;
+    keys: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    keys: string[];
+    range: string;
+}, {
+    keys: string[];
+    range: string;
+}>;
+export type DeleteRequest = z.infer<typeof deleteReqZ>;
+export declare class KV {
+    private static readonly GET_ENDPOINT;
+    private static readonly SET_ENDPOINT;
+    private static readonly DELETE_ENDPOINT;
+    private readonly rangeKey;
+    private readonly client;
+    constructor(rng: Key, client: UnaryClient);
+    get(key: string): Promise<string>;
+    get(keys: string[]): Promise<Record<string, string>>;
+    set(key: string, value: string): Promise<void>;
+    set(kv: Record<string, string>): Promise<void>;
+    delete(key: string | string[]): Promise<void>;
+}
+export {};

package/dist/ranger/payload.d.ts

@@ -0,0 +1,94 @@
+import { TimeRange } from "@synnaxlabs/x";
+import { z } from "zod";
+export declare const keyZ: z.ZodString;
+export type Key = z.infer<typeof keyZ>;
+export type Name = string;
+export type Keys = Key[];
+export type Names = Name[];
+export type Params = Key | Name | Keys | Names;
+export declare const payloadZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    timeRange: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        start: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+        end: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+    }, "strip", z.ZodTypeAny, {
+        start: import("@synnaxlabs/x").TimeStamp;
+        end: import("@synnaxlabs/x").TimeStamp;
+    }, {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    }>, TimeRange, {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    }>, z.ZodType<TimeRange, z.ZodTypeDef, TimeRange>]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    timeRange: TimeRange;
+}, {
+    name: string;
+    key: string;
+    timeRange: (TimeRange | {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    }) & (TimeRange | {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    } | undefined);
+}>;
+export type Payload = z.infer<typeof payloadZ>;
+export declare const newPayloadZ: z.ZodObject<{
+    name: z.ZodString;
+    timeRange: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        start: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+        end: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+    }, "strip", z.ZodTypeAny, {
+        start: import("@synnaxlabs/x").TimeStamp;
+        end: import("@synnaxlabs/x").TimeStamp;
+    }, {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    }>, TimeRange, {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    }>, z.ZodType<TimeRange, z.ZodTypeDef, TimeRange>]>;
+    key: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    timeRange: TimeRange;
+    key?: string | undefined;
+}, {
+    name: string;
+    timeRange: (TimeRange | {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    }) & (TimeRange | {
+        start: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        end: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+    } | undefined);
+    key?: string | undefined;
+}>;
+export type NewPayload = z.infer<typeof newPayloadZ>;
+export type ParamAnalsysisResult = {
+    single: true;
+    variant: "keys";
+    normalized: Keys;
+    actual: Key;
+} | {
+    single: true;
+    variant: "names";
+    normalized: Names;
+    actual: Name;
+} | {
+    single: false;
+    variant: "keys";
+    normalized: Keys;
+    actual: Keys;
+} | {
+    single: false;
+    variant: "names";
+    normalized: Names;
+    actual: Names;
+};
+export declare const analyzeParams: (params: Params) => ParamAnalsysisResult;

package/dist/ranger/range.d.ts

@@ -0,0 +1,29 @@
+import { type Series, TimeRange } from "@synnaxlabs/x";
+import { type Key, type Params, type Name } from '../channel/payload';
+import { type Retriever as ChannelRetriever } from '../channel/retriever';
+import { type framer } from '../framer';
+import { type label } from '../label';
+import { type Label } from '../label/payload';
+import { type Alias, type Aliaser } from '../ranger/alias';
+import { type KV } from '../ranger/kv';
+import { type signals } from '../signals';
+export declare class Range {
+    key: string;
+    name: string;
+    readonly kv: KV;
+    readonly timeRange: TimeRange;
+    readonly channels: ChannelRetriever;
+    private readonly aliaser;
+    private readonly frameClient;
+    private readonly labelClient;
+    constructor(name: string, timeRange: TimeRange | undefined, key: string, _frameClient: framer.Client, _kv: KV, _aliaser: Aliaser, _channels: ChannelRetriever, _labelClient: label.Client);
+    setAlias(channel: Key | Name, alias: string): Promise<void>;
+    deleteAlias(...channels: Key[]): Promise<void>;
+    listAliases(): Promise<Record<Key, string>>;
+    openAliasTracker(): Promise<signals.Observable<string, Alias>>;
+    read(channel: Key | Name): Promise<Series>;
+    read(channels: Params): Promise<framer.Frame>;
+    labels(): Promise<Label[]>;
+    addLabel(...labels: label.Key[]): Promise<void>;
+    removeLabel(...labels: label.Key[]): Promise<void>;
+}

package/dist/ranger/ranger.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ranger/retriever.d.ts

@@ -0,0 +1,10 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type Params, type Payload } from "./payload";
+export declare class Retriever {
+    private readonly ENDPOINT;
+    private readonly client;
+    constructor(client: UnaryClient);
+    retrieve(params: Params): Promise<Payload[]>;
+    search(term: string): Promise<Payload[]>;
+    private execute;
+}

package/dist/ranger/writer.d.ts

@@ -0,0 +1,9 @@
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { type NewPayload, type Payload } from '../ranger/payload';
+export declare class Writer {
+    client: UnaryClient;
+    constructor(client: UnaryClient);
+    rename(key: string, name: string): Promise<void>;
+    create(ranges: NewPayload[]): Promise<Payload[]>;
+    delete(keys: string[]): Promise<void>;
+}