@synnaxlabs/client 0.38.1 → 0.40.0

package/dist/workspace/table/payload.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const keyZ: z.ZodString;
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+export declare const tableZ: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    data: z.ZodUnion<[z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>, z.ZodEffects<z.ZodString, import('@synnaxlabs/x').UnknownRecord, string>]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    data: import('@synnaxlabs/x').UnknownRecord | Record<string | number | symbol, unknown>;
+}, {
+    name: string;
+    key: string;
+    data: string | Record<string | number | symbol, unknown>;
+}>;
+export interface Table extends z.infer<typeof tableZ> {
+}
+export declare const newZ: z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    data: z.ZodUnion<[z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>, z.ZodEffects<z.ZodString, import('@synnaxlabs/x').UnknownRecord, string>]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    data: import('@synnaxlabs/x').UnknownRecord | Record<string | number | symbol, unknown>;
+    key?: string | undefined;
+}, {
+    name: string;
+    data: string | Record<string | number | symbol, unknown>;
+    key?: string | undefined;
+}>, {
+    data: string;
+    name: string;
+    key?: string | undefined;
+}, {
+    name: string;
+    data: string | Record<string | number | symbol, unknown>;
+    key?: string | undefined;
+}>;
+export interface New extends z.input<typeof newZ> {
+}
+export declare const remoteZ: z.ZodObject<z.objectUtil.extendShape<{
+    key: z.ZodString;
+    name: z.ZodString;
+    data: z.ZodUnion<[z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>, z.ZodEffects<z.ZodString, import('@synnaxlabs/x').UnknownRecord, string>]>;
+}, {
+    data: z.ZodEffects<z.ZodString, import('@synnaxlabs/x').UnknownRecord, string>;
+}>, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    data: import('@synnaxlabs/x').UnknownRecord;
+}, {
+    name: string;
+    key: string;
+    data: string;
+}>;
+export declare const ONTOLOGY_TYPE = "table";
+export type OntologyType = typeof ONTOLOGY_TYPE;
+//# sourceMappingURL=payload.d.ts.map

package/dist/workspace/table/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/workspace/table/payload.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,IAAI,aAAoB,CAAC;AACtC,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AACvC,MAAM,MAAM,MAAM,GAAG,GAAG,GAAG,GAAG,EAAE,CAAC;AAEjC,eAAO,MAAM,MAAM;;;;;;;;;;;;EAIjB,CAAC;AACH,MAAM,WAAW,KAAM,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC;CAAG;AAExD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;EAE4C,CAAC;AAC9D,MAAM,WAAW,GAAI,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC;CAAG;AAEpD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;EAElB,CAAC;AAEH,eAAO,MAAM,aAAa,UAAU,CAAC;AACrC,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC"}

package/examples/node/basicReadWrite.js

@@ -16,34 +16,34 @@ import { DataType, Synnax, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/cl
 // Connect to a locally running, insecure Synnax cluster. If your connection parameters
 // are different, enter them here.
 const client = new Synnax({
-    host: "localhost",
-    port: 9090,
-    username: "synnax",
-    password: "seldon",
-    secure: false,
+  host: "localhost",
+  port: 9090,
+  username: "synnax",
+  password: "seldon",
+  secure: false,
 });
 
 // Create an index channel that will be used to store our timestamps.
 const timeChannel = await client.channels.create(
-    {
-        name: "basic_read_write_time",
-        isIndex: true,
-        dataType: DataType.TIMESTAMP,
-    },
-    { retrieveIfNameExists: true },
+  {
+    name: "basic_read_write_time",
+    isIndex: true,
+    dataType: DataType.TIMESTAMP,
+  },
+  { retrieveIfNameExists: true },
 );
 
 // Create a channel that will be used to store our data.
 const dataChannel = await client.channels.create(
-    {
-        name: "basic_read_write_data",
-        isIndex: false,
-        dataType: DataType.FLOAT32,
-        // We need to specify the index channel that we want to use to store the timestamps
-        // for this data channel.
-        index: timeChannel.key,
-    },
-    { retrieveIfNameExists: true },
+  {
+    name: "basic_read_write_data",
+    isIndex: false,
+    dataType: DataType.FLOAT32,
+    // We need to specify the index channel that we want to use to store the timestamps
+    // for this data channel.
+    index: timeChannel.key,
+  },
+  { retrieveIfNameExists: true },
 );
 
 const N_SAMPLES = 5000;
@@ -54,7 +54,7 @@ const start = TimeStamp.now();
 
 // Generate a new timestamp every millisecond for N_SAMPLES.
 const time = BigInt64Array.from({ length: N_SAMPLES }, (_, i) =>
-    start.add(TimeSpan.milliseconds(i)).valueOf(),
+  start.add(TimeSpan.milliseconds(i)).valueOf(),
 );
 
 // Generate a sine wave for N_SAMPLES.
@@ -75,11 +75,11 @@ const readData = await dataChannel.read(tr);
 
 // Print out some information.
 console.log({
-    firstTimestamp: readTime.at(0),
-    firstData: readData.at(0),
-    lastTimestamp: readTime.at(N_SAMPLES - 1),
-    lastData: readData.at(N_SAMPLES - 1),
-    returnLength: readData.length,
+  firstTimestamp: readTime.at(0),
+  firstData: readData.at(0),
+  lastTimestamp: readTime.at(N_SAMPLES - 1),
+  lastData: readData.at(N_SAMPLES - 1),
+  returnLength: readData.length,
 });
 
 // Make sure to close the client when you're done.

package/examples/node/liveStream.js

@@ -19,18 +19,18 @@ import { Synnax } from "@synnaxlabs/client";
 // Connect to a locally running, insecure Synnax cluster. If your connection parameters
 // are different, enter them here.
 const client = new Synnax({
-    host: "localhost",
-    port: 9090,
-    username: "synnax",
-    password: "seldon",
-    secure: false,
+  host: "localhost",
+  port: 9090,
+  username: "synnax",
+  password: "seldon",
+  secure: false,
 });
 
 // We can just specify the names of the channels we'd like to stream from.
 const read_from = [
-    "stream_write_example_time",
-    "stream_write_example_data_1",
-    "stream_write_example_data_2",
+  "stream_write_example_time",
+  "stream_write_example_data_1",
+  "stream_write_example_data_2",
 ];
 
 const streamer = await client.openStreamer(read_from);
@@ -39,12 +39,12 @@ const streamer = await client.openStreamer(read_from);
 // network connections and other resources, so we wrap the streaming loop in a
 // try-finally block.
 try {
-    // Loop through the frames in the streamer. Each iteration will block until a new
-    // frame is available, and then we'll just print out the last sample for each
-    // channel in the frame.
-    for await (const frame of streamer) console.log(frame.at(-1));
+  // Loop through the frames in the streamer. Each iteration will block until a new
+  // frame is available, and then we'll just print out the last sample for each
+  // channel in the frame.
+  for await (const frame of streamer) console.log(frame.at(-1));
 } finally {
-    streamer.close();
-    // Close the client when we're done with it.
-    client.close();
+  streamer.close();
+  // Close the client when we're done with it.
+  client.close();
 }

package/examples/node/seriesAndFrames.js

@@ -67,9 +67,9 @@ const start = TimeStamp.now();
 const tr = new TimeRange(start, start.add(TimeSpan.seconds(5)));
 
 series = new Series({
-    data: [1, 2, 3, 4, 5],
-    dataType: "float64",
-    timeRange: tr,
+  data: [1, 2, 3, 4, 5],
+  dataType: "float64",
+  timeRange: tr,
 });
 
 series = new Series([1, 2, 3, 4, 5]);
@@ -93,52 +93,52 @@ import { Frame } from "@synnaxlabs/client";
 
 // Construct a frame for the given channel names.
 let frame = new Frame({
-    channel1: new Series([1, 2, 3, 4, 5]),
-    channel2: new Series([5, 4, 3, 2, 1]),
-    channel3: new Series([1, 1, 1, 1, 1]),
+  channel1: new Series([1, 2, 3, 4, 5]),
+  channel2: new Series([5, 4, 3, 2, 1]),
+  channel3: new Series([1, 1, 1, 1, 1]),
 });
 
 // Construct a frame for the given channel keys
 frame = new Frame({
-    1: new Series([1, 2, 3, 4, 5]),
-    2: new Series([5, 4, 3, 2, 1]),
-    // Notice that series do not need to be the same length.
-    3: new Series([1, 1, 1]),
+  1: new Series([1, 2, 3, 4, 5]),
+  2: new Series([5, 4, 3, 2, 1]),
+  // Notice that series do not need to be the same length.
+  3: new Series([1, 1, 1]),
 });
 
 // Construct a frame from a map
 frame = new Frame(
-    new Map([
-        ["channel1", new Series([1, 2, 3, 4, 5])],
-        ["channel2", new Series([5, 4, 3, 2, 1])],
-        ["channel3", new Series([1, 1, 1, 1, 1])],
-    ]),
+  new Map([
+    ["channel1", new Series([1, 2, 3, 4, 5])],
+    ["channel2", new Series([5, 4, 3, 2, 1])],
+    ["channel3", new Series([1, 1, 1, 1, 1])],
+  ]),
 );
 
 // Or from an array of keys and series
 frame = new Frame(
-    ["channel1", "channel2", "channel3"],
-    [
-        new Series([1, 2, 3, 4, 5]),
-        new Series([5, 4, 3, 2, 1]),
-        new Series([1, 1, 1, 1, 1]),
-    ],
+  ["channel1", "channel2", "channel3"],
+  [
+    new Series([1, 2, 3, 4, 5]),
+    new Series([5, 4, 3, 2, 1]),
+    new Series([1, 1, 1, 1, 1]),
+  ],
 );
 
 // Or construct a frame with multiple series for a single channel
 frame = new Frame({
-    channel1: [
-        new Series([1, 2, 3, 4, 5]),
-        new Series([5, 4, 3, 2, 1]),
-        new Series([1, 1, 1, 1, 1]),
-    ],
-    channel2: [new Series([1, 2, 3, 4, 5])],
+  channel1: [
+    new Series([1, 2, 3, 4, 5]),
+    new Series([5, 4, 3, 2, 1]),
+    new Series([1, 1, 1, 1, 1]),
+  ],
+  channel2: [new Series([1, 2, 3, 4, 5])],
 });
 
 frame = new Frame({
-    channel1: [new Series([1, 2]), new Series([3, 4, 5])],
-    channel2: new Series([5, 4, 3, 2, 1]),
-    channel3: new Series([1, 1, 1, 1, 1]),
+  channel1: [new Series([1, 2]), new Series([3, 4, 5])],
+  channel2: new Series([5, 4, 3, 2, 1]),
+  channel3: new Series([1, 1, 1, 1, 1]),
 });
 
 const multiSeries = frame.get("channel1");
@@ -153,21 +153,21 @@ jsArray = [...multiSeries];
 console.log(jsArray); // [ 1, 2, 3, 4, 5 ]
 
 frame = new Frame({
-    channel1: new Series([1, 2, 3, 4, 5]),
-    channel2: new Series([5, 4, 3, 2, 1]),
-    channel3: new Series([1, 1]),
+  channel1: new Series([1, 2, 3, 4, 5]),
+  channel2: new Series([5, 4, 3, 2, 1]),
+  channel3: new Series([1, 1]),
 });
 
 let obj = frame.at(3);
 console.log(obj); // { channel1: 1, channel2: 5, channel3: undefined }
 
 frame = new Frame({
-    channel1: new Series([1, 2, 3, 4, 5]),
-    channel2: new Series([5, 4, 3, 2, 1]),
-    channel3: new Series([1, 1]),
+  channel1: new Series([1, 2, 3, 4, 5]),
+  channel2: new Series([5, 4, 3, 2, 1]),
+  channel3: new Series([1, 1]),
 });
 try {
-    obj = frame.at(3, true); // Throws an error
+  obj = frame.at(3, true); // Throws an error
 } catch (e) {
-    console.log(e.message); // no value at index
+  console.log(e.message); // no value at index
 }

package/examples/node/streamWrite.js

@@ -17,39 +17,39 @@ import { Rate, Synnax, TimeStamp } from "@synnaxlabs/client";
 // Connect to a locally running, insecure Synnax cluster. If your connection parameters
 // are different, enter them here.
 const client = new Synnax({
-    host: "localhost",
-    port: 9090,
-    username: "synnax",
-    password: "seldon",
+  host: "localhost",
+  port: 9090,
+  username: "synnax",
+  password: "seldon",
 });
 
 // Create an index channel that will be used to store our timestamps.
 const timeChannel = await client.channels.create(
-    {
-        name: "stream_write_example_time",
-        isIndex: true,
-        dataType: "timestamp",
-    },
-    { retrieveIfNameExists: true },
+  {
+    name: "stream_write_example_time",
+    isIndex: true,
+    dataType: "timestamp",
+  },
+  { retrieveIfNameExists: true },
 );
 
 // Create a data channel that will be used to store our fake sensor data.
 const dataChannel1 = await client.channels.create(
-    {
-        name: "stream_write_example_data_1",
-        dataType: "float32",
-        index: timeChannel.key,
-    },
-    { retrieveIfNameExists: true },
+  {
+    name: "stream_write_example_data_1",
+    dataType: "float32",
+    index: timeChannel.key,
+  },
+  { retrieveIfNameExists: true },
 );
 
 const dataChannel2 = await client.channels.create(
-    {
-        name: "stream_write_example_data_2",
-        dataType: "int32",
-        index: timeChannel.key,
-    },
-    { retrieveIfNameExists: true },
+  {
+    name: "stream_write_example_data_2",
+    dataType: "int32",
+    index: timeChannel.key,
+  },
+  { retrieveIfNameExists: true },
 );
 
 // We'll start our write at the current time. This timestamps should be the same as or
@@ -61,32 +61,34 @@ const start = TimeStamp.now();
 const roughRate = Rate.hz(25);
 
 const writer = await client.openWriter({
-    start,
-    channels: [timeChannel.key, dataChannel1.key, dataChannel2.key],
-    enableAutoCommit: true,
+  start,
+  channels: [timeChannel.key, dataChannel1.key, dataChannel2.key],
+  enableAutoCommit: true,
 });
 
 try {
-    let i = 0;
-    while (true) {
-        await new Promise((resolve) =>
-            setTimeout(resolve, roughRate.period.milliseconds),
-        );
-        i++;
-        const timestamp = TimeStamp.now();
-        const data1 = Math.sin(i / 10);
-        const data2 = i % 2;
-        await writer.write({
-            [timeChannel.key]: timestamp,
-            [dataChannel1.key]: data1,
-            [dataChannel2.key]: data2,
-        });
-
-        if (i % 60 == 0)
-            console.log(`Writing sample ${i} at ${timestamp.toISOString()}`);
+  let i = 0;
+  while (true) {
+    await new Promise((resolve) => setTimeout(resolve, roughRate.period.milliseconds));
+    i++;
+    const timestamp = TimeStamp.now();
+    const data1 = Math.sin(i / 10);
+    const data2 = i % 2;
+    if (
+      !(await writer.write({
+        [timeChannel.key]: timestamp,
+        [dataChannel1.key]: data1,
+        [dataChannel2.key]: data2,
+      }))
+    ) {
+      console.error("Failed to write");
+      break;
     }
+
+    if (i % 60 == 0) console.log(`Writing sample ${i} at ${timestamp.toISOString()}`);
+  }
 } finally {
-    // Close the writer and the client when you are done
-    await writer.close();
-    client.close();
+  // Close the writer and the client when you are done
+  await writer.close();
+  client.close();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/client",
-  "version": "0.38.1",
+  "version": "0.40.0",
   "description": "The Synnax Client Library",
   "keywords": [
     "synnax",
@@ -25,21 +25,22 @@
   },
   "dependencies": {
     "async-mutex": "^0.5.0",
-    "uuid": "^11.0.5",
-    "zod": "^3.24.1",
-    "@synnaxlabs/freighter": "0.38.1",
-    "@synnaxlabs/x": "0.38.1"
+    "uuid": "^11.1.0",
+    "zod": "^3.24.2",
+    "@synnaxlabs/freighter": "0.40.0",
+    "@synnaxlabs/x": "0.40.0"
   },
   "devDependencies": {
-    "@types/node": "^22.10.6",
+    "@types/node": "^22.13.10",
     "@types/uuid": "^10.0.0",
-    "eslint": "^9.18.0",
-    "typescript": "^5.7.3",
-    "vite": "^6.0.7",
-    "vitest": "^2.1.8",
+    "eslint": "^9.22.0",
+    "madge": "^8.0.0",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.1",
+    "vitest": "^2.1.9",
+    "@synnaxlabs/tsconfig": "0.0.2",
     "@synnaxlabs/vite-plugin": "0.0.1",
-    "eslint-config-synnaxlabs": "0.0.1",
-    "@synnaxlabs/tsconfig": "0.0.2"
+    "eslint-config-synnaxlabs": "0.0.1"
   },
   "type": "module",
   "types": "dist/index.d.ts",
@@ -49,6 +50,7 @@
     "watch": "tsc --noEmit && vite build --watch",
     "test": "vitest",
     "lint": "eslint --cache",
-    "fix": "eslint --cache --fix"
+    "fix": "eslint --cache --fix",
+    "madge": "madge --circular src"
   }
 }

package/src/access/payload.ts

@@ -9,17 +9,17 @@
 
 import { z } from "zod";
 
-export const actionZ = z.union([
-  z.literal("all"),
-  z.literal("create"),
-  z.literal("delete"),
-  z.literal("retrieve"),
-  z.literal("update"),
+export const ALL_ACTION = "all";
+export const CREATE_ACTION = "create";
+export const DELETE_ACTION = "delete";
+export const RETRIEVE_ACTION = "retrieve";
+export const UPDATE_ACTION = "update";
+
+export const actionZ = z.enum([
+  ALL_ACTION,
+  CREATE_ACTION,
+  DELETE_ACTION,
+  RETRIEVE_ACTION,
+  UPDATE_ACTION,
 ]);
 export type Action = z.infer<typeof actionZ>;
-
-export const ALL_ACTION: Action = "all";
-export const CREATE_ACTION: Action = "create";
-export const DELETE_ACTION: Action = "delete";
-export const RETRIEVE_ACTION: Action = "retrieve";
-export const UPDATE_ACTION: Action = "update";

package/src/access/policy/client.ts

@@ -10,7 +10,8 @@
 import { type UnaryClient } from "@synnaxlabs/freighter";
 import { toArray } from "@synnaxlabs/x/toArray";
 
-import { type Key, type NewPolicy, type Policy } from "@/access/policy/payload";
+import { ALLOW_ALL_ONTOLOGY_TYPE, ONTOLOGY_TYPE } from "@/access/policy/ontology";
+import { type Key, type New, type Policy } from "@/access/policy/payload";
 import { Retriever } from "@/access/policy/retriever";
 import { Writer } from "@/access/policy/writer";
 import { ontology } from "@/ontology";
@@ -24,20 +25,16 @@ export class Client {
     this.writer = new Writer(client);
   }
 
-  async create(policy: NewPolicy): Promise<Policy>;
-
-  async create(policies: NewPolicy[]): Promise<Policy[]>;
-
-  async create(policies: NewPolicy | NewPolicy[]): Promise<Policy | Policy[]> {
+  async create(policy: New): Promise<Policy>;
+  async create(policies: New[]): Promise<Policy[]>;
+  async create(policies: New | New[]): Promise<Policy | Policy[]> {
     const isMany = Array.isArray(policies);
     const createdPolicies = await this.writer.create(policies);
     return isMany ? createdPolicies : createdPolicies[0];
   }
 
   async retrieve(key: Key): Promise<Policy>;
-
   async retrieve(keys: Key[]): Promise<Policy[]>;
-
   async retrieve(keys: Key | Key[]): Promise<Policy | Policy[]> {
     const isMany = Array.isArray(keys);
     const res = await this.retriever.retrieve({ keys: toArray(keys) });
@@ -45,9 +42,7 @@ export class Client {
   }
 
   async retrieveFor(subject: ontology.CrudeID): Promise<Policy[]>;
-
   async retrieveFor(subjects: ontology.CrudeID[]): Promise<Policy[]>;
-
   async retrieveFor(
     subjects: ontology.CrudeID | ontology.CrudeID[],
   ): Promise<Policy[]> {
@@ -56,10 +51,16 @@ export class Client {
   }
 
   async delete(key: Key): Promise<void>;
-
   async delete(keys: Key[]): Promise<void>;
-
   async delete(keys: Key | Key[]): Promise<void> {
     await this.writer.delete(keys);
   }
 }
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+
+export const ALLOW_ALL_ONTOLOGY_ID = new ontology.ID({
+  type: ALLOW_ALL_ONTOLOGY_TYPE,
+  key: "",
+});

package/src/access/policy/external.ts

@@ -8,4 +8,5 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/access/policy/client";
+export * from "@/access/policy/ontology";
 export * from "@/access/policy/payload";

package/src/access/policy/ontology.ts

@@ -0,0 +1,17 @@
+// Copyright 2025 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.
+
+// This needs to be a separate file because these types are imported by the ontology
+// module, but the policy module need to import the ID schema from the ontology module.
+
+export const ONTOLOGY_TYPE = "policy";
+export type OntologyType = typeof ONTOLOGY_TYPE;
+
+export const ALLOW_ALL_ONTOLOGY_TYPE = "allow_all";
+export type AllowAllOntologyType = typeof ALLOW_ALL_ONTOLOGY_TYPE;

package/src/access/policy/payload.ts

@@ -16,30 +16,18 @@ import { nullableArrayZ } from "@/util/zod";
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 
-export const newPolicyZ = z.object({
-  key: keyZ.optional(),
-  subjects: ontology.crudeIDZ.array().or(ontology.crudeIDZ),
-  objects: ontology.crudeIDZ.array().or(ontology.crudeIDZ),
-  actions: actionZ.array().or(actionZ),
-});
-export type NewPolicy = z.input<typeof newPolicyZ>;
-
 export const policyZ = z.object({
   key: keyZ,
   subjects: nullableArrayZ(ontology.idZ),
   objects: nullableArrayZ(ontology.idZ),
   actions: nullableArrayZ(actionZ),
 });
-export type Policy = z.infer<typeof policyZ>;
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "policy";
+export interface Policy extends z.infer<typeof policyZ> {}
 
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
-
-export const ALLOW_ALL_ONTOLOGY_TYPE: ontology.ResourceType = "allow_all";
-
-export const ALLOW_ALL_ONTOLOGY_ID = new ontology.ID({
-  type: ALLOW_ALL_ONTOLOGY_TYPE,
-  key: "",
+export const newZ = z.object({
+  key: keyZ.optional(),
+  subjects: ontology.crudeIDZ.array().or(ontology.crudeIDZ),
+  objects: ontology.crudeIDZ.array().or(ontology.crudeIDZ),
+  actions: actionZ.array().or(actionZ),
 });
+export interface New extends z.input<typeof newZ> {}