@synnaxlabs/client 0.38.0 → 0.39.0

package/src/ontology/payload.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -10,43 +10,65 @@
 import { type change, type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import {
+  ALLOW_ALL_ONTOLOGY_TYPE as ALLOW_ALL_TYPE,
+  ONTOLOGY_TYPE as POLICY_TYPE,
+} from "@/access/policy/ontology";
+import { ONTOLOGY_TYPE as CHANNEL_TYPE } from "@/channel/payload";
+import { ONTOLOGY_TYPE as FRAMER_TYPE } from "@/framer/frame";
+import { ONTOLOGY_TYPE as DEVICE_TYPE } from "@/hardware/device/payload";
+import { ONTOLOGY_TYPE as RACK_TYPE } from "@/hardware/rack/payload";
+import { ONTOLOGY_TYPE as TASK_TYPE } from "@/hardware/task/payload";
+import { ONTOLOGY_TYPE as LABEL_TYPE } from "@/label/payload";
+import { ONTOLOGY_TYPE as GROUP_TYPE } from "@/ontology/group/payload";
+import {
+  ALIAS_ONTOLOGY_TYPE as RANGE_ALIAS_TYPE,
+  ONTOLOGY_TYPE as RANGE_TYPE,
+} from "@/ranger/payload";
+import { ONTOLOGY_TYPE as USER_TYPE } from "@/user/payload";
+import { ONTOLOGY_TYPE as LINE_PLOT_TYPE } from "@/workspace/lineplot/payload";
+import { ONTOLOGY_TYPE as LOG_TYPE } from "@/workspace/log/payload";
+import { ONTOLOGY_TYPE as WORKSPACE_TYPE } from "@/workspace/payload";
+import { ONTOLOGY_TYPE as SCHEMATIC_TYPE } from "@/workspace/schematic/payload";
+import { ONTOLOGY_TYPE as TABLE_TYPE } from "@/workspace/table/payload";
+
 export type ResourceChange = change.Change<ID, Resource>;
-export type ResourceSet = change.Set<ID, Resource>;
-export type ResourceDelete = change.Delete<ID, Resource>;
+export interface ResourceSet extends change.Set<ID, Resource> {}
+export interface ResourceDelete extends change.Delete<ID, Resource> {}
 export type RelationshipChange = change.Change<Relationship, undefined>;
-export type RelationshipSet = change.Set<Relationship, undefined>;
-export type RelationshipDelete = change.Delete<Relationship, undefined>;
-
-export const resourceTypeZ = z.union([
-  z.literal("label"),
-  z.literal("log"),
-  z.literal("allow_all"),
-  z.literal("builtin"),
-  z.literal("cluster"),
-  z.literal("channel"),
-  z.literal("node"),
-  z.literal("group"),
-  z.literal("range"),
-  z.literal("framer"),
-  z.literal("range-alias"),
-  z.literal("user"),
-  z.literal("workspace"),
-  z.literal("schematic"),
-  z.literal("lineplot"),
-  z.literal("rack"),
-  z.literal("device"),
-  z.literal("task"),
-  z.literal("policy"),
-  z.literal("table"),
+export interface RelationshipSet extends change.Set<Relationship, undefined> {}
+export interface RelationshipDelete extends change.Delete<Relationship, undefined> {}
+
+export const BUILTIN_TYPE = "builtin";
+export const CLUSTER_TYPE = "cluster";
+export const NODE_TYPE = "node";
+
+export const resourceTypeZ = z.enum([
+  LABEL_TYPE,
+  LOG_TYPE,
+  ALLOW_ALL_TYPE,
+  BUILTIN_TYPE,
+  CLUSTER_TYPE,
+  CHANNEL_TYPE,
+  NODE_TYPE,
+  GROUP_TYPE,
+  RANGE_TYPE,
+  FRAMER_TYPE,
+  RANGE_ALIAS_TYPE,
+  USER_TYPE,
+  WORKSPACE_TYPE,
+  SCHEMATIC_TYPE,
+  LINE_PLOT_TYPE,
+  RACK_TYPE,
+  DEVICE_TYPE,
+  TASK_TYPE,
+  POLICY_TYPE,
+  TABLE_TYPE,
 ]);
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 
-export const BUILTIN_TYPE: ResourceType = "builtin";
-export const CLUSTER_TYPE: ResourceType = "cluster";
-export const NODE_TYPE: ResourceType = "node";
-
 export const idZ = z.object({ type: resourceTypeZ, key: z.string() });
-export type IDPayload = z.infer<typeof idZ>;
+export interface IDPayload extends z.infer<typeof idZ> {}
 
 export const stringIDZ = z.string().transform((v) => {
   const [type, key] = v.split(":");
@@ -95,19 +117,18 @@ export class ID {
   static readonly z = z.union([z.instanceof(ID), crudeIDZ.transform((v) => new ID(v))]);
 }
 
-export const Root = new ID({ type: BUILTIN_TYPE, key: "root" });
+export const ROOT_ID = new ID({ type: BUILTIN_TYPE, key: "root" });
 
 export const schemaFieldZ = z.object({ type: z.number() });
-
-export type SchemaField = z.infer<typeof schemaFieldZ>;
+export interface SchemaField extends z.infer<typeof schemaFieldZ> {}
 
 export const schemaZ = z.object({
   type: resourceTypeZ,
   fields: z.record(schemaFieldZ),
 });
-export type Schema = z.infer<typeof schemaZ>;
+export interface Schema extends z.infer<typeof schemaZ> {}
 
-export const resourceSchemaZ = z
+export const resourceZ = z
   .object({
     id: ID.z,
     name: z.string(),
@@ -115,16 +136,19 @@ export const resourceSchemaZ = z
     data: z.record(z.unknown()).optional().nullable(),
   })
   .transform((resource) => ({ key: resource.id.toString(), ...resource }));
+export interface Resource<T extends UnknownRecord = UnknownRecord>
+  extends Omit<z.output<typeof resourceZ>, "data"> {
+  data?: T | null;
+}
 
-export type Resource<T extends UnknownRecord = UnknownRecord> = Omit<
-  z.output<typeof resourceSchemaZ>,
-  "data"
-> & { data?: T | null };
-
-export type RelationshipDirection = "from" | "to";
+export const TO_RELATIONSHIP_DIRECTION = "to";
+export const FROM_RELATIONSHIP_DIRECTION = "from";
+export type RelationshipDirection =
+  | typeof TO_RELATIONSHIP_DIRECTION
+  | typeof FROM_RELATIONSHIP_DIRECTION;
 
 export const relationshipSchemaZ = z.object({ from: ID.z, type: z.string(), to: ID.z });
-export type Relationship = z.infer<typeof relationshipSchemaZ>;
+export interface Relationship extends z.infer<typeof relationshipSchemaZ> {}
 
 export const parseRelationship = (str: string): Relationship => {
   const [from, type, to] = str.split("->");

package/src/ontology/writer.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -12,22 +12,15 @@ import { z } from "zod";
 
 import { type CrudeID, ID, idZ } from "@/ontology/payload";
 
-const ENDPOINTS = {
-  ADD_CHILDREN: "/ontology/add-children",
-  REMOVE_CHILDREN: "/ontology/remove-children",
-  MOVE_CHILDREN: "/ontology/move-children",
-};
+const ADD_CHILDREN_ENDPOINT = "/ontology/add-children";
+const REMOVE_CHILDREN_ENDPOINT = "/ontology/remove-children";
+const MOVE_CHILDREN_ENDPOINT = "/ontology/move-children";
 
-const addRemoveChildrenReqZ = z.object({
-  id: idZ,
-  children: idZ.array(),
-});
+const addRemoveChildrenReqZ = z.object({ id: idZ, children: idZ.array() });
 
-const moveChildrenReqZ = z.object({
-  from: idZ,
-  to: idZ,
-  children: idZ.array(),
-});
+const moveChildrenReqZ = z.object({ from: idZ, to: idZ, children: idZ.array() });
+
+const emptyResZ = z.object({});
 
 export class Writer {
   client: UnaryClient;
@@ -37,22 +30,22 @@ export class Writer {
   }
 
   async addChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
-    await sendRequired<typeof addRemoveChildrenReqZ, z.ZodTypeAny>(
+    await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      ENDPOINTS.ADD_CHILDREN,
+      ADD_CHILDREN_ENDPOINT,
       { id: new ID(id).payload, children: children.map((c) => new ID(c).payload) },
       addRemoveChildrenReqZ,
-      z.object({}),
+      emptyResZ,
     );
   }
 
   async removeChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
-    await sendRequired<typeof addRemoveChildrenReqZ, z.ZodTypeAny>(
+    await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      ENDPOINTS.REMOVE_CHILDREN,
+      REMOVE_CHILDREN_ENDPOINT,
       { id: new ID(id).payload, children: children.map((c) => new ID(c).payload) },
       addRemoveChildrenReqZ,
-      z.object({}),
+      emptyResZ,
     );
   }
 
@@ -66,12 +59,12 @@ export class Writer {
       to: new ID(to).payload,
       children: children.map((c) => new ID(c).payload),
     };
-    await sendRequired(
+    await sendRequired<typeof moveChildrenReqZ, typeof emptyResZ>(
       this.client,
-      ENDPOINTS.MOVE_CHILDREN,
+      MOVE_CHILDREN_ENDPOINT,
       req,
       moveChildrenReqZ,
-      z.object({}),
+      emptyResZ,
     );
   }
 }

package/src/ranger/alias.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -11,73 +11,60 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { type change } from "@synnaxlabs/x/change";
 import { z } from "zod";
 
-import { type channel } from "@/channel";
-import { type Key as ChannelKey, keyZ as channelKeyZ } from "@/channel/payload";
-import { type Client as FrameClient } from "@/framer/client";
+import { channel } from "@/channel";
+import { type framer } from "@/framer";
 import { type Key, keyZ } from "@/ranger/payload";
 import { signals } from "@/signals";
 
-export const ALIAS_SET_NAME = "sy_range_alias_set";
-export const ALIAS_DELETE_NAME = "sy_range_alias_delete";
+export const SET_ALIAS_CHANNEL_NAME = "sy_range_alias_set";
+export const DELETE_ALIAS_CHANNEL_NAME = "sy_range_alias_delete";
 
-const resolveReqZ = z.object({
-  range: keyZ,
-  aliases: z.string().array(),
-});
+const resolveReqZ = z.object({ range: keyZ, aliases: z.string().array() });
 
-const resolveResZ = z.object({
-  aliases: z.record(z.string(), channelKeyZ),
-});
+const resolveResZ = z.object({ aliases: z.record(z.string(), channel.keyZ) });
 
 const setReqZ = z.object({
   range: keyZ,
-  aliases: z.record(channelKeyZ.or(z.string()), z.string()),
+  aliases: z.record(channel.keyZ.or(z.string()), z.string()),
 });
 
 const setResZ = z.unknown();
 
-const deleteReqZ = z.object({
-  range: keyZ,
-  channels: channelKeyZ.array(),
-});
+const deleteReqZ = z.object({ range: keyZ, channels: channel.keyZ.array() });
 
 const deleteResZ = z.unknown();
 
-const listReqZ = z.object({
-  range: keyZ,
-});
+const listReqZ = z.object({ range: keyZ });
 
-const listResZ = z.object({
-  aliases: z.record(z.string(), z.string()),
-});
+const listResZ = z.object({ aliases: z.record(z.string(), z.string()) });
 
 export class Aliaser {
   private static readonly SET_ENDPOINT = "/range/alias/set";
   private static readonly RESOLVE_ENDPOINT = "/range/alias/resolve";
   private static readonly LIST_ENDPOINT = "/range/alias/list";
   private static readonly DELETE_ENDPOINT = "/range/alias/delete";
-  private readonly frameClient: FrameClient;
-  private readonly cache = new Map<string, ChannelKey>();
+  private readonly frameClient: framer.Client;
+  private readonly cache = new Map<string, channel.Key>();
   private readonly client: UnaryClient;
   private readonly rangeKey: Key;
 
-  constructor(rangeKey: Key, frameClient: FrameClient, client: UnaryClient) {
+  constructor(rangeKey: Key, frameClient: framer.Client, client: UnaryClient) {
     this.rangeKey = rangeKey;
     this.cache = new Map();
     this.client = client;
     this.frameClient = frameClient;
   }
 
-  resolve(aliases: string): Promise<ChannelKey>;
+  resolve(aliases: string): Promise<channel.Key>;
 
-  resolve(aliases: string[]): Promise<Record<string, ChannelKey>>;
+  resolve(aliases: string[]): Promise<Record<string, channel.Key>>;
 
   async resolve(
     aliases: string | string[],
-  ): Promise<ChannelKey | Record<string, ChannelKey>> {
+  ): Promise<channel.Key | Record<string, channel.Key>> {
     const toFetch: string[] = [];
     const isSingle = typeof aliases === "string";
-    const cached: Record<string, ChannelKey> = {};
+    const cached: Record<string, channel.Key> = {};
     if (isSingle) {
       const c = this.cache.get(aliases);
       if (c != null) return c;
@@ -100,7 +87,7 @@ export class Aliaser {
     return isSingle ? res.aliases[toFetch[0]] : { ...cached, ...res.aliases };
   }
 
-  async set(aliases: Record<ChannelKey, string>): Promise<void> {
+  async set(aliases: Record<channel.Key, string>): Promise<void> {
     await sendRequired<typeof setReqZ, typeof setResZ>(
       this.client,
       Aliaser.SET_ENDPOINT,
@@ -110,7 +97,7 @@ export class Aliaser {
     );
   }
 
-  async list(): Promise<Record<ChannelKey, string>> {
+  async list(): Promise<Record<channel.Key, string>> {
     return (
       await sendRequired<typeof listReqZ, typeof listResZ>(
         this.client,
@@ -122,7 +109,7 @@ export class Aliaser {
     ).aliases;
   }
 
-  async delete(aliases: ChannelKey[]): Promise<void> {
+  async delete(aliases: channel.Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
       Aliaser.DELETE_ENDPOINT,
@@ -135,8 +122,8 @@ export class Aliaser {
   async openChangeTracker(): Promise<signals.Observable<string, Alias>> {
     return await signals.openObservable<string, Alias>(
       this.frameClient,
-      ALIAS_SET_NAME,
-      ALIAS_DELETE_NAME,
+      SET_ALIAS_CHANNEL_NAME,
+      DELETE_ALIAS_CHANNEL_NAME,
       decodeAliasChanges(this.rangeKey),
     );
   }
@@ -150,13 +137,9 @@ export interface Alias {
 
 export type AliasChange = change.Change<string, Alias>;
 
-const aliasZ = z.object({
-  range: keyZ,
-  channel: channelKeyZ,
-  alias: z.string(),
-});
+const aliasZ = z.object({ range: keyZ, channel: channel.keyZ, alias: z.string() });
 
-const aliasSeparator = "---";
+const separator = "---";
 
 const decodeAliasChanges =
   (rangeKey: Key): signals.Decoder<string, Alias> =>
@@ -164,7 +147,7 @@ const decodeAliasChanges =
     if (variant === "delete")
       return data
         .toStrings()
-        .filter((k) => k.split(aliasSeparator)[0] === rangeKey)
+        .filter((k) => k.split(separator)[0] === rangeKey)
         .map((alias) => ({
           variant,
           key: alias,

package/src/ranger/client.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -14,25 +14,23 @@ import { type Series } from "@synnaxlabs/x/telem";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { type Key as ChannelKey } from "@/channel/payload";
-import { type Retriever as ChannelRetriever } from "@/channel/retriever";
+import { type channel } from "@/channel";
 import { MultipleFoundError, NotFoundError, QueryError } from "@/errors";
 import { type framer } from "@/framer";
 import { type label } from "@/label";
-import { type Label } from "@/label/payload";
-import { type ontology } from "@/ontology";
-import { type Resource } from "@/ontology/payload";
+import { ontology } from "@/ontology";
 import { type Alias, Aliaser } from "@/ranger/alias";
 import { KV } from "@/ranger/kv";
 import {
+  ALIAS_ONTOLOGY_TYPE,
   analyzeParams,
   type Key,
   type Keys,
   keyZ,
   type Name,
   type Names,
-  type NewPayload,
-  ontologyID,
+  type New,
+  ONTOLOGY_TYPE,
   type Params,
   type Payload,
   payloadZ,
@@ -47,7 +45,7 @@ export class Range {
   readonly kv: KV;
   readonly timeRange: TimeRange;
   readonly color: string | undefined;
-  readonly channels: ChannelRetriever;
+  readonly channels: channel.Retriever;
   private readonly aliaser: Aliaser;
   private readonly frameClient: framer.Client;
   private readonly labelClient: label.Client;
@@ -62,7 +60,7 @@ export class Range {
     _frameClient: framer.Client,
     _kv: KV,
     _aliaser: Aliaser,
-    _channels: ChannelRetriever,
+    _channels: channel.Retriever,
     _labelClient: label.Client,
     _ontologyClient: ontology.Client,
     _rangeClient: Client,
@@ -93,22 +91,21 @@ export class Range {
     };
   }
 
-  async setAlias(channel: ChannelKey | Name, alias: string): Promise<void> {
+  async setAlias(channel: channel.Key | Name, alias: string): Promise<void> {
     const ch = await this.channels.retrieve(channel);
     if (ch.length === 0) throw new QueryError(`Channel ${channel} does not exist`);
-
     await this.aliaser.set({ [ch[0].key]: alias });
   }
 
-  async deleteAlias(...channels: ChannelKey[]): Promise<void> {
+  async deleteAlias(...channels: channel.Key[]): Promise<void> {
     await this.aliaser.delete(channels);
   }
 
-  async listAliases(): Promise<Record<ChannelKey, string>> {
+  async listAliases(): Promise<Record<channel.Key, string>> {
     return await this.aliaser.list();
   }
 
-  async resolveAlias(alias: string): Promise<ChannelKey> {
+  async resolveAlias(alias: string): Promise<channel.Key> {
     return await this.aliaser.resolve(alias);
   }
 
@@ -131,14 +128,12 @@ export class Range {
   }
 
   async read(channel: Key | Name): Promise<Series>;
-
   async read(channels: Params): Promise<framer.Frame>;
-
   async read(channels: Params): Promise<Series | framer.Frame> {
     return await this.frameClient.read(this.timeRange, channels);
   }
 
-  async labels(): Promise<Label[]> {
+  async labels(): Promise<label.Label[]> {
     return await this.labelClient.retrieveFor(ontologyID(this.key));
   }
 
@@ -161,7 +156,7 @@ export class Range {
       dependents: initial,
       resourceType: "range",
     });
-    base.onChange((r: Resource[]) =>
+    base.onChange((r: ontology.Resource[]) =>
       wrapper.notify(this.rangeClient.resourcesToRanges(r)),
     );
     wrapper.setCloser(async () => await base.close());
@@ -179,7 +174,7 @@ export class Range {
       dependents: [resourceP],
       relationshipDirection: "to",
     });
-    base.onChange((resources: Resource[]) => {
+    base.onChange((resources: ontology.Resource[]) => {
       const ranges = this.rangeClient.resourcesToRanges(resources);
       if (ranges.length === 0) return;
       const p = ranges[0];
@@ -202,20 +197,18 @@ const retrieveReqZ = z.object({
   offset: z.number().int().optional(),
 });
 
-export type RetrieveRequest = z.infer<typeof retrieveReqZ>;
+export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
 
 const RETRIEVE_ENDPOINT = "/range/retrieve";
 
-const retrieveResZ = z.object({
-  ranges: nullableArrayZ(payloadZ),
-});
+const retrieveResZ = z.object({ ranges: nullableArrayZ(payloadZ) });
 
 export class Client implements AsyncTermSearcher<string, Key, Range> {
   readonly type: string = "range";
   private readonly frameClient: framer.Client;
   private readonly writer: Writer;
   private readonly unaryClient: UnaryClient;
-  private readonly channels: ChannelRetriever;
+  private readonly channels: channel.Retriever;
   private readonly labelClient: label.Client;
   private readonly ontologyClient: ontology.Client;
 
@@ -223,7 +216,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     frameClient: framer.Client,
     writer: Writer,
     unary: UnaryClient,
-    channels: ChannelRetriever,
+    channels: channel.Retriever,
     labelClient: label.Client,
     ontologyClient: ontology.Client,
   ) {
@@ -235,14 +228,9 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     this.ontologyClient = ontologyClient;
   }
 
-  async create(range: NewPayload, options?: CreateOptions): Promise<Range>;
-
-  async create(ranges: NewPayload[], options?: CreateOptions): Promise<Range[]>;
-
-  async create(
-    ranges: NewPayload | NewPayload[],
-    options?: CreateOptions,
-  ): Promise<Range | Range[]> {
+  async create(range: New, options?: CreateOptions): Promise<Range>;
+  async create(ranges: New[], options?: CreateOptions): Promise<Range[]>;
+  async create(ranges: New | New[], options?: CreateOptions): Promise<Range | Range[]> {
     const single = !Array.isArray(ranges);
     const res = this.sugarMany(await this.writer.create(toArray(ranges), options));
     return single ? res[0] : res;
@@ -265,11 +253,8 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
   }
 
   async retrieve(range: CrudeTimeRange): Promise<Range[]>;
-
   async retrieve(range: Key | Name): Promise<Range>;
-
   async retrieve(range: Keys | Names): Promise<Range[]>;
-
   async retrieve(ranges: Params | CrudeTimeRange): Promise<Range | Range[]> {
     if (typeof ranges === "object" && "start" in ranges)
       return await this.execRetrieve({ overlapsWith: new TimeRange(ranges) });
@@ -278,9 +263,11 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     const retrieved = await this.execRetrieve({ [variant]: normalized });
     if (!single) return retrieved;
     if (retrieved.length === 0)
-      throw new NotFoundError(`range matching ${actual} not found`);
+      throw new NotFoundError(`range matching ${actual as string} not found`);
     if (retrieved.length > 1)
-      throw new MultipleFoundError(`multiple ranges matching ${actual} found`);
+      throw new MultipleFoundError(
+        `multiple ranges matching ${actual as string} found`,
+      );
     return retrieved[0];
   }
 
@@ -341,11 +328,11 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     );
   }
 
-  resourcesToRanges(resources: Resource[]): Range[] {
+  resourcesToRanges(resources: ontology.Resource[]): Range[] {
     return resources.map((r) => this.resourceToRange(r));
   }
 
-  resourceToRange(resource: Resource): Range {
+  resourceToRange(resource: ontology.Resource): Range {
     return this.sugarOne({
       key: resource.id.key,
       name: resource.data?.name as string,
@@ -354,3 +341,9 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     });
   }
 }
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+
+export const aliasOntologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key });

package/src/ranger/external.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export type { Alias, AliasChange } from "@/ranger/alias";
+export { type Alias, type AliasChange } from "@/ranger/alias";
 export * from "@/ranger/client";
 export * from "@/ranger/kv";
 export * from "@/ranger/payload";

package/src/ranger/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.