@synnaxlabs/client 0.56.2 → 0.57.1

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

@@ -1,7 +1,8 @@
 import { WebSocketClient } from '@synnaxlabs/freighter';
-import { breaker, observe, Rate, TimeSpan } from '@synnaxlabs/x';
+import { Rate } from '@synnaxlabs/x';
 import { z } from 'zod';
 import { channel } from '../channel';
+import { ChannelRetriever } from './adapter';
 import { Frame } from './frame';
 declare const reqZ: z.ZodObject<{
     keys: z.ZodArray<z.ZodNumber>;
@@ -30,17 +31,21 @@ declare const resZ: z.ZodObject<{
                     value: z.ZodBigInt;
                 }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, {
                     value: bigint;
-                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<TimeSpan, TimeSpan>, z.ZodTransform<import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, [number, number, number] | [number, number] | [number]>>]>;
+                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeSpan>, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, [number, number] | [number] | [number, number, number]>>]>;
                 end: z.ZodUnion<readonly [z.ZodCustom<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodPipe<z.ZodObject<{
                     value: z.ZodBigInt;
                 }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, {
                     value: bigint;
-                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<TimeSpan, TimeSpan>, z.ZodTransform<import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, [number, number, number] | [number, number] | [number]>>]>;
+                }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, bigint>>, z.ZodPipe<z.ZodDate, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, Date>>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeSpan>, z.ZodTransform<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, [number, number] | [number] | [number, number, number]>>]>;
             }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').TimeRange, {
                 start: import('@synnaxlabs/x').TimeStamp;
                 end: import('@synnaxlabs/x').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<{
@@ -56,88 +61,81 @@ declare const resZ: z.ZodObject<{
  */
 export interface StreamerResponse extends z.infer<typeof resZ> {
 }
+/** Zod schema for {@link StreamerConfig}. A bare channel list parses as a config. */
 export declare const streamerConfigZ: z.ZodUnion<[z.ZodObject<{
     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>>]>>;
             duration: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
                 value: z.ZodBigInt;
-            }, z.core.$strip>, z.ZodTransform<TimeSpan, {
+            }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<TimeSpan, 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 import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency>>>;
-        status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-            success: "success";
+            }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, bigint>>, z.ZodCustom<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeSpan>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, Rate>>]>>;
+        }, z.core.$strip>>>;
+        concurrency: z.ZodDefault<z.ZodEnum<typeof import('@synnaxlabs/x/dist/src/control/types.gen.js').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>>]>>;
             duration: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
                 value: z.ZodBigInt;
-            }, z.core.$strip>, z.ZodTransform<TimeSpan, {
+            }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<TimeSpan, 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 import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency>>>;
-        status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-            success: "success";
+            }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, bigint>>, z.ZodCustom<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeSpan>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, Rate>>]>>;
+        }, z.core.$strip>>>;
+        concurrency: z.ZodDefault<z.ZodEnum<typeof import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency>>;
+        status: z.ZodOptional<import('..').StatusZodObject<z.ZodNever, z.ZodEnum<{
             error: "error";
+            success: "success";
             info: "info";
             warning: "warning";
             loading: "loading";
@@ -153,20 +151,20 @@ export declare const streamerConfigZ: 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?: import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency | undefined;
+            duration: import('@synnaxlabs/x').TimeSpan;
+        }[];
+        concurrency: import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency;
+        alias?: string | undefined;
         status?: {
             key: string;
             name: string;
             variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
             message: string;
+            description: string;
             time: import('@synnaxlabs/x').TimeStamp;
-            description?: string | undefined;
             labels?: {
                 key: string;
                 name: string;
@@ -184,20 +182,20 @@ export declare const streamerConfigZ: 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?: import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency | undefined;
+            duration: import('@synnaxlabs/x').TimeSpan;
+        }[];
+        concurrency: import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency;
+        alias?: string | undefined;
         status?: {
             key: string;
             name: string;
             variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
             message: string;
+            description: string;
             time: import('@synnaxlabs/x').TimeStamp;
-            description?: string | undefined;
             labels?: {
                 key: string;
                 name: string;
@@ -215,20 +213,20 @@ export declare const streamerConfigZ: 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?: import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency | undefined;
+            duration: import('@synnaxlabs/x').TimeSpan;
+        }[];
+        concurrency: import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency;
+        alias?: string | undefined;
         status?: {
             key: string;
             name: string;
             variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
             message: string;
+            description: string;
             time: import('@synnaxlabs/x').TimeStamp;
-            description?: string | undefined;
             labels?: {
                 key: string;
                 name: string;
@@ -241,86 +239,78 @@ export declare const streamerConfigZ: z.ZodUnion<[z.ZodObject<{
     throttleRate: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodNumber, z.ZodTransform<Rate, number>>, z.ZodCustom<Rate, Rate>]>>;
     excludeGroups: z.ZodDefault<z.ZodArray<z.ZodUInt32>>;
 }, 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>>]>>;
         duration: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
             value: z.ZodBigInt;
-        }, z.core.$strip>, z.ZodTransform<TimeSpan, {
+        }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<TimeSpan, 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 import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency>>>;
-    status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-        success: "success";
+        }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, bigint>>, z.ZodCustom<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeSpan>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, Rate>>]>>;
+    }, z.core.$strip>>>;
+    concurrency: z.ZodDefault<z.ZodEnum<typeof import('@synnaxlabs/x/dist/src/control/types.gen.js').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>>]>>;
         duration: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
             value: z.ZodBigInt;
-        }, z.core.$strip>, z.ZodTransform<TimeSpan, {
+        }, z.core.$strip>, z.ZodTransform<import('@synnaxlabs/x').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<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<TimeSpan, 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 import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency>>>;
-    status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodNever, z.ZodEnum<{
-        success: "success";
+        }>>, z.ZodPipe<z.ZodString, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, number>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, bigint>>, z.ZodCustom<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeSpan>, z.ZodPipe<z.ZodCustom<import('@synnaxlabs/x').TimeStamp, import('@synnaxlabs/x').TimeStamp>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, import('@synnaxlabs/x').TimeStamp>>, z.ZodPipe<z.ZodCustom<Rate, Rate>, z.ZodTransform<import('@synnaxlabs/x').TimeSpan, Rate>>]>>;
+    }, z.core.$strip>>>;
+    concurrency: z.ZodDefault<z.ZodEnum<typeof import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency>>;
+    status: z.ZodOptional<import('..').StatusZodObject<z.ZodNever, z.ZodEnum<{
         error: "error";
+        success: "success";
         info: "info";
         warning: "warning";
         loading: "loading";
@@ -336,20 +326,20 @@ export declare const streamerConfigZ: 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?: import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency | undefined;
+        duration: import('@synnaxlabs/x').TimeSpan;
+    }[];
+    concurrency: import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency;
+    alias?: string | undefined;
     status?: {
         key: string;
         name: string;
         variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
         message: string;
+        description: string;
         time: import('@synnaxlabs/x').TimeStamp;
-        description?: string | undefined;
         labels?: {
             key: string;
             name: string;
@@ -367,20 +357,20 @@ export declare const streamerConfigZ: 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?: import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency | undefined;
+        duration: import('@synnaxlabs/x').TimeSpan;
+    }[];
+    concurrency: import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency;
+    alias?: string | undefined;
     status?: {
         key: string;
         name: string;
         variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
         message: string;
+        description: string;
         time: import('@synnaxlabs/x').TimeStamp;
-        description?: string | undefined;
         labels?: {
             key: string;
             name: string;
@@ -398,20 +388,20 @@ export declare const streamerConfigZ: 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?: import('@synnaxlabs/x/dist/src/control/types.gen').Concurrency | undefined;
+        duration: import('@synnaxlabs/x').TimeSpan;
+    }[];
+    concurrency: import('@synnaxlabs/x/dist/src/control/types.gen.js').Concurrency;
+    alias?: string | undefined;
     status?: {
         key: string;
         name: string;
         variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
         message: string;
+        description: string;
         time: import('@synnaxlabs/x').TimeStamp;
-        description?: string | undefined;
         labels?: {
             key: string;
             name: string;
@@ -425,105 +415,42 @@ export declare const streamerConfigZ: z.ZodUnion<[z.ZodObject<{
     throttleRate: Rate;
     excludeGroups: number[];
 }, string[] | number[]>>]>;
+/** Config for a streamer. Pass it to `client.telem.openStreamer`. */
 export type StreamerConfig = z.input<typeof streamerConfigZ>;
 /**
- * A streamer is used to stream frames of telemetry in real-time from a Synnax cluster.
- * It should not be constructed directly, and should instead be created using the
- * client's openStreamer method.
- *
- * To open a streamer, use the openStreamer method on the client and pass it in the list
- * of channels you'd like to receive data from. Once the streamer has been opened, call
- * the `read` method to read the next frame of telemetry, or use the streamer as an
- * async iterator to iterate over the frames of telemetry as they are received.
- *
- * The list of channels being streamed can be updated at any time by using the `update`
- * method.
+ * Streams frames of telemetry from a Synnax cluster in real time. Open one with the
+ * client's openStreamer method, never directly. Read frames with `read` or by
+ * iterating the streamer. Close it in a `finally` block to free its resources.
  *
- * Once done, call the `close` method to close the streamer and free all associated
- * resources. We recommend using the streamer within a try-finally block to ensure
- * that it is closed properly in the event of an error.
- *
- * For detailed documentation, see https://docs.synnaxlabs.com/reference/client/working-with-data/streaming-data
+ * @see https://docs.synnaxlabs.com/reference/client/working-with-data/streaming-data
  */
 export interface Streamer extends AsyncIterator<Frame>, AsyncIterable<Frame> {
     /** The keys of the channels currently being streamed from. */
     keys: channel.Key[];
-    /**
-     * Update the list of channels being streamed from. This replaces the list of channels
-     * being streamed from with the new list of channels.
-     */
+    /** Replaces the list of channels being streamed from. */
     update: (channels: channel.Params) => Promise<void>;
     /** Close the streamer and free all associated resources. */
     close: () => void;
     /** Read the next frame of telemetry. */
     read: () => Promise<Frame>;
 }
-/**
- * A function that opens a streamer.
- */
+/** A function that opens a streamer. */
 export interface StreamOpener {
     (config: StreamerConfig): Promise<Streamer>;
 }
 /**
- * Creates a function that opens streamers with the given retriever and client.
- * @param retriever - The channel retriever to use for resolving channel information
+ * Creates a function that opens streamers with the given channel resolver and client.
+ * @param retrieveChannels - Resolves channel params to payloads for the codec
  * @param client - The WebSocket client to use for streaming
  * @returns A function that opens streamers with the given configuration
  */
-export declare const createStreamOpener: (retriever: channel.Retriever, client: WebSocketClient) => StreamOpener;
+export declare const createStreamOpener: (retrieveChannels: ChannelRetriever, client: WebSocketClient) => StreamOpener;
 /**
  * Opens a new streamer with the given configuration.
- * @param retriever - The channel retriever to use for resolving channel information
+ * @param retrieveChannels - Resolves channel params to payloads for the codec
  * @param client - The WebSocket client to use for streaming
- * @param config - The configuration for the streamer
  * @returns A promise that resolves to a new streamer
  */
-export declare const openStreamer: (retriever: channel.Retriever, client: WebSocketClient, config: StreamerConfig) => Promise<Streamer>;
-/**
- * A hardened streamer that automatically reconnects on failure.
- * This streamer wraps a regular streamer and adds automatic reconnection
- * logic when the connection is lost or errors occur.
- */
-export declare class HardenedStreamer implements Streamer {
-    private wrapped_;
-    private readonly breaker;
-    private readonly opener;
-    private readonly config;
-    private constructor();
-    /**
-     * Opens a new hardened streamer with the given configuration.
-     * @param opener - The function to use for opening streamers
-     * @param config - The configuration for the streamer
-     * @returns A promise that resolves to a new hardened streamer
-     */
-    static open(opener: StreamOpener, config: StreamerConfig, breakerConfig?: breaker.Config): Promise<HardenedStreamer>;
-    private runStreamer;
-    private get wrapped();
-    update(channels: channel.Params): Promise<void>;
-    next(): Promise<IteratorResult<Frame>>;
-    read(): Promise<Frame>;
-    close(): void;
-    get keys(): channel.Key[];
-    [Symbol.asyncIterator](): AsyncIterator<Frame>;
-}
-/**
- * Wraps a standard streamer to implement an observable interface for handling changes
- * to channel values through an onChange handler.
- */
-export declare class ObservableStreamer<V = Frame> extends observe.Observer<Frame, V> implements observe.ObservableAsyncCloseable<V> {
-    private readonly streamer;
-    private readonly closePromise;
-    /**
-     * Creates a new observable streamer.
-     * @param streamer - The streamer to wrap
-     * @param transform - An optional transform function to apply to each frame
-     * @template V - The type of the transformed value. Only relevant if transform is
-     * provided. Defaults to Frame.
-     */
-    constructor(streamer: Streamer, transform?: observe.Transform<Frame, V>);
-    update(channels: channel.Params): Promise<void>;
-    close(): Promise<void>;
-    private stream;
-}
+export declare const openStreamer: (retrieveChannels: ChannelRetriever, client: WebSocketClient, config: StreamerConfig) => Promise<Streamer>;
 export {};
 //# sourceMappingURL=streamer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"streamer.d.ts","sourceRoot":"","sources":["../../../src/framer/streamer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"streamer.d.ts","sourceRoot":"","sources":["../../../src/framer/streamer.ts"],"names":[],"mappings":"AASA,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,EAAU,IAAI,EAAO,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,KAAK,EAAU,MAAM,gBAAgB,CAAC;AAG/C,QAAA,MAAM,IAAI;;;;;iBAKR,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC;CAAG;AAEhE,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA8B,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC;CAAG;AAcjE,qFAAqF;AACrF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAE3B,CAAC;AAEF,qEAAqE;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,WAAW,QAAS,SAAQ,aAAa,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,KAAK,CAAC;IAC1E,8DAA8D;IAC9D,IAAI,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC;IACpB,yDAAyD;IACzD,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,4DAA4D;IAC5D,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,wCAAwC;IACxC,IAAI,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;CAC5B;AAED,wCAAwC;AACxC,MAAM,WAAW,YAAY;IAC3B,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC7C;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC5B,kBAAkB,gBAAgB,EAAE,QAAQ,eAAe,KAAG,YAqB9D,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACvB,kBAAkB,gBAAgB,EAClC,QAAQ,eAAe,EACvB,QAAQ,cAAc,KACrB,OAAO,CAAC,QAAQ,CAA+D,CAAC"}