@synnaxlabs/pluto 0.12.0

package/dist/telem/control/aether/chip.d.ts

@@ -0,0 +1,229 @@
+import { type Destructor } from "@synnaxlabs/x";
+import { z } from "zod";
+import { aether } from '../../../aether/aether';
+import { telem } from '../../../telem/aether';
+export declare const chipStateZ: z.ZodObject<{
+    triggered: z.ZodBoolean;
+    status: z.ZodObject<{
+        key: z.ZodString;
+        variant: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+        message: z.ZodString;
+        time: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        key: string;
+        time: import("@synnaxlabs/x").TimeStamp;
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }, {
+        message: string;
+        key: string;
+        time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }>;
+    sink: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        props: z.ZodAny;
+        variant: z.ZodLiteral<"sink">;
+        transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+        valueType: z.ZodLiteral<"boolean">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        valueType: "boolean";
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    }, {
+        type: string;
+        valueType: "boolean";
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>>>;
+    source: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        props: z.ZodAny;
+        variant: z.ZodLiteral<"source">;
+        transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+        valueType: z.ZodLiteral<"status">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }, {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    status: {
+        message: string;
+        key: string;
+        time: import("@synnaxlabs/x").TimeStamp;
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    };
+    source: {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    };
+    sink: {
+        type: string;
+        valueType: "boolean";
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    };
+    triggered: boolean;
+}, {
+    status: {
+        message: string;
+        key: string;
+        time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    };
+    triggered: boolean;
+    sink?: {
+        type: string;
+        valueType: "boolean";
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    } | undefined;
+    source?: {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    } | undefined;
+}>;
+interface InternalState {
+    source: telem.StatusSource;
+    sink: telem.BooleanSink;
+    stopListening: Destructor;
+}
+export declare class Chip extends aether.Leaf<typeof chipStateZ, InternalState> {
+    static readonly TYPE = "Chip";
+    schema: z.ZodObject<{
+        triggered: z.ZodBoolean;
+        status: z.ZodObject<{
+            key: z.ZodString;
+            variant: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+            message: z.ZodString;
+            time: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            key: string;
+            time: import("@synnaxlabs/x").TimeStamp;
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }, {
+            message: string;
+            key: string;
+            time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }>;
+        sink: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            props: z.ZodAny;
+            variant: z.ZodLiteral<"sink">;
+            transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+            valueType: z.ZodLiteral<"boolean">;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            valueType: "boolean";
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        }, {
+            type: string;
+            valueType: "boolean";
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>>>;
+        source: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            props: z.ZodAny;
+            variant: z.ZodLiteral<"source">;
+            transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+            valueType: z.ZodLiteral<"status">;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }, {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        status: {
+            message: string;
+            key: string;
+            time: import("@synnaxlabs/x").TimeStamp;
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        };
+        source: {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        };
+        sink: {
+            type: string;
+            valueType: "boolean";
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        };
+        triggered: boolean;
+    }, {
+        status: {
+            message: string;
+            key: string;
+            time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        };
+        triggered: boolean;
+        sink?: {
+            type: string;
+            valueType: "boolean";
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        } | undefined;
+        source?: {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        } | undefined;
+    }>;
+    afterUpdate(): void;
+    private updateEnabledState;
+    afterDelete(): void;
+    render(): void;
+}
+export {};

package/dist/telem/control/aether/controller.d.ts

@@ -0,0 +1,166 @@
+import { type Instrumentation } from "@synnaxlabs/alamos";
+import { channel, type Synnax, framer, Authority } from "@synnaxlabs/client";
+import { z } from "zod";
+import { aether } from '../../../aether/aether';
+import { type theming } from '../../../aetherIndex';
+import { status } from '../../../status/aether';
+import { telem } from '../../../telem/aether';
+import { AbstractSink } from '../../../telem/aether/telem';
+import { StateProvider } from '../../../telem/control/aether/state';
+export declare const STATUSES: readonly ["acquired", "released", "overridden", "failed"];
+export declare const statusZ: z.ZodEnum<["acquired", "released", "overridden", "failed"]>;
+export type Status = z.infer<typeof statusZ>;
+export declare const controllerStateZ: z.ZodObject<{
+    name: z.ZodString;
+    authority: z.ZodDefault<z.ZodNumber>;
+    acquireTrigger: z.ZodNumber;
+    status: z.ZodOptional<z.ZodEnum<["acquired", "released", "overridden", "failed"]>>;
+    needsControlOf: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    authority: number;
+    acquireTrigger: number;
+    needsControlOf: number[];
+    status?: "failed" | "acquired" | "released" | "overridden" | undefined;
+}, {
+    name: string;
+    acquireTrigger: number;
+    authority?: number | undefined;
+    status?: "failed" | "acquired" | "released" | "overridden" | undefined;
+    needsControlOf?: number[] | undefined;
+}>;
+interface InternalState {
+    client: Synnax | null;
+    instrumentation: Instrumentation;
+    stateProv: StateProvider;
+    addStatus: status.Aggregate;
+    theme: theming.Theme;
+    prevTrigger: number;
+}
+interface AetherControllerTelem extends telem.Telem {
+    needsControlOf: (client: Synnax) => Promise<channel.Keys>;
+}
+/**
+ * @summary Acquires control over a set of channels by opening a writer to a Synnax
+ * cluster, and then acts as a factory for telemetry that can be used to send commands
+ * to that writer.
+ */
+export declare class Controller extends aether.Composite<typeof controllerStateZ, InternalState> implements telem.Factory {
+    static readonly TYPE = "Controller";
+    schema: z.ZodObject<{
+        name: z.ZodString;
+        authority: z.ZodDefault<z.ZodNumber>;
+        acquireTrigger: z.ZodNumber;
+        status: z.ZodOptional<z.ZodEnum<["acquired", "released", "overridden", "failed"]>>;
+        needsControlOf: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        authority: number;
+        acquireTrigger: number;
+        needsControlOf: number[];
+        status?: "failed" | "acquired" | "released" | "overridden" | undefined;
+    }, {
+        name: string;
+        acquireTrigger: number;
+        authority?: number | undefined;
+        status?: "failed" | "acquired" | "released" | "overridden" | undefined;
+        needsControlOf?: number[] | undefined;
+    }>;
+    private readonly registry;
+    private writer?;
+    afterUpdate(): void;
+    afterDelete(): void;
+    private updateNeedsControlOf;
+    private acquire;
+    private release;
+    set(frame: framer.CrudeFrame): Promise<void>;
+    setAuthority(channels: channel.Keys, value: Authority): Promise<void>;
+    releaseAuthority(keys: channel.Keys): Promise<void>;
+    deleteTelem(t: AetherControllerTelem): void;
+    /** @implements telem.Factory to create telemetry that is bound to this controller. */
+    create<T>(spec: telem.Spec): T | null;
+}
+export declare const setChannelValuePropsZ: z.ZodObject<{
+    channel: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    channel: number;
+}, {
+    channel: number;
+}>;
+export type SetChannelValueProps = z.infer<typeof setChannelValuePropsZ>;
+export declare class SetChannelValue extends AbstractSink<typeof setChannelValuePropsZ> implements telem.NumberSink, AetherControllerTelem {
+    static readonly TYPE = "controlled-numeric-telem-sink";
+    private readonly controller;
+    schema: z.ZodObject<{
+        channel: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        channel: number;
+    }, {
+        channel: number;
+    }>;
+    constructor(controller: Controller, props: unknown);
+    invalidate(): void;
+    cleanup(): void;
+    needsControlOf(client: Synnax): Promise<channel.Keys>;
+    set(value: number): Promise<void>;
+}
+export declare const setChannelValue: (props: SetChannelValueProps) => telem.NumberSinkSPec;
+export declare const acquireChannelControlPropsZ: z.ZodObject<{
+    authority: z.ZodDefault<z.ZodNumber>;
+    channel: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    channel: number;
+    authority: number;
+}, {
+    channel: number;
+    authority?: number | undefined;
+}>;
+export type AcquireChannelControlProps = z.infer<typeof acquireChannelControlPropsZ>;
+export declare class AcquireChannelControl extends AbstractSink<typeof acquireChannelControlPropsZ> implements telem.BooleanSink, AetherControllerTelem {
+    static readonly TYPE = "acquire-channel-control";
+    private readonly controller;
+    schema: z.ZodObject<{
+        authority: z.ZodDefault<z.ZodNumber>;
+        channel: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        channel: number;
+        authority: number;
+    }, {
+        channel: number;
+        authority?: number | undefined;
+    }>;
+    constructor(controller: Controller, props: unknown);
+    cleanup(): void;
+    needsControlOf(client: Synnax): Promise<channel.Keys>;
+    set(acquire: boolean): Promise<void>;
+}
+export declare const acquireChannelControl: (props: AcquireChannelControlProps) => telem.BooleanSinkSpec;
+export declare const authoritySourceProps: z.ZodObject<{
+    channel: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    channel: number;
+}, {
+    channel: number;
+}>;
+export type AuthoritySourceProps = z.infer<typeof authoritySourceProps>;
+export declare class AuthoritySource extends telem.AbstractSource<typeof authoritySourceProps> implements telem.StatusSource, AetherControllerTelem {
+    static readonly TYPE = "controlled-status-source";
+    private readonly prov;
+    private valid;
+    private stopListening?;
+    private readonly controller;
+    schema: z.ZodObject<{
+        channel: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        channel: number;
+    }, {
+        channel: number;
+    }>;
+    constructor(controller: Controller, prov: StateProvider, props: unknown);
+    needsControlOf(): Promise<channel.Keys>;
+    private maybeRevalidate;
+    value(): Promise<status.Spec>;
+    cleanup(): void;
+}
+export declare const authoritySource: (props: AuthoritySourceProps) => telem.StatusSourceSpec;
+export {};

package/dist/telem/control/aether/external.d.ts

@@ -0,0 +1,6 @@
+export * from '../../../telem/control/aether/controller';
+export * from '../../../telem/control/aether/state';
+export * from '../../../telem/control/aether/indicator';
+export * from '../../../telem/control/aether/registry';
+export * from '../../../telem/control/aether/chip';
+export * from '../../../telem/control/aether/legend';

package/dist/telem/control/aether/index.d.ts

@@ -0,0 +1 @@
+export * as control from '../../../telem/control/aether/external';

package/dist/telem/control/aether/indicator.d.ts

@@ -0,0 +1,248 @@
+import { z } from "zod";
+import { aether } from '../../../aether/aether';
+import { color } from '../../../color/core';
+import { telem } from '../../../telem/aether';
+export declare const indicatorStateZ: z.ZodObject<{
+    statusSource: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        props: z.ZodAny;
+        variant: z.ZodLiteral<"source">;
+        transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+        valueType: z.ZodLiteral<"status">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }, {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>>>;
+    colorSource: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        props: z.ZodAny;
+        variant: z.ZodLiteral<"source">;
+        transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+        valueType: z.ZodLiteral<"color">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        valueType: "color";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }, {
+        type: string;
+        valueType: "color";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>>>;
+    status: z.ZodObject<{
+        key: z.ZodString;
+        variant: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+        message: z.ZodString;
+        time: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        key: string;
+        time: import("@synnaxlabs/x").TimeStamp;
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }, {
+        message: string;
+        key: string;
+        time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }>;
+    color: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodType<color.Color, z.ZodTypeDef, color.Color>, z.ZodObject<{
+        rgba255: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, "strip", z.ZodTypeAny, {
+        rgba255: [number, number, number, number];
+    }, {
+        rgba255: [number, number, number, number];
+    }>]>, color.Color, string | [number, number, number, number] | {
+        rgba255: [number, number, number, number];
+    } | color.Color | [number, number, number]>>;
+}, "strip", z.ZodTypeAny, {
+    status: {
+        message: string;
+        key: string;
+        time: import("@synnaxlabs/x").TimeStamp;
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    };
+    statusSource: {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    };
+    colorSource: {
+        type: string;
+        valueType: "color";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    };
+    color?: color.Color | undefined;
+}, {
+    status: {
+        message: string;
+        key: string;
+        time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    };
+    statusSource?: {
+        type: string;
+        valueType: "status";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    } | undefined;
+    colorSource?: {
+        type: string;
+        valueType: "color";
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    } | undefined;
+    color?: string | [number, number, number, number] | {
+        rgba255: [number, number, number, number];
+    } | color.Color | [number, number, number] | undefined;
+}>;
+interface InternalState {
+    statusSource: telem.StatusSource;
+    colorSource: telem.ColorSource;
+}
+export declare class Indicator extends aether.Leaf<typeof indicatorStateZ, InternalState> {
+    static readonly TYPE = "Indicator";
+    schema: z.ZodObject<{
+        statusSource: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            props: z.ZodAny;
+            variant: z.ZodLiteral<"source">;
+            transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+            valueType: z.ZodLiteral<"status">;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }, {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>>>;
+        colorSource: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            props: z.ZodAny;
+            variant: z.ZodLiteral<"source">;
+            transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+            valueType: z.ZodLiteral<"color">;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            valueType: "color";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }, {
+            type: string;
+            valueType: "color";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>>>;
+        status: z.ZodObject<{
+            key: z.ZodString;
+            variant: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+            message: z.ZodString;
+            time: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, import("@synnaxlabs/x").TimeStamp, Number>, z.ZodEffects<z.ZodNumber, import("@synnaxlabs/x").TimeStamp, number>, z.ZodType<import("@synnaxlabs/x").TimeStamp, z.ZodTypeDef, import("@synnaxlabs/x").TimeStamp>]>;
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            key: string;
+            time: import("@synnaxlabs/x").TimeStamp;
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }, {
+            message: string;
+            key: string;
+            time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }>;
+        color: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodType<color.Color, z.ZodTypeDef, color.Color>, z.ZodObject<{
+            rgba255: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, "strip", z.ZodTypeAny, {
+            rgba255: [number, number, number, number];
+        }, {
+            rgba255: [number, number, number, number];
+        }>]>, color.Color, string | [number, number, number, number] | {
+            rgba255: [number, number, number, number];
+        } | color.Color | [number, number, number]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: {
+            message: string;
+            key: string;
+            time: import("@synnaxlabs/x").TimeStamp;
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        };
+        statusSource: {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        };
+        colorSource: {
+            type: string;
+            valueType: "color";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        };
+        color?: color.Color | undefined;
+    }, {
+        status: {
+            message: string;
+            key: string;
+            time: (number | Number | import("@synnaxlabs/x").TimeStamp) & (number | Number | import("@synnaxlabs/x").TimeStamp | undefined);
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        };
+        statusSource?: {
+            type: string;
+            valueType: "status";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        } | undefined;
+        colorSource?: {
+            type: string;
+            valueType: "color";
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        } | undefined;
+        color?: string | [number, number, number, number] | {
+            rgba255: [number, number, number, number];
+        } | color.Color | [number, number, number] | undefined;
+    }>;
+    afterUpdate(): void;
+    afterDelete(): void;
+    render(): Promise<void>;
+    updateState(): Promise<void>;
+}
+export {};