@synnaxlabs/client 0.56.2 → 0.57.1

package/dist/src/framer/writer.d.ts

@@ -2,13 +2,16 @@ import { WebSocketClient } from '@synnaxlabs/freighter';
 import { control, CrudeSeries, errors, TimeSpan, TimeStamp } from '@synnaxlabs/x';
 import { z } from 'zod';
 import { channel } from '../channel';
+import { ChannelRetriever } from './adapter';
 import { CrudeFrame } from './frame';
 import { WriterCommand } from './types.gen';
+/** Whether a writer persists its samples, streams them to subscribers, or both. */
 export declare enum WriterMode {
     PersistStream = 1,
     Persist = 2,
     Stream = 3
 }
+/** `autoIndexPersistInterval` that flushes the index on every auto commit. */
 export declare const ALWAYS_INDEX_PERSIST_ON_AUTO_COMMIT: TimeSpan;
 declare const WriterClosedError_base: errors.TypedClass;
 export declare class WriterClosedError extends WriterClosedError_base {
@@ -19,6 +22,7 @@ declare const writerModeZ: z.ZodUnion<[z.ZodEnum<typeof WriterMode>, z.ZodPipe<z
     stream: "stream";
     persistStream: "persistStream";
 }>, z.ZodTransform<WriterMode, "persist" | "stream" | "persistStream">>]>;
+/** A {@link WriterMode}, or its name as a string. */
 export type CrudeWriterMode = z.input<typeof writerModeZ>;
 declare const netWriterConfigZ: z.ZodObject<{
     start: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<TimeStamp, TimeStamp>, z.ZodPipe<z.ZodObject<{
@@ -29,7 +33,7 @@ declare const netWriterConfigZ: z.ZodObject<{
     controlSubject: z.ZodOptional<z.ZodObject<{
         key: z.ZodString;
         name: z.ZodString;
-        group: z.ZodOptional<z.ZodUInt32>;
+        group: z.ZodDefault<z.ZodUInt32>;
     }, z.core.$strip>>;
     authorities: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodInt, z.ZodTransform<number[], number>>, z.ZodArray<z.ZodInt>]>>;
     mode: z.ZodDefault<z.ZodUnion<[z.ZodEnum<typeof WriterMode>, z.ZodPipe<z.ZodEnum<{
@@ -48,6 +52,7 @@ declare const netWriterConfigZ: z.ZodObject<{
     keys: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>>;
 }, z.core.$strip>;
 export type NetWriterConfig = z.input<typeof netWriterConfigZ>;
+/** Zod schema for {@link WriterConfig}. A bare channel list parses as a config. */
 export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
     start: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<TimeStamp, TimeStamp>, z.ZodPipe<z.ZodObject<{
         value: z.ZodBigInt;
@@ -57,7 +62,7 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
     controlSubject: z.ZodOptional<z.ZodObject<{
         key: z.ZodString;
         name: z.ZodString;
-        group: z.ZodOptional<z.ZodUInt32>;
+        group: z.ZodDefault<z.ZodUInt32>;
     }, z.core.$strip>>;
     authorities: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodInt, z.ZodTransform<number[], number>>, z.ZodArray<z.ZodInt>]>>;
     mode: z.ZodDefault<z.ZodUnion<[z.ZodEnum<typeof WriterMode>, z.ZodPipe<z.ZodEnum<{
@@ -74,22 +79,26 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
     }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeSpan, bigint>>, z.ZodCustom<TimeSpan, TimeSpan>, z.ZodPipe<z.ZodCustom<TimeStamp, TimeStamp>, z.ZodTransform<TimeSpan, TimeStamp>>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').Rate, import('@synnaxlabs/x').Rate>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').Rate>>]>>;
     autoIndex: z.ZodDefault<z.ZodBoolean>;
     channels: z.ZodUnion<readonly [z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>, z.ZodPipe<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodTransform<number[], number>>]>, z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>, z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodObject<{
-        key: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+        key: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
         name: z.ZodString;
-        leaseholder: z.ZodInt;
-        dataType: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>]>;
-        isIndex: z.ZodBoolean;
-        index: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+        leaseholder: z.ZodDefault<z.ZodInt>;
+        dataType: z.ZodUnion<readonly [z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodPipe<z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').DataType, {
+            value: string;
+        }>>]>;
+        isIndex: z.ZodDefault<z.ZodBoolean>;
+        index: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
         alias: z.ZodOptional<z.ZodString>;
         virtual: z.ZodDefault<z.ZodBoolean>;
         internal: z.ZodDefault<z.ZodBoolean>;
         expression: z.ZodDefault<z.ZodString>;
-        operations: z.ZodOptional<z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
-                none: "none";
                 min: "min";
                 max: "max";
                 avg: "avg";
+                none: "none";
                 derivative: "derivative";
             }>;
             resetChannel: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
@@ -98,41 +107,37 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
             }, z.core.$strip>, z.ZodTransform<TimeSpan, {
                 value: bigint;
             }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeSpan, bigint>>, z.ZodCustom<TimeSpan, TimeSpan>, z.ZodPipe<z.ZodCustom<TimeStamp, TimeStamp>, z.ZodTransform<TimeSpan, TimeStamp>>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').Rate, import('@synnaxlabs/x').Rate>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').Rate>>]>>;
-        }, z.core.$strip>>>, z.ZodTransform<{
-            type: "none" | "min" | "max" | "avg" | "derivative";
-            resetChannel: number;
-            duration: TimeSpan;
-        }[] | undefined, {
-            type: "none" | "min" | "max" | "avg" | "derivative";
-            resetChannel: number;
-            duration: TimeSpan;
-        }[] | null>>>;
-        concurrency: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>>;
-        status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-            success: "success";
+        }, z.core.$strip>>>;
+        concurrency: z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>;
+        status: z.ZodOptional<import('..').StatusZodObject<z.ZodNever, z.ZodEnum<{
             error: "error";
+            success: "success";
             info: "info";
             warning: "warning";
             loading: "loading";
             disabled: "disabled";
         }>>>;
     }, z.core.$strip>>, z.ZodPipe<z.ZodObject<{
-        key: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+        key: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
         name: z.ZodString;
-        leaseholder: z.ZodInt;
-        dataType: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>]>;
-        isIndex: z.ZodBoolean;
-        index: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+        leaseholder: z.ZodDefault<z.ZodInt>;
+        dataType: z.ZodUnion<readonly [z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodPipe<z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').DataType, {
+            value: string;
+        }>>]>;
+        isIndex: z.ZodDefault<z.ZodBoolean>;
+        index: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
         alias: z.ZodOptional<z.ZodString>;
         virtual: z.ZodDefault<z.ZodBoolean>;
         internal: z.ZodDefault<z.ZodBoolean>;
         expression: z.ZodDefault<z.ZodString>;
-        operations: z.ZodOptional<z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
-                none: "none";
                 min: "min";
                 max: "max";
                 avg: "avg";
+                none: "none";
                 derivative: "derivative";
             }>;
             resetChannel: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
@@ -141,19 +146,11 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
             }, z.core.$strip>, z.ZodTransform<TimeSpan, {
                 value: bigint;
             }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeSpan, bigint>>, z.ZodCustom<TimeSpan, TimeSpan>, z.ZodPipe<z.ZodCustom<TimeStamp, TimeStamp>, z.ZodTransform<TimeSpan, TimeStamp>>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').Rate, import('@synnaxlabs/x').Rate>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').Rate>>]>>;
-        }, z.core.$strip>>>, z.ZodTransform<{
-            type: "none" | "min" | "max" | "avg" | "derivative";
-            resetChannel: number;
-            duration: TimeSpan;
-        }[] | undefined, {
-            type: "none" | "min" | "max" | "avg" | "derivative";
-            resetChannel: number;
-            duration: TimeSpan;
-        }[] | null>>>;
-        concurrency: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>>;
-        status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-            success: "success";
+        }, z.core.$strip>>>;
+        concurrency: z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>;
+        status: z.ZodOptional<import('..').StatusZodObject<z.ZodNever, z.ZodEnum<{
             error: "error";
+            success: "success";
             info: "info";
             warning: "warning";
             loading: "loading";
@@ -169,20 +166,20 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
         virtual: boolean;
         internal: boolean;
         expression: string;
-        alias?: string | undefined;
-        operations?: {
-            type: "none" | "min" | "max" | "avg" | "derivative";
+        operations: {
+            type: "min" | "max" | "avg" | "none" | "derivative";
             resetChannel: number;
             duration: TimeSpan;
-        }[] | undefined;
-        concurrency?: control.Concurrency | undefined;
+        }[];
+        concurrency: control.Concurrency;
+        alias?: string | undefined;
         status?: {
             key: string;
             name: string;
             variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
             message: string;
+            description: string;
             time: TimeStamp;
-            description?: string | undefined;
             labels?: {
                 key: string;
                 name: string;
@@ -200,20 +197,20 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
         virtual: boolean;
         internal: boolean;
         expression: string;
-        alias?: string | undefined;
-        operations?: {
-            type: "none" | "min" | "max" | "avg" | "derivative";
+        operations: {
+            type: "min" | "max" | "avg" | "none" | "derivative";
             resetChannel: number;
             duration: TimeSpan;
-        }[] | undefined;
-        concurrency?: control.Concurrency | undefined;
+        }[];
+        concurrency: control.Concurrency;
+        alias?: string | undefined;
         status?: {
             key: string;
             name: string;
             variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
             message: string;
+            description: string;
             time: TimeStamp;
-            description?: string | undefined;
             labels?: {
                 key: string;
                 name: string;
@@ -231,20 +228,20 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
         virtual: boolean;
         internal: boolean;
         expression: string;
-        alias?: string | undefined;
-        operations?: {
-            type: "none" | "min" | "max" | "avg" | "derivative";
+        operations: {
+            type: "min" | "max" | "avg" | "none" | "derivative";
             resetChannel: number;
             duration: TimeSpan;
-        }[] | undefined;
-        concurrency?: control.Concurrency | undefined;
+        }[];
+        concurrency: control.Concurrency;
+        alias?: string | undefined;
         status?: {
             key: string;
             name: string;
             variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
             message: string;
+            description: string;
             time: TimeStamp;
-            description?: string | undefined;
             labels?: {
                 key: string;
                 name: string;
@@ -254,22 +251,26 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
         } | undefined;
     }[]>>]>;
 }, z.core.$strip>, z.ZodPipe<z.ZodUnion<readonly [z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>, z.ZodPipe<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodTransform<number[], number>>]>, z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>, z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodObject<{
-    key: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+    key: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
     name: z.ZodString;
-    leaseholder: z.ZodInt;
-    dataType: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>]>;
-    isIndex: z.ZodBoolean;
-    index: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+    leaseholder: z.ZodDefault<z.ZodInt>;
+    dataType: z.ZodUnion<readonly [z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodPipe<z.ZodObject<{
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').DataType, {
+        value: string;
+    }>>]>;
+    isIndex: z.ZodDefault<z.ZodBoolean>;
+    index: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
     alias: z.ZodOptional<z.ZodString>;
     virtual: z.ZodDefault<z.ZodBoolean>;
     internal: z.ZodDefault<z.ZodBoolean>;
     expression: z.ZodDefault<z.ZodString>;
-    operations: z.ZodOptional<z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodObject<{
+    operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
-            none: "none";
             min: "min";
             max: "max";
             avg: "avg";
+            none: "none";
             derivative: "derivative";
         }>;
         resetChannel: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
@@ -278,41 +279,37 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
         }, z.core.$strip>, z.ZodTransform<TimeSpan, {
             value: bigint;
         }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeSpan, bigint>>, z.ZodCustom<TimeSpan, TimeSpan>, z.ZodPipe<z.ZodCustom<TimeStamp, TimeStamp>, z.ZodTransform<TimeSpan, TimeStamp>>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').Rate, import('@synnaxlabs/x').Rate>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').Rate>>]>>;
-    }, z.core.$strip>>>, z.ZodTransform<{
-        type: "none" | "min" | "max" | "avg" | "derivative";
-        resetChannel: number;
-        duration: TimeSpan;
-    }[] | undefined, {
-        type: "none" | "min" | "max" | "avg" | "derivative";
-        resetChannel: number;
-        duration: TimeSpan;
-    }[] | null>>>;
-    concurrency: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>>;
-    status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-        success: "success";
+    }, z.core.$strip>>>;
+    concurrency: z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>;
+    status: z.ZodOptional<import('..').StatusZodObject<z.ZodNever, z.ZodEnum<{
         error: "error";
+        success: "success";
         info: "info";
         warning: "warning";
         loading: "loading";
         disabled: "disabled";
     }>>>;
 }, z.core.$strip>>, z.ZodPipe<z.ZodObject<{
-    key: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+    key: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
     name: z.ZodString;
-    leaseholder: z.ZodInt;
-    dataType: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>]>;
-    isIndex: z.ZodBoolean;
-    index: z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>;
+    leaseholder: z.ZodDefault<z.ZodInt>;
+    dataType: z.ZodUnion<readonly [z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodPipe<z.ZodObject<{
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').DataType, {
+        value: string;
+    }>>]>;
+    isIndex: z.ZodDefault<z.ZodBoolean>;
+    index: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
     alias: z.ZodOptional<z.ZodString>;
     virtual: z.ZodDefault<z.ZodBoolean>;
     internal: z.ZodDefault<z.ZodBoolean>;
     expression: z.ZodDefault<z.ZodString>;
-    operations: z.ZodOptional<z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodObject<{
+    operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
-            none: "none";
             min: "min";
             max: "max";
             avg: "avg";
+            none: "none";
             derivative: "derivative";
         }>;
         resetChannel: z.ZodDefault<z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
@@ -321,19 +318,11 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
         }, z.core.$strip>, z.ZodTransform<TimeSpan, {
             value: bigint;
         }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeSpan, bigint>>, z.ZodCustom<TimeSpan, TimeSpan>, z.ZodPipe<z.ZodCustom<TimeStamp, TimeStamp>, z.ZodTransform<TimeSpan, TimeStamp>>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').Rate, import('@synnaxlabs/x').Rate>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').Rate>>]>>;
-    }, z.core.$strip>>>, z.ZodTransform<{
-        type: "none" | "min" | "max" | "avg" | "derivative";
-        resetChannel: number;
-        duration: TimeSpan;
-    }[] | undefined, {
-        type: "none" | "min" | "max" | "avg" | "derivative";
-        resetChannel: number;
-        duration: TimeSpan;
-    }[] | null>>>;
-    concurrency: z.ZodOptional<z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>>;
-    status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-        success: "success";
+    }, z.core.$strip>>>;
+    concurrency: z.ZodDefault<z.ZodEnum<typeof control.Concurrency>>;
+    status: z.ZodOptional<import('..').StatusZodObject<z.ZodNever, z.ZodEnum<{
         error: "error";
+        success: "success";
         info: "info";
         warning: "warning";
         loading: "loading";
@@ -349,20 +338,20 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
     virtual: boolean;
     internal: boolean;
     expression: string;
-    alias?: string | undefined;
-    operations?: {
-        type: "none" | "min" | "max" | "avg" | "derivative";
+    operations: {
+        type: "min" | "max" | "avg" | "none" | "derivative";
         resetChannel: number;
         duration: TimeSpan;
-    }[] | undefined;
-    concurrency?: control.Concurrency | undefined;
+    }[];
+    concurrency: control.Concurrency;
+    alias?: string | undefined;
     status?: {
         key: string;
         name: string;
         variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
         message: string;
+        description: string;
         time: TimeStamp;
-        description?: string | undefined;
         labels?: {
             key: string;
             name: string;
@@ -380,20 +369,20 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
     virtual: boolean;
     internal: boolean;
     expression: string;
-    alias?: string | undefined;
-    operations?: {
-        type: "none" | "min" | "max" | "avg" | "derivative";
+    operations: {
+        type: "min" | "max" | "avg" | "none" | "derivative";
         resetChannel: number;
         duration: TimeSpan;
-    }[] | undefined;
-    concurrency?: control.Concurrency | undefined;
+    }[];
+    concurrency: control.Concurrency;
+    alias?: string | undefined;
     status?: {
         key: string;
         name: string;
         variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
         message: string;
+        description: string;
         time: TimeStamp;
-        description?: string | undefined;
         labels?: {
             key: string;
             name: string;
@@ -411,20 +400,20 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
     virtual: boolean;
     internal: boolean;
     expression: string;
-    alias?: string | undefined;
-    operations?: {
-        type: "none" | "min" | "max" | "avg" | "derivative";
+    operations: {
+        type: "min" | "max" | "avg" | "none" | "derivative";
         resetChannel: number;
         duration: TimeSpan;
-    }[] | undefined;
-    concurrency?: control.Concurrency | undefined;
+    }[];
+    concurrency: control.Concurrency;
+    alias?: string | undefined;
     status?: {
         key: string;
         name: string;
         variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
         message: string;
+        description: string;
         time: TimeStamp;
-        description?: string | undefined;
         labels?: {
             key: string;
             name: string;
@@ -444,9 +433,10 @@ export declare const writerConfigZ: z.ZodUnion<[z.ZodObject<{
     controlSubject?: {
         key: string;
         name: string;
-        group?: number | undefined;
+        group: number;
     } | undefined;
 }, string[] | number[]>>]>;
+/** Config for a writer. Pass it to `client.telem.openWriter`. */
 export type WriterConfig = z.input<typeof writerConfigZ>;
 declare const reqZ: z.ZodObject<{
     command: z.ZodEnum<typeof WriterCommand>;
@@ -459,7 +449,7 @@ declare const reqZ: z.ZodObject<{
         controlSubject: z.ZodOptional<z.ZodObject<{
             key: z.ZodString;
             name: z.ZodString;
-            group: z.ZodOptional<z.ZodUInt32>;
+            group: z.ZodDefault<z.ZodUInt32>;
         }, z.core.$strip>>;
         authorities: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodInt, z.ZodTransform<number[], number>>, z.ZodArray<z.ZodInt>]>>;
         mode: z.ZodDefault<z.ZodUnion<[z.ZodEnum<typeof WriterMode>, z.ZodPipe<z.ZodEnum<{
@@ -491,17 +481,21 @@ declare const reqZ: z.ZodObject<{
                     value: z.ZodBigInt;
                 }, z.core.$strip>, z.ZodTransform<TimeStamp, {
                     value: bigint;
-                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<TimeSpan, TimeSpan>, z.ZodTransform<TimeStamp, TimeSpan>>, z.ZodPipe<z.ZodUnion<readonly [z.ZodTuple<[z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt, z.ZodInt], null>]>, z.ZodTransform<TimeStamp, [number, number, number] | [number, number] | [number]>>]>;
+                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<TimeSpan, TimeSpan>, z.ZodTransform<TimeStamp, TimeSpan>>, z.ZodPipe<z.ZodUnion<readonly [z.ZodTuple<[z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt, z.ZodInt], null>]>, z.ZodTransform<TimeStamp, [number, number] | [number] | [number, number, number]>>]>;
                 end: z.ZodUnion<readonly [z.ZodCustom<TimeStamp, TimeStamp>, z.ZodPipe<z.ZodObject<{
                     value: z.ZodBigInt;
                 }, z.core.$strip>, z.ZodTransform<TimeStamp, {
                     value: bigint;
-                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<TimeSpan, TimeSpan>, z.ZodTransform<TimeStamp, TimeSpan>>, z.ZodPipe<z.ZodUnion<readonly [z.ZodTuple<[z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt, z.ZodInt], null>]>, z.ZodTransform<TimeStamp, [number, number, number] | [number, number] | [number]>>]>;
+                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<TimeSpan, TimeSpan>, z.ZodTransform<TimeStamp, TimeSpan>>, z.ZodPipe<z.ZodUnion<readonly [z.ZodTuple<[z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt], null>, z.ZodTuple<[z.ZodInt, z.ZodInt, z.ZodInt], null>]>, z.ZodTransform<TimeStamp, [number, number] | [number] | [number, number, number]>>]>;
             }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').TimeRange, {
                 start: TimeStamp;
                 end: TimeStamp;
             }>>, z.ZodCustom<import('@synnaxlabs/x').TimeRange, import('@synnaxlabs/x').TimeRange>]>>;
-            dataType: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>]>;
+            dataType: z.ZodUnion<readonly [z.ZodCustom<import('@synnaxlabs/x').DataType, import('@synnaxlabs/x').DataType>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').DataType, string>>, z.ZodPipe<z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').DataType, {
+                value: string;
+            }>>]>;
             alignment: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
             data: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<ArrayBuffer, string>>, z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<ArrayBuffer, null | undefined>>, z.ZodCustom<ArrayBuffer, ArrayBuffer>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>;
             glBufferUsage: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
@@ -514,66 +508,41 @@ declare const reqZ: z.ZodObject<{
 }, z.core.$strip>;
 export interface WriteRequest extends z.input<typeof reqZ> {
 }
-declare const authorityArgsZ: z.ZodPipe<z.ZodTuple<[z.ZodUnion<readonly [z.ZodRecord<z.ZodUnion<[z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodString]>, z.ZodInt>, z.ZodUnion<[z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodString]>, z.ZodInt]>, z.ZodOptional<z.ZodInt>], null>, z.ZodTransform<{
+declare const authorityParamsZ: z.ZodPipe<z.ZodTuple<[z.ZodUnion<readonly [z.ZodRecord<z.ZodUnion<[z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodString]>, z.ZodInt>, z.ZodUnion<[z.ZodUnion<[z.ZodUInt32, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodString]>, z.ZodInt]>, z.ZodOptional<z.ZodInt>], null>, z.ZodTransform<{
     keys: channel.Key[] | channel.Name[];
     authorities: number[];
 }, [string | number | Record<string | number, number>, (number | undefined)?]>>;
-export type AuthorityArgs = z.input<typeof authorityArgsZ>;
 /**
- * Writer is used to write telemetry to a set of channels in time order. It should not
- * be instantiated directly, and should instead be instantiated via the FramerClient
- * {@link FrameClient#openWriter}.
- *
- * The writer is a streaming protocol that is heavily optimized for performance. This
- * comes at the cost of increased complexity, and should only be used directly when
- * writing large volumes of data (such as recording telemetry from a sensor or ingesting
- * data from file). Simpler methods (such as the frame client's write method) should be
- * used for most use cases.
- *
- * The protocol is as follows:
- *
- * 1. The writer is opened with a starting timestamp and a list of channel keys. The
- *    writer will fail to open if the starting timestamp overlaps with any existing
- *    telemetry for any channels specified. If the writer opens successfully, the caller
- *    is then free to write frames to the writer.
- *
- * 2. To write a frame, the caller can use the write method and follow the validation
- *    rules described in its method's documentation. This process is asynchronous,
- *    meaning that write calls may return before the frame has been written to the
- *    cluster. This also means that the writer can accumulate an error after write is
- *    called. If the writer accumulates an error, all subsequent write and commit calls
- *    will return False. The caller can check for errors by calling the error method,
- *    which returns the accumulated error and resets the writer for future use. The
- *    caller can also check for errors by closing the writer, which will throw any
- *    accumulated error.
- *
- * 3. To commit the written frames to the cluster, the caller can call the commit
- *    method. Unlike write, commit is synchronous, meaning that it will not return until
- *    the frames have been written to the cluster. If the writer has accumulated an
- *    error, commit will return false. After the caller acknowledges the error, they can
- *    attempt to commit again. Commit can be called several times throughout a writer's
- *    lifetime, and will only commit the frames that have been written since the last
- *    commit.
+ * Arguments to `Writer.setAuthority`: one authority for every channel, one channel and
+ * its authority, or a record of channel to authority.
+ */
+export type AuthorityParams = z.input<typeof authorityParamsZ>;
+/**
+ * Writes telemetry to a set of channels in time order. Open one with
+ * {@link FrameClient#openWriter}, never directly. Prefer the frame client's write
+ * method unless the volume warrants the streaming protocol.
  *
- * 4. A writer MUST be closed after use in order to prevent resource leaks. Close should
- *    typically be called in a 'finally' block. If the writer has accumulated an error,
- *    close will throw the error.
+ * Opening fails when the start timestamp overlaps existing telemetry on any of the
+ * channels. `write` is asynchronous, so a failure surfaces on a later call: once the
+ * writer accumulates an error, every write and commit returns false until `error`
+ * reads and clears it. `commit` blocks until the cluster has the frames written since
+ * the last commit, and may be called repeatedly. Close in a `finally` block to release
+ * resources; close throws any accumulated error.
  */
 export declare class Writer {
     private readonly stream;
     private readonly adapter;
     private closeErr;
     private constructor();
-    static _open(retriever: channel.Retriever, client: WebSocketClient, config: WriterConfig): Promise<Writer>;
+    static _open(retrieveChannels: ChannelRetriever, client: WebSocketClient, config: WriterConfig): Promise<Writer>;
     write(channel: channel.Key | channel.Name, data: CrudeSeries): Promise<void>;
     write(channel: channel.Key[] | channel.Name[], data: CrudeSeries[]): Promise<void>;
     write(frame: CrudeFrame | Record<channel.Key | channel.Name, CrudeSeries>): Promise<void>;
     write(channelsOrData: channel.Params | Record<channel.Key | channel.Name, CrudeSeries> | CrudeFrame, series?: CrudeSeries | CrudeSeries[]): Promise<void>;
-    setAuthority(value: AuthorityArgs[0], authority?: AuthorityArgs[1]): Promise<void>;
+    setAuthority(value: AuthorityParams[0], authority?: AuthorityParams[1]): Promise<void>;
     /**
      * Commits the written frames to the database. Commit is synchronous, meaning that it
      * will not return until all frames have been committed to the database.
-     *
      * @returns the timestamp of the last sample written to the writer.
      * @throws if the commit fails or any previous writer method has thrown. Once commit
      * throws, the writer must be closed and re-opened to continue use.

package/dist/src/framer/writer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/framer/writer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/framer/writer.ts"],"names":[],"mappings":"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"}