@synnaxlabs/client 0.53.1 → 0.54.0

package/src/channel/retriever.ts

@@ -12,19 +12,10 @@ import { array, DataType, debounce, zod } from "@synnaxlabs/x";
 import { Mutex } from "async-mutex";
 import { z } from "zod";
 
-import {
-  type Key,
-  type KeyOrName,
-  type Keys,
-  type KeysOrNames,
-  keyZ,
-  type Params,
-  type Payload,
-  payloadZ,
-  type PrimitiveParams,
-} from "@/channel/payload";
+import { type Params, type PrimitiveParams } from "@/channel/payload";
+import { type Key, keyZ, type Name, type Payload, payloadZ } from "@/channel/types.gen";
 import { QueryError } from "@/errors";
-import { keyZ as rangeKeyZ } from "@/ranger/payload";
+import { keyZ as rangeKeyZ } from "@/ranger/types.gen";
 import {
   analyzeParams as analyzeParameters,
   type ParamAnalysisResult,
@@ -53,11 +44,11 @@ export interface RetrieveOptions extends Omit<
 > {}
 export interface PageOptions extends Omit<RetrieveOptions, "offset" | "limit"> {}
 
-const resZ = z.object({ channels: array.nullableZ(payloadZ) });
+const resZ = z.object({ channels: array.nullishToEmpty(payloadZ) });
 
 export const analyzeParams = (
   channels: Params,
-): ParamAnalysisResult<KeyOrName, { number: "keys"; string: "names" }> => {
+): ParamAnalysisResult<Key | Name, { number: "keys"; string: "names" }> => {
   if (Array.isArray(channels) && channels.length > 0 && typeof channels[0] === "object")
     channels = (channels as Payload[]).map((c) => c.key);
   else if (typeof channels === "object" && "key" in channels) channels = [channels.key];
@@ -125,7 +116,7 @@ export class CacheRetriever implements Retriever {
       return await this.wrapped.retrieve(channels);
     const { normalized } = analyzeParams(channels);
     const results: Payload[] = [];
-    const toFetch: KeysOrNames = [];
+    const toFetch: Key[] | Name[] = [];
     normalized.forEach((keyOrName) => {
       const c = this.get(keyOrName);
       if (c != null) results.push(...c);
@@ -183,7 +174,7 @@ export class CacheRetriever implements Retriever {
     });
   }
 
-  private get(channel: KeyOrName): Payload[] | undefined {
+  private get(channel: Key | Name): Payload[] | undefined {
     if (typeof channel === "number") {
       const ch = this.cache.get(channel);
       if (ch == null) return undefined;
@@ -209,7 +200,7 @@ export interface PromiseFns<T> {
 // no interval
 export class DebouncedBatchRetriever implements Retriever {
   private readonly mu = new Mutex();
-  private readonly requests = new Map<Keys, PromiseFns<Payload[]>>();
+  private readonly requests = new Map<Key[], PromiseFns<Payload[]>>();
   private readonly wrapped: Retriever;
   private readonly debouncedRun: () => void;
 
@@ -260,7 +251,7 @@ export const retrieveRequired = async (
 ): Promise<Payload[]> => {
   const { normalized } = analyzeParams(channels);
   const results = await r.retrieve(normalized);
-  const notFound: KeyOrName[] = [];
+  const notFound: (Key | Name)[] = [];
   normalized.forEach((v) => {
     if (results.find((c) => c.name === v || c.key === v) == null) notFound.push(v);
   });

package/src/channel/types.gen.ts

@@ -0,0 +1,137 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { control, status, telem, TimeSpan, zod } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { cluster } from "@/cluster";
+import { ontology } from "@/ontology";
+
+export const keyZ = z.uint32().or(
+  z
+    .string()
+    .refine((v) => !isNaN(Number(v)))
+    .transform(Number),
+);
+export type Key = z.infer<typeof keyZ>;
+
+export const localKeyZ = zod.uint20;
+export type LocalKey = z.infer<typeof localKeyZ>;
+
+export const OPERATION_TYPES = ["min", "max", "avg", "none"] as const;
+export const operationTypeZ = z.enum(OPERATION_TYPES);
+export type OperationType = z.infer<typeof operationTypeZ>;
+
+/**
+ * Operation defines an aggregation operation applied to channel data. Operations
+ * calculate min, max, or average values over a time duration or triggered
+ * by a reset channel.
+ */
+export const operationZ = z.object({
+  /** type is the aggregation operation type: min, max, avg, or none. */
+  type: operationTypeZ,
+  /**
+   * resetChannel is the channel key that triggers reset of the aggregation. If 0,
+   * duration-based reset is used.
+   */
+  resetChannel: keyZ.default(0),
+  /** duration is the time window for aggregation when reset_channel is 0. */
+  duration: telem.timeSpanZ.default(TimeSpan.ZERO),
+});
+export interface Operation extends z.infer<typeof operationZ> {}
+
+export const nameZ = z.string().min(1, "Name is required");
+export type Name = z.infer<typeof nameZ>;
+
+export const statusZ = status.statusZ();
+export type Status = z.infer<typeof statusZ>;
+
+/**
+ * Payload is a logical collection of samples emitted by or representing values
+ * from a single source. Channels are the fundamental unit of telemetry
+ * storage and streaming in Synnax.
+ */
+export const payloadZ = z.object({
+  /**
+   * key is the unique identifier for this channel, automatically assigned
+   * by Synnax.
+   */
+  key: keyZ,
+  /** name is the human-readable channel name. */
+  name: nameZ,
+  /**
+   * leaseholder is the cluster node that holds the lease for this channel. Mostly
+   * for internal use.
+   */
+  leaseholder: cluster.nodeKeyZ,
+  /**
+   * dataType is the data type of samples stored in this channel (e.g., Float64,
+   * Int32, TimeStamp).
+   */
+  dataType: telem.dataTypeZ,
+  /**
+   * isIndex is true if this is an index channel. Index channels must have int64
+   * values (TIMESTAMP data type) written in ascending order, and are
+   * most commonly unix nanosecond timestamps.
+   */
+  isIndex: z.boolean(),
+  /**
+   * index is the channel used to index this channel's values, associating
+   * each value with a timestamp. If zero, the channel's data will be
+   * indexed using its rate.
+   */
+  index: keyZ,
+  /** alias is an optional alternate name for the channel within a specific context. */
+  alias: z.string().optional(),
+  /**
+   * virtual is true if this channel does not store data in the database but can
+   * still be used for streaming purposes.
+   */
+  virtual: z.boolean().default(false),
+  /** internal is true if this is a system channel hidden from normal user queries. */
+  internal: z.boolean().default(false),
+  /**
+   * expression is an Arc expression for calculated channels. If set, the channel
+   * is automatically configured as virtual.
+   */
+  expression: z.string().default(""),
+  /**
+   * operations contains optional aggregation operations (min, max, avg) applied to
+   * channel data over time or triggered by a reset channel.
+   */
+  operations: zod.nullToUndefined(operationZ.array()),
+  /**
+   * concurrency sets the policy for concurrent writes to the channel's data. Only
+   * virtual channels can have a policy of shared concurrency.
+   */
+  concurrency: control.concurrencyZ.default(control.Concurrency.exclusive).optional(),
+  /** status is the current operational status of the channel. */
+  status: statusZ.optional(),
+});
+export interface Payload extends z.infer<typeof payloadZ> {}
+
+export const newZ = payloadZ
+  .omit({ leaseholder: true })
+  .partial({
+    key: true,
+    index: true,
+    isIndex: true,
+    internal: true,
+    virtual: true,
+    expression: true,
+  })
+  .extend({
+    leaseholder: zod.uint12.optional(),
+  });
+export interface New extends z.input<typeof newZ> {}
+
+export const ontologyID = ontology.createIDFactory<Key>("channel");
+export const TYPE_ONTOLOGY_ID = ontologyID(0);

package/src/channel/writer.ts

@@ -11,6 +11,7 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { type DataType } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import { type CacheRetriever } from "@/channel/retriever";
 import {
   type Key,
   keyZ,
@@ -19,8 +20,7 @@ import {
   newZ,
   type Payload,
   payloadZ,
-} from "@/channel/payload";
-import { type CacheRetriever } from "@/channel/retriever";
+} from "@/channel/types.gen";
 
 const createReqZ = z.object({ channels: newZ.array() });
 const createResZ = z.object({ channels: payloadZ.array() });

package/src/client.ts

@@ -26,6 +26,8 @@ import { log } from "@/log";
 import { ontology } from "@/ontology";
 import { rack } from "@/rack";
 import { ranger } from "@/ranger";
+import { alias } from "@/ranger/alias";
+import { kv } from "@/ranger/kv";
 import { schematic } from "@/schematic";
 import { status } from "@/status";
 import { table } from "@/table";
@@ -152,6 +154,8 @@ export default class Synnax extends framer.Client {
       chRetriever,
       this.labels,
       this.ontology,
+      (key: ranger.Key) => new alias.Client(key, this.transport.unary),
+      (key: ranger.Key) => new kv.Client(key, this.transport.unary),
     );
     this.access = new access.Client(this.transport.unary);
     this.users = new user.Client(this.transport.unary);

package/src/cluster/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * as cluster from "@/cluster/types.gen";

package/src/cluster/types.gen.ts

@@ -0,0 +1,16 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { zod } from "@synnaxlabs/x";
+import { type z } from "zod";
+
+export const nodeKeyZ = zod.uint12;
+export type NodeKey = z.infer<typeof nodeKeyZ>;

package/src/control/state.ts

@@ -11,24 +11,26 @@ import { binary, control, type observe } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type channel } from "@/channel";
-import { keyZ } from "@/channel/payload";
+import { keyZ } from "@/channel/types.gen";
 import { framer } from "@/framer";
 
 export type Authority = control.Authority;
 export const ABSOLUTE_AUTHORITY = control.ABSOLUTE_AUTHORITY;
 export const ZERO_AUTHORITY = control.ZERO_AUTHORITY;
-export type Transfer = control.Transfer<channel.Key>;
-export interface State extends control.State<channel.Key> {}
+export type Transfer = control.Transfer<typeof channel.keyZ>;
+export interface State extends control.State<typeof channel.keyZ> {}
 export interface Subject extends control.Subject {}
 export const stateZ = control.stateZ(z.number());
 
 export const transferString = (t: Transfer): string => {
-  if (t.to == null) return `${t.from?.resource} - ${t.from?.subject.name} -> released`;
+  const fromResource = t.from?.resource;
+  const toResource = t.to?.resource;
+  if (t.to == null) return `${fromResource} - ${t.from?.subject.name} -> released`;
   if (t.from == null)
-    return `${t.to.resource} - released -> ${
+    return `${toResource} - released -> ${
       t.to.subject.name
     } (${t.to.authority.toString()})`;
-  return `${t.to.resource} - ${t.from.subject.name} -> ${
+  return `${toResource} - ${t.from.subject.name} -> ${
     t.to.subject.name
   } (${t.to.authority.toString()})`;
 };

package/src/device/client.ts

@@ -19,16 +19,17 @@ import {
   keyZ,
   type New,
   newZ,
-} from "@/device/payload";
+  ontologyID,
+} from "@/device/types.gen";
 import { ontology } from "@/ontology";
-import { keyZ as rackKeyZ } from "@/rack/payload";
+import { keyZ as rackKeyZ } from "@/rack/types.gen";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
 export const SET_CHANNEL_NAME = "sy_device_set";
 export const DELETE_CHANNEL_NAME = "sy_device_delete";
 
 const createReqZ = <
-  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
   Make extends z.ZodType<string> = z.ZodString,
   Model extends z.ZodType<string> = z.ZodString,
 >(
@@ -36,7 +37,7 @@ const createReqZ = <
 ) => z.object({ devices: zod.toArray(newZ(schemas)) });
 
 const createResZ = <
-  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
   Make extends z.ZodType<string> = z.ZodString,
   Model extends z.ZodType<string> = z.ZodString,
 >(
@@ -57,15 +58,16 @@ const retrieveRequestZ = z.object({
   limit: z.int().optional(),
   offset: z.int().optional(),
   includeStatus: z.boolean().optional(),
+  includeParent: z.boolean().optional(),
 });
 
 const retrieveResZ = <
-  Properties extends z.ZodType<record.Unknown> = typeof record.unknownZ,
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
   Make extends z.ZodType<string> = z.ZodString,
   Model extends z.ZodType<string> = z.ZodString,
 >(
   schemas?: DeviceSchemas<Properties, Make, Model>,
-) => z.object({ devices: array.nullableZ(deviceZ(schemas)) });
+) => z.object({ devices: array.nullishToEmpty(deviceZ(schemas)) });
 
 const singleRetrieveArgsZ = z
   .object({
@@ -133,6 +135,10 @@ export class Client {
     return isSingle ? res.devices[0] : res.devices;
   }
 
+  async create(device: New): Promise<Device>;
+
+  async create(devices: New[]): Promise<Device[]>;
+
   async create<
     Properties extends z.ZodType<record.Unknown>,
     Make extends z.ZodType<string>,
@@ -142,7 +148,7 @@ export class Client {
     schemas: DeviceSchemas<Properties, Make, Model>,
   ): Promise<Device<Properties, Make, Model>>;
 
-  async create(device: New): Promise<Device>;
+  async create(device: New, schemas?: DeviceSchemas): Promise<Device>;
 
   async create<
     Properties extends z.ZodType<record.Unknown>,
@@ -153,7 +159,7 @@ export class Client {
     schemas: DeviceSchemas<Properties, Make, Model>,
   ): Promise<Device<Properties, Make, Model>[]>;
 
-  async create(devices: New[]): Promise<Device[]>;
+  async create(devices: New[], schemas?: DeviceSchemas): Promise<Device[]>;
 
   async create(
     devices: New | New[],
@@ -181,7 +187,4 @@ export class Client {
   }
 }
 
-export const ontologyID = ontology.createIDFactory<Key>("device");
-export const TYPE_ONTOLOGY_ID = ontologyID("");
-
 export const statusKey = (key: Key): string => ontology.idToString(ontologyID(key));

package/src/device/device.spec.ts

@@ -7,8 +7,9 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { id, TimeStamp, unique } from "@synnaxlabs/x";
+import { id, record, TimeStamp, unique } from "@synnaxlabs/x";
 import { beforeAll, describe, expect, it } from "vitest";
+import { z } from "zod";
 
 import { type device } from "@/device";
 import { createTestClient } from "@/testutil/client";
@@ -361,5 +362,98 @@ describe("Device", async () => {
           .toBe(true);
       });
     });
+
+    describe("with schemas", () => {
+      const schemas = {
+        properties: z.object({
+          rate: z.number(),
+          channels: z.array(z.string()),
+        }),
+        make: z.string(),
+        model: z.string(),
+      };
+
+      it("should create and retrieve with typed properties", async () => {
+        const d = await client.devices.create(
+          {
+            key: id.create(),
+            rack: testRack.key,
+            location: "Dev1",
+            name: "typed-device",
+            make: "ni",
+            model: "pxi-6281",
+            properties: { rate: 1000, channels: ["ai0", "ai1"] },
+          },
+          schemas,
+        );
+        expect(d.properties.rate).toBe(1000);
+        expect(d.properties.channels).toEqual(["ai0", "ai1"]);
+
+        const retrieved = await client.devices.retrieve({
+          key: d.key,
+          schemas,
+        });
+        expect(retrieved.properties.rate).toBe(1000);
+        expect(retrieved.properties.channels).toEqual(["ai0", "ai1"]);
+      });
+
+      it("should create and retrieve with typed make and model", async () => {
+        const makeModelSchemas = {
+          properties: record.unknownZ(),
+          make: z.literal("labjack"),
+          model: z.enum(["t7", "t4", "t8"]),
+        };
+
+        const d = await client.devices.create(
+          {
+            key: id.create(),
+            rack: testRack.key,
+            location: "Dev1",
+            name: "typed-make-model",
+            make: "labjack",
+            model: "t7",
+            properties: {},
+          },
+          makeModelSchemas,
+        );
+        expect(d.make).toBe("labjack");
+        expect(d.model).toBe("t7");
+      });
+
+      it("should retrieve multiple devices with schemas", async () => {
+        const d1 = await client.devices.create(
+          {
+            key: id.create(),
+            rack: testRack.key,
+            location: "Dev1",
+            name: "schema-multi-1",
+            make: "ni",
+            model: "pxi",
+            properties: { rate: 100, channels: ["ch1"] },
+          },
+          schemas,
+        );
+        const d2 = await client.devices.create(
+          {
+            key: id.create(),
+            rack: testRack.key,
+            location: "Dev2",
+            name: "schema-multi-2",
+            make: "ni",
+            model: "pxi",
+            properties: { rate: 200, channels: ["ch2", "ch3"] },
+          },
+          schemas,
+        );
+
+        const retrieved = await client.devices.retrieve({
+          keys: [d1.key, d2.key],
+          schemas,
+        });
+        expect(retrieved).toHaveLength(2);
+        expect(retrieved[0].properties.rate).toBe(100);
+        expect(retrieved[1].properties.rate).toBe(200);
+      });
+    });
   });
 });

package/src/device/external.ts

@@ -8,4 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/device/client";
-export * from "@/device/payload";
+export * from "@/device/types.gen";

package/src/device/payload.spec.ts

@@ -10,7 +10,7 @@
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
 
-import { deviceZ, newZ } from "@/device/payload";
+import { deviceZ, newZ } from "@/device/types.gen";
 
 const VALID_DEVICE = {
   key: "dev-1",
@@ -20,7 +20,7 @@ const VALID_DEVICE = {
   model: "pxi-6281",
   location: "Lab1",
   properties: { rate: 10 },
-  status: null,
+  status: undefined,
 };
 
 describe("deviceZ", () => {
@@ -108,6 +108,30 @@ describe("newZ", () => {
     expect(result.properties).toEqual(VALID_DEVICE.properties);
   });
 
+  it("should accept a device with an optional parent ontology ID", () => {
+    const result = newZ().safeParse({
+      ...VALID_DEVICE,
+      parent: { type: "rack", key: "rack-1" },
+    });
+    expect(result.success).toBe(true);
+    if (result.success)
+      expect(result.data.parent).toEqual({ type: "rack", key: "rack-1" });
+  });
+
+  it("should accept a device without a parent", () => {
+    const result = newZ().safeParse(VALID_DEVICE);
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.data.parent).toBeUndefined();
+  });
+
+  it("should reject a device with an invalid parent type", () => {
+    const result = newZ().safeParse({
+      ...VALID_DEVICE,
+      parent: { type: "invalid_type", key: "key-1" },
+    });
+    expect(result.success).toBe(false);
+  });
+
   it("should still validate make and model with custom schemas", () => {
     const makeZ = z.literal("ni");
     const result = newZ({ make: makeZ }).safeParse(VALID_DEVICE);

package/src/device/types.gen.ts

@@ -0,0 +1,100 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { type optional, record, status } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+import { rack } from "@/rack";
+
+/** StatusDetails contains device-specific status details identifying the device and its associated rack. */
+export const statusDetailsZ = z.object({
+  /** rack is the key of the rack this device belongs to. */
+  rack: rack.keyZ,
+  /** device is the device identifier. */
+  device: z.string(),
+});
+export interface StatusDetails extends z.infer<typeof statusDetailsZ> {}
+
+export const keyZ = z.string();
+export type Key = z.infer<typeof keyZ>;
+
+export const statusZ = status.statusZ({ details: statusDetailsZ });
+export type Status = z.infer<typeof statusZ>;
+
+export interface DeviceSchemas<
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  Make extends z.ZodType<string> = z.ZodType<string>,
+  Model extends z.ZodType<string> = z.ZodType<string>,
+> {
+  properties: Properties;
+  make: Make;
+  model: Model;
+}
+
+export const deviceZ = <
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+>({ properties, make, model }: Partial<DeviceSchemas<Properties, Make, Model>> = {}) =>
+  z.object({
+    key: keyZ,
+    rack: rack.keyZ,
+    location: z.string().min(1, "Location is required"),
+    make: make ?? z.string().min(1, "Make is required"),
+    model: model ?? z.string().min(1, "Model is required"),
+    name: z.string().min(1, "Name is required"),
+    configured: z.boolean().default(false),
+    properties: properties ?? record.nullishToEmpty(),
+    status: statusZ.optional(),
+    parent: ontology.idZ.optional(),
+  });
+export interface Device<
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+> {
+  key: Key;
+  rack: rack.Key;
+  location: string;
+  make: z.infer<Make>;
+  model: z.infer<Model>;
+  name: string;
+  configured: boolean;
+  properties: z.infer<Properties>;
+  status?: Status;
+  parent?: ontology.ID;
+}
+
+export interface NewSchemas<
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  Make extends z.ZodType<string> = z.ZodType<string>,
+  Model extends z.ZodType<string> = z.ZodType<string>,
+> {
+  properties: Properties;
+  make: Make;
+  model: Model;
+}
+
+export const newZ = <
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+>({ properties, make, model }: Partial<NewSchemas<Properties, Make, Model>> = {}) =>
+  deviceZ({ properties, make, model }).partial({ key: true, configured: true });
+export type New<
+  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
+  Make extends z.ZodType<string> = z.ZodString,
+  Model extends z.ZodType<string> = z.ZodString,
+> = optional.Optional<Device<Properties, Make, Model>, "key" | "configured">;
+
+export const ontologyID = ontology.createIDFactory<Key>("device");
+export const TYPE_ONTOLOGY_ID = ontologyID("");