@naisys/hub-protocol 3.0.0-beta.3

package/dist/schemas/costs.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+/** How often NAISYS instances flush buffered cost entries to the hub (ms) */
+export const COST_FLUSH_INTERVAL_MS = 100;
+export const CostSourceEnum = z.enum([
+    "console",
+    "write_protection",
+    "compact",
+    "lynx",
+    "look",
+    "listen",
+    "genimg",
+]);
+/** A single cost entry sent from NAISYS instance to hub */
+export const CostWriteEntrySchema = z.object({
+    userId: z.number(),
+    runId: z.number(),
+    sessionId: z.number(),
+    source: CostSourceEnum,
+    model: z.string(),
+    cost: z.number(),
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheWriteTokens: z.number(),
+    cacheReadTokens: z.number(),
+});
+/** Batch of cost entries sent from NAISYS instance to hub */
+export const CostWriteRequestSchema = z.object({
+    entries: z.array(CostWriteEntrySchema),
+});
+/** Per-user budget entry in the COST_WRITE response */
+export const CostWriteBudgetEntrySchema = z.object({
+    userId: z.number(),
+    /** Remaining budget for this agent, or null if no per-agent limit */
+    budgetLeft: z.number().nullable(),
+});
+/** Response to COST_WRITE — returns per-agent budget info for each user in the batch */
+export const CostWriteResponseSchema = z.object({
+    budgets: z.array(CostWriteBudgetEntrySchema),
+});
+/** Cost delta pushed from hub to supervisor after DB write */
+export const CostPushEntrySchema = z.object({
+    userId: z.number(),
+    runId: z.number(),
+    sessionId: z.number(),
+    costDelta: z.number(),
+});
+export const CostPushSchema = z.object({
+    entries: z.array(CostPushEntrySchema),
+});
+/** Pushed from hub when an agent's spending status changes */
+export const CostControlSchema = z.object({
+    userId: z.number(),
+    enabled: z.boolean(),
+    reason: z.string(),
+});

package/dist/schemas/heartbeat.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/** How often NAISYS instances send heartbeats to the hub (ms) */
+export declare const NAISYS_HEARTBEAT_INTERVAL_MS = 2000;
+/** How often the hub pushes aggregate active user status to all connections (NAISYS/Supervisors) (ms) */
+export declare const HUB_HEARTBEAT_INTERVAL_MS = 2000;
+/** Sent by NAISYS instance to hub with active user IDs */
+export declare const HeartbeatSchema: z.ZodObject<{
+    activeUserIds: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export type Heartbeat = z.infer<typeof HeartbeatSchema>;
+/** Per-agent notification IDs pushed from hub to connected clients */
+export declare const AgentNotificationSchema: z.ZodObject<{
+    latestLogId: z.ZodNumber;
+    latestMailId: z.ZodNumber;
+    latestChatId: z.ZodNumber;
+}, z.core.$strip>;
+export type AgentNotification = z.infer<typeof AgentNotificationSchema>;
+/** Sent by hub to NAISYS instances with aggregate active agents and notifications */
+export declare const AgentsStatusSchema: z.ZodObject<{
+    hostActiveAgents: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>;
+    agentNotifications: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        latestLogId: z.ZodNumber;
+        latestMailId: z.ZodNumber;
+        latestChatId: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AgentsStatus = z.infer<typeof AgentsStatusSchema>;
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/schemas/heartbeat.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+/** How often NAISYS instances send heartbeats to the hub (ms) */
+export const NAISYS_HEARTBEAT_INTERVAL_MS = 2000;
+/** How often the hub pushes aggregate active user status to all connections (NAISYS/Supervisors) (ms) */
+export const HUB_HEARTBEAT_INTERVAL_MS = 2000;
+/** Sent by NAISYS instance to hub with active user IDs */
+export const HeartbeatSchema = z.object({
+    activeUserIds: z.array(z.number()),
+});
+/** Per-agent notification IDs pushed from hub to connected clients */
+export const AgentNotificationSchema = z.object({
+    latestLogId: z.number(),
+    latestMailId: z.number(),
+    latestChatId: z.number(),
+});
+/** Sent by hub to NAISYS instances with aggregate active agents and notifications */
+export const AgentsStatusSchema = z.object({
+    hostActiveAgents: z.record(z.string(), z.array(z.number())),
+    agentNotifications: z.record(z.string(), AgentNotificationSchema).optional(),
+});

package/dist/schemas/hosts.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const HostTypeEnum: z.ZodEnum<{
+    naisys: "naisys";
+    supervisor: "supervisor";
+}>;
+export type HostType = z.infer<typeof HostTypeEnum>;
+/** Pushed from hub to all NAISYS instances when the set of known hosts changes */
+export declare const HostListSchema: z.ZodObject<{
+    hosts: z.ZodArray<z.ZodObject<{
+        hostId: z.ZodNumber;
+        hostName: z.ZodString;
+        restricted: z.ZodBoolean;
+        hostType: z.ZodEnum<{
+            naisys: "naisys";
+            supervisor: "supervisor";
+        }>;
+        online: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type HostList = z.infer<typeof HostListSchema>;
+//# sourceMappingURL=hosts.d.ts.map

package/dist/schemas/hosts.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const HostTypeEnum = z.enum(["naisys", "supervisor"]);
+/** Pushed from hub to all NAISYS instances when the set of known hosts changes */
+export const HostListSchema = z.object({
+    hosts: z.array(z.object({
+        hostId: z.number(),
+        hostName: z.string(),
+        restricted: z.boolean(),
+        hostType: HostTypeEnum,
+        online: z.boolean(),
+    })),
+});

package/dist/schemas/logs.d.ts

@@ -0,0 +1,154 @@
+import { z } from "zod";
+/** How often NAISYS instances flush buffered log entries to the hub (ms) */
+export declare const LOG_FLUSH_INTERVAL_MS = 100;
+export declare const LogRoleEnum: z.ZodEnum<{
+    NAISYS: "NAISYS";
+    LLM: "LLM";
+}>;
+export declare const LogSourceEnum: z.ZodEnum<{
+    console: "console";
+    startPrompt: "startPrompt";
+    endPrompt: "endPrompt";
+    llm: "llm";
+}>;
+export declare const LogTypeEnum: z.ZodEnum<{
+    error: "error";
+    comment: "comment";
+    system: "system";
+    tool: "tool";
+}>;
+/** A single log entry sent from NAISYS instance to hub */
+export declare const LogWriteEntrySchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    runId: z.ZodNumber;
+    sessionId: z.ZodNumber;
+    role: z.ZodEnum<{
+        NAISYS: "NAISYS";
+        LLM: "LLM";
+    }>;
+    source: z.ZodNullable<z.ZodEnum<{
+        console: "console";
+        startPrompt: "startPrompt";
+        endPrompt: "endPrompt";
+        llm: "llm";
+    }>>;
+    type: z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        comment: "comment";
+        system: "system";
+        tool: "tool";
+    }>>;
+    message: z.ZodString;
+    createdAt: z.ZodString;
+    attachmentId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type LogWriteEntry = z.infer<typeof LogWriteEntrySchema>;
+/** Batch of log entries sent from NAISYS instance to hub */
+export declare const LogWriteRequestSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        userId: z.ZodNumber;
+        runId: z.ZodNumber;
+        sessionId: z.ZodNumber;
+        role: z.ZodEnum<{
+            NAISYS: "NAISYS";
+            LLM: "LLM";
+        }>;
+        source: z.ZodNullable<z.ZodEnum<{
+            console: "console";
+            startPrompt: "startPrompt";
+            endPrompt: "endPrompt";
+            llm: "llm";
+        }>>;
+        type: z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            comment: "comment";
+            system: "system";
+            tool: "tool";
+        }>>;
+        message: z.ZodString;
+        createdAt: z.ZodString;
+        attachmentId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LogWriteRequest = z.infer<typeof LogWriteRequestSchema>;
+/** A single log entry pushed from hub to supervisor (includes DB-assigned ID) */
+export declare const LogPushEntrySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    previousId: z.ZodNullable<z.ZodNumber>;
+    userId: z.ZodNumber;
+    runId: z.ZodNumber;
+    sessionId: z.ZodNumber;
+    role: z.ZodEnum<{
+        NAISYS: "NAISYS";
+        LLM: "LLM";
+    }>;
+    source: z.ZodNullable<z.ZodEnum<{
+        console: "console";
+        startPrompt: "startPrompt";
+        endPrompt: "endPrompt";
+        llm: "llm";
+    }>>;
+    type: z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        comment: "comment";
+        system: "system";
+        tool: "tool";
+    }>>;
+    message: z.ZodString;
+    createdAt: z.ZodString;
+    attachmentId: z.ZodOptional<z.ZodString>;
+    attachmentFilename: z.ZodOptional<z.ZodString>;
+    attachmentFileSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type LogPushEntry = z.infer<typeof LogPushEntrySchema>;
+/** Session delta included with log pushes */
+export declare const LogPushSessionUpdateSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    runId: z.ZodNumber;
+    sessionId: z.ZodNumber;
+    lastActive: z.ZodString;
+    latestLogId: z.ZodNumber;
+    totalLinesDelta: z.ZodNumber;
+}, z.core.$strip>;
+export type LogPushSessionUpdate = z.infer<typeof LogPushSessionUpdateSchema>;
+/** Full-data log push from hub to supervisor */
+export declare const LogPushSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        previousId: z.ZodNullable<z.ZodNumber>;
+        userId: z.ZodNumber;
+        runId: z.ZodNumber;
+        sessionId: z.ZodNumber;
+        role: z.ZodEnum<{
+            NAISYS: "NAISYS";
+            LLM: "LLM";
+        }>;
+        source: z.ZodNullable<z.ZodEnum<{
+            console: "console";
+            startPrompt: "startPrompt";
+            endPrompt: "endPrompt";
+            llm: "llm";
+        }>>;
+        type: z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            comment: "comment";
+            system: "system";
+            tool: "tool";
+        }>>;
+        message: z.ZodString;
+        createdAt: z.ZodString;
+        attachmentId: z.ZodOptional<z.ZodString>;
+        attachmentFilename: z.ZodOptional<z.ZodString>;
+        attachmentFileSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    sessionUpdates: z.ZodArray<z.ZodObject<{
+        userId: z.ZodNumber;
+        runId: z.ZodNumber;
+        sessionId: z.ZodNumber;
+        lastActive: z.ZodString;
+        latestLogId: z.ZodNumber;
+        totalLinesDelta: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LogPush = z.infer<typeof LogPushSchema>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/schemas/logs.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+/** How often NAISYS instances flush buffered log entries to the hub (ms) */
+export const LOG_FLUSH_INTERVAL_MS = 100;
+export const LogRoleEnum = z.enum(["NAISYS", "LLM"]);
+export const LogSourceEnum = z.enum([
+    "startPrompt",
+    "endPrompt",
+    "console",
+    "llm",
+]);
+export const LogTypeEnum = z.enum(["comment", "error", "system", "tool"]);
+/** A single log entry sent from NAISYS instance to hub */
+export const LogWriteEntrySchema = z.object({
+    userId: z.number(),
+    runId: z.number(),
+    sessionId: z.number(),
+    role: LogRoleEnum,
+    source: LogSourceEnum.nullable(),
+    type: LogTypeEnum.nullable(),
+    message: z.string(),
+    createdAt: z.string(),
+    attachmentId: z.number().optional(),
+});
+/** Batch of log entries sent from NAISYS instance to hub */
+export const LogWriteRequestSchema = z.object({
+    entries: z.array(LogWriteEntrySchema),
+});
+/** A single log entry pushed from hub to supervisor (includes DB-assigned ID) */
+export const LogPushEntrySchema = z.object({
+    id: z.number(),
+    /** ID of the previous log entry for this session, null if unknown (e.g. hub restart) */
+    previousId: z.number().nullable(),
+    userId: z.number(),
+    runId: z.number(),
+    sessionId: z.number(),
+    role: LogRoleEnum,
+    source: LogSourceEnum.nullable(),
+    type: LogTypeEnum.nullable(),
+    message: z.string(),
+    createdAt: z.string(),
+    attachmentId: z.string().optional(),
+    attachmentFilename: z.string().optional(),
+    attachmentFileSize: z.number().optional(),
+});
+/** Session delta included with log pushes */
+export const LogPushSessionUpdateSchema = z.object({
+    userId: z.number(),
+    runId: z.number(),
+    sessionId: z.number(),
+    lastActive: z.string(),
+    latestLogId: z.number(),
+    totalLinesDelta: z.number(),
+});
+/** Full-data log push from hub to supervisor */
+export const LogPushSchema = z.object({
+    entries: z.array(LogPushEntrySchema),
+    sessionUpdates: z.array(LogPushSessionUpdateSchema),
+});

package/dist/schemas/mail.d.ts

@@ -0,0 +1,261 @@
+import { z } from "zod";
+export declare const MessageKindSchema: z.ZodEnum<{
+    mail: "mail";
+    chat: "chat";
+}>;
+export type MessageKind = z.infer<typeof MessageKindSchema>;
+export declare const AttachmentPurposeEnum: z.ZodEnum<{
+    mail: "mail";
+    context: "context";
+}>;
+export type AttachmentPurpose = z.infer<typeof AttachmentPurposeEnum>;
+/** Request to send a mail message */
+export declare const MailSendRequestSchema: z.ZodObject<{
+    fromUserId: z.ZodNumber;
+    toUserIds: z.ZodArray<z.ZodNumber>;
+    subject: z.ZodString;
+    body: z.ZodString;
+    kind: z.ZodEnum<{
+        mail: "mail";
+        chat: "chat";
+    }>;
+    attachmentIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type MailSendRequest = z.infer<typeof MailSendRequestSchema>;
+/** Response to mail send request */
+export declare const MailSendResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MailSendResponse = z.infer<typeof MailSendResponseSchema>;
+/** Request to list mail messages */
+export declare const MailListRequestSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    filter: z.ZodOptional<z.ZodEnum<{
+        received: "received";
+        sent: "sent";
+    }>>;
+    kind: z.ZodEnum<{
+        mail: "mail";
+        chat: "chat";
+    }>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    take: z.ZodOptional<z.ZodNumber>;
+    withUserIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type MailListRequest = z.infer<typeof MailListRequestSchema>;
+/** Attachment metadata included in message responses */
+export declare const MailAttachmentDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+    fileSize: z.ZodNumber;
+}, z.core.$strip>;
+export type MailAttachmentData = z.infer<typeof MailAttachmentDataSchema>;
+/** A single message in a mail list response */
+export declare const MailListMessageDataSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    fromUsername: z.ZodString;
+    fromTitle: z.ZodString;
+    recipientUsernames: z.ZodArray<z.ZodString>;
+    subject: z.ZodString;
+    createdAt: z.ZodString;
+    isUnread: z.ZodBoolean;
+    body: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        filename: z.ZodString;
+        fileSize: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MailListMessageData = z.infer<typeof MailListMessageDataSchema>;
+/** Response to mail list request */
+export declare const MailListResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        fromUsername: z.ZodString;
+        fromTitle: z.ZodString;
+        recipientUsernames: z.ZodArray<z.ZodString>;
+        subject: z.ZodString;
+        createdAt: z.ZodString;
+        isUnread: z.ZodBoolean;
+        body: z.ZodOptional<z.ZodString>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            fileSize: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MailListResponse = z.infer<typeof MailListResponseSchema>;
+/** Request to peek at a specific mail message */
+export declare const MailPeekRequestSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    messageId: z.ZodNumber;
+}, z.core.$strip>;
+export type MailPeekRequest = z.infer<typeof MailPeekRequestSchema>;
+/** Full message data returned when fetching a message */
+export declare const MailMessageDataSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    subject: z.ZodString;
+    fromUsername: z.ZodString;
+    fromTitle: z.ZodString;
+    recipientUsernames: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    body: z.ZodString;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        filename: z.ZodString;
+        fileSize: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MailMessageData = z.infer<typeof MailMessageDataSchema>;
+/** Response to mail peek request */
+export declare const MailPeekResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodObject<{
+        id: z.ZodNumber;
+        subject: z.ZodString;
+        fromUsername: z.ZodString;
+        fromTitle: z.ZodString;
+        recipientUsernames: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        body: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            fileSize: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MailPeekResponse = z.infer<typeof MailPeekResponseSchema>;
+/** Request to archive mail messages */
+export declare const MailArchiveRequestSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    messageIds: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export type MailArchiveRequest = z.infer<typeof MailArchiveRequestSchema>;
+/** Response to mail archive request */
+export declare const MailArchiveResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    archivedIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MailArchiveResponse = z.infer<typeof MailArchiveResponseSchema>;
+/** Request to search mail messages */
+export declare const MailSearchRequestSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    terms: z.ZodString;
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+    subjectOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MailSearchRequest = z.infer<typeof MailSearchRequestSchema>;
+/** A single message in a mail search response */
+export declare const MailSearchMessageDataSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    subject: z.ZodString;
+    fromUsername: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type MailSearchMessageData = z.infer<typeof MailSearchMessageDataSchema>;
+/** Response to mail search request */
+export declare const MailSearchResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        subject: z.ZodString;
+        fromUsername: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MailSearchResponse = z.infer<typeof MailSearchResponseSchema>;
+/** Request to mark messages as read */
+export declare const MailMarkReadRequestSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    messageIds: z.ZodArray<z.ZodNumber>;
+    kind: z.ZodEnum<{
+        mail: "mail";
+        chat: "chat";
+    }>;
+}, z.core.$strip>;
+export type MailMarkReadRequest = z.infer<typeof MailMarkReadRequestSchema>;
+/** Response to mark-read request */
+export declare const MailMarkReadResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MailMarkReadResponse = z.infer<typeof MailMarkReadResponseSchema>;
+/** Request to get unread messages */
+export declare const MailUnreadRequestSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    kind: z.ZodEnum<{
+        mail: "mail";
+        chat: "chat";
+    }>;
+    afterId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type MailUnreadRequest = z.infer<typeof MailUnreadRequestSchema>;
+/** Response to unread messages request */
+export declare const MailUnreadResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        subject: z.ZodString;
+        fromUsername: z.ZodString;
+        fromTitle: z.ZodString;
+        recipientUsernames: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        body: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            fileSize: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MailUnreadResponse = z.infer<typeof MailUnreadResponseSchema>;
+/** Push notification from hub to NAISYS when mail is received */
+export declare const MailReceivedPushSchema: z.ZodObject<{
+    recipientUserIds: z.ZodArray<z.ZodNumber>;
+    kind: z.ZodEnum<{
+        mail: "mail";
+        chat: "chat";
+    }>;
+}, z.core.$strip>;
+export type MailReceivedPush = z.infer<typeof MailReceivedPushSchema>;
+/** Full-data mail/chat push from hub to supervisor after DB write */
+export declare const MailPushSchema: z.ZodObject<{
+    recipientUserIds: z.ZodArray<z.ZodNumber>;
+    fromUserId: z.ZodNumber;
+    kind: z.ZodEnum<{
+        mail: "mail";
+        chat: "chat";
+    }>;
+    messageId: z.ZodNumber;
+    subject: z.ZodOptional<z.ZodString>;
+    body: z.ZodString;
+    createdAt: z.ZodString;
+    participants: z.ZodString;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        filename: z.ZodString;
+        fileSize: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MailPush = z.infer<typeof MailPushSchema>;
+/** Read-receipt push from hub to supervisor when messages are marked read */
+export declare const MailReadPushSchema: z.ZodObject<{
+    messageIds: z.ZodArray<z.ZodNumber>;
+    userId: z.ZodNumber;
+    kind: z.ZodEnum<{
+        mail: "mail";
+        chat: "chat";
+    }>;
+    participants: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type MailReadPush = z.infer<typeof MailReadPushSchema>;
+//# sourceMappingURL=mail.d.ts.map