linkshell-cli 0.5.42 → 0.6.0

package/dist/wire/src/model.d.ts

@@ -0,0 +1,704 @@
+import { z } from "zod";
+/**
+ * How far LinkShell can take a given agent. The UI renders capabilities from
+ * this instead of guessing:
+ * - multi_client: desktop TUI and remote devices are live clients of one agent
+ *   server (Codex app-server, OpenCode server).
+ * - handoff: the native TUI owns the session on the desktop; a remote device can
+ *   take it over and the session continues headlessly under the same id.
+ * - remote: structured control only; the desktop uses LinkShell's own UI.
+ * - terminal: PTY only.
+ */
+export declare const agentTierSchema: z.ZodEnum<["multi_client", "handoff", "remote", "terminal"]>;
+export type AgentTier = z.infer<typeof agentTierSchema>;
+export declare const agentCapabilitiesSchema: z.ZodObject<{
+    interrupt: z.ZodBoolean;
+    /** Inject a message into a running turn instead of queueing it. */
+    steer: z.ZodBoolean;
+    permissions: z.ZodBoolean;
+    images: z.ZodBoolean;
+    fork: z.ZodBoolean;
+    models: z.ZodBoolean;
+    modes: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    models: boolean;
+    modes: boolean;
+    steer: boolean;
+    images: boolean;
+    fork: boolean;
+    permissions: boolean;
+    interrupt: boolean;
+}, {
+    models: boolean;
+    modes: boolean;
+    steer: boolean;
+    images: boolean;
+    fork: boolean;
+    permissions: boolean;
+    interrupt: boolean;
+}>;
+export type AgentCapabilities = z.infer<typeof agentCapabilitiesSchema>;
+/**
+ * How the agent authenticates on this machine, as the agent itself reports it
+ * (e.g. `claude auth status`, `codex login status`). LinkShell never handles
+ * the credentials; it runs agents with the user's own environment and config.
+ */
+export declare const agentAuthSchema: z.ZodObject<{
+    state: z.ZodEnum<["ok", "missing", "unknown"]>;
+    /** e.g. "claude.ai", "api_key", "oauth_token", "chatgpt", "bedrock". */
+    method: z.ZodOptional<z.ZodString>;
+    /** What the user should do when state is "missing". */
+    hint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    state: "unknown" | "ok" | "missing";
+    method?: string | undefined;
+    hint?: string | undefined;
+}, {
+    state: "unknown" | "ok" | "missing";
+    method?: string | undefined;
+    hint?: string | undefined;
+}>;
+export type AgentAuth = z.infer<typeof agentAuthSchema>;
+export declare const agentInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    tier: z.ZodEnum<["multi_client", "handoff", "remote", "terminal"]>;
+    installed: z.ZodBoolean;
+    version: z.ZodOptional<z.ZodString>;
+    /** Human-readable reason when the agent is installed but unusable. */
+    problem: z.ZodOptional<z.ZodString>;
+    auth: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<["ok", "missing", "unknown"]>;
+        /** e.g. "claude.ai", "api_key", "oauth_token", "chatgpt", "bedrock". */
+        method: z.ZodOptional<z.ZodString>;
+        /** What the user should do when state is "missing". */
+        hint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        state: "unknown" | "ok" | "missing";
+        method?: string | undefined;
+        hint?: string | undefined;
+    }, {
+        state: "unknown" | "ok" | "missing";
+        method?: string | undefined;
+        hint?: string | undefined;
+    }>>;
+    capabilities: z.ZodObject<{
+        interrupt: z.ZodBoolean;
+        /** Inject a message into a running turn instead of queueing it. */
+        steer: z.ZodBoolean;
+        permissions: z.ZodBoolean;
+        images: z.ZodBoolean;
+        fork: z.ZodBoolean;
+        models: z.ZodBoolean;
+        modes: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        models: boolean;
+        modes: boolean;
+        steer: boolean;
+        images: boolean;
+        fork: boolean;
+        permissions: boolean;
+        interrupt: boolean;
+    }, {
+        models: boolean;
+        modes: boolean;
+        steer: boolean;
+        images: boolean;
+        fork: boolean;
+        permissions: boolean;
+        interrupt: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    capabilities: {
+        models: boolean;
+        modes: boolean;
+        steer: boolean;
+        images: boolean;
+        fork: boolean;
+        permissions: boolean;
+        interrupt: boolean;
+    };
+    tier: "multi_client" | "handoff" | "remote" | "terminal";
+    installed: boolean;
+    auth?: {
+        state: "unknown" | "ok" | "missing";
+        method?: string | undefined;
+        hint?: string | undefined;
+    } | undefined;
+    version?: string | undefined;
+    problem?: string | undefined;
+}, {
+    id: string;
+    label: string;
+    capabilities: {
+        models: boolean;
+        modes: boolean;
+        steer: boolean;
+        images: boolean;
+        fork: boolean;
+        permissions: boolean;
+        interrupt: boolean;
+    };
+    tier: "multi_client" | "handoff" | "remote" | "terminal";
+    installed: boolean;
+    auth?: {
+        state: "unknown" | "ok" | "missing";
+        method?: string | undefined;
+        hint?: string | undefined;
+    } | undefined;
+    version?: string | undefined;
+    problem?: string | undefined;
+}>;
+export type AgentInfo = z.infer<typeof agentInfoSchema>;
+/**
+ * Who is driving a handoff session right now: the desktop's native UI, this
+ * host on behalf of a device, or nobody (either side can continue).
+ */
+export declare const sessionDriverSchema: z.ZodEnum<["desktop", "remote", "none"]>;
+export type SessionDriver = z.infer<typeof sessionDriverSchema>;
+export declare const sessionStateSchema: z.ZodEnum<["idle", "running", "waiting", "error", "offline"]>;
+export type SessionState = z.infer<typeof sessionStateSchema>;
+export declare const toolKindSchema: z.ZodEnum<["read", "edit", "delete", "move", "search", "execute", "think", "fetch", "other"]>;
+export type ToolKind = z.infer<typeof toolKindSchema>;
+export declare const permissionOptionSchema: z.ZodObject<{
+    optionId: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<["allow_once", "allow_always", "reject_once", "reject_always"]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+    optionId: string;
+}, {
+    name: string;
+    kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+    optionId: string;
+}>;
+export type PermissionOption = z.infer<typeof permissionOptionSchema>;
+/** What a running session is doing right now, for list rows. Live only. */
+export declare const sessionActivitySchema: z.ZodObject<{
+    kind: z.ZodEnum<["thinking", "responding", "tool"]>;
+    title: z.ZodOptional<z.ZodString>;
+    toolKind: z.ZodOptional<z.ZodEnum<["read", "edit", "delete", "move", "search", "execute", "think", "fetch", "other"]>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "thinking" | "tool" | "responding";
+    title?: string | undefined;
+    toolKind?: "search" | "other" | "read" | "edit" | "delete" | "move" | "execute" | "think" | "fetch" | undefined;
+}, {
+    kind: "thinking" | "tool" | "responding";
+    title?: string | undefined;
+    toolKind?: "search" | "other" | "read" | "edit" | "delete" | "move" | "execute" | "think" | "fetch" | undefined;
+}>;
+export type SessionActivity = z.infer<typeof sessionActivitySchema>;
+/** The oldest unanswered permission request, so lists can offer approval inline. Live only. */
+export declare const pendingPermissionSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+    options: z.ZodArray<z.ZodObject<{
+        optionId: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<["allow_once", "allow_always", "reject_once", "reject_always"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+        optionId: string;
+    }, {
+        name: string;
+        kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+        optionId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        name: string;
+        kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+        optionId: string;
+    }[];
+    requestId: string;
+    title: string;
+    detail?: string | undefined;
+    toolCallId?: string | undefined;
+}, {
+    options: {
+        name: string;
+        kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+        optionId: string;
+    }[];
+    requestId: string;
+    title: string;
+    detail?: string | undefined;
+    toolCallId?: string | undefined;
+}>;
+export type PendingPermissionSummary = z.infer<typeof pendingPermissionSchema>;
+export declare const sessionSummarySchema: z.ZodObject<{
+    /** `${agent}:${nativeId}` — stable across daemon restarts and rediscovery. */
+    id: z.ZodString;
+    agent: z.ZodString;
+    nativeId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    preview: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodString;
+    state: z.ZodEnum<["idle", "running", "waiting", "error", "offline"]>;
+    driver: z.ZodOptional<z.ZodEnum<["desktop", "remote", "none"]>>;
+    pendingPermissions: z.ZodNumber;
+    model: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    lastSeq: z.ZodNumber;
+    archived: z.ZodBoolean;
+    activity: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<["thinking", "responding", "tool"]>;
+        title: z.ZodOptional<z.ZodString>;
+        toolKind: z.ZodOptional<z.ZodEnum<["read", "edit", "delete", "move", "search", "execute", "think", "fetch", "other"]>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "thinking" | "tool" | "responding";
+        title?: string | undefined;
+        toolKind?: "search" | "other" | "read" | "edit" | "delete" | "move" | "execute" | "think" | "fetch" | undefined;
+    }, {
+        kind: "thinking" | "tool" | "responding";
+        title?: string | undefined;
+        toolKind?: "search" | "other" | "read" | "edit" | "delete" | "move" | "execute" | "think" | "fetch" | undefined;
+    }>>;
+    permission: z.ZodOptional<z.ZodObject<{
+        requestId: z.ZodString;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        options: z.ZodArray<z.ZodObject<{
+            optionId: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<["allow_once", "allow_always", "reject_once", "reject_always"]>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+            optionId: string;
+        }, {
+            name: string;
+            kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+            optionId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        options: {
+            name: string;
+            kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+            optionId: string;
+        }[];
+        requestId: string;
+        title: string;
+        detail?: string | undefined;
+        toolCallId?: string | undefined;
+    }, {
+        options: {
+            name: string;
+            kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+            optionId: string;
+        }[];
+        requestId: string;
+        title: string;
+        detail?: string | undefined;
+        toolCallId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    cwd: string;
+    createdAt: number;
+    pendingPermissions: number;
+    updatedAt: number;
+    archived: boolean;
+    state: "idle" | "error" | "running" | "waiting" | "offline";
+    agent: string;
+    nativeId: string;
+    lastSeq: number;
+    title?: string | undefined;
+    model?: string | undefined;
+    permission?: {
+        options: {
+            name: string;
+            kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+            optionId: string;
+        }[];
+        requestId: string;
+        title: string;
+        detail?: string | undefined;
+        toolCallId?: string | undefined;
+    } | undefined;
+    preview?: string | undefined;
+    driver?: "none" | "desktop" | "remote" | undefined;
+    activity?: {
+        kind: "thinking" | "tool" | "responding";
+        title?: string | undefined;
+        toolKind?: "search" | "other" | "read" | "edit" | "delete" | "move" | "execute" | "think" | "fetch" | undefined;
+    } | undefined;
+}, {
+    id: string;
+    cwd: string;
+    createdAt: number;
+    pendingPermissions: number;
+    updatedAt: number;
+    archived: boolean;
+    state: "idle" | "error" | "running" | "waiting" | "offline";
+    agent: string;
+    nativeId: string;
+    lastSeq: number;
+    title?: string | undefined;
+    model?: string | undefined;
+    permission?: {
+        options: {
+            name: string;
+            kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+            optionId: string;
+        }[];
+        requestId: string;
+        title: string;
+        detail?: string | undefined;
+        toolCallId?: string | undefined;
+    } | undefined;
+    preview?: string | undefined;
+    driver?: "none" | "desktop" | "remote" | undefined;
+    activity?: {
+        kind: "thinking" | "tool" | "responding";
+        title?: string | undefined;
+        toolKind?: "search" | "other" | "read" | "edit" | "delete" | "move" | "execute" | "think" | "fetch" | undefined;
+    } | undefined;
+}>;
+export type SessionSummary = z.infer<typeof sessionSummarySchema>;
+export declare function sessionIdFor(agent: string, nativeId: string): string;
+export declare function parseSessionId(id: string): {
+    agent: string;
+    nativeId: string;
+} | null;
+export declare const projectSummarySchema: z.ZodObject<{
+    cwd: z.ZodString;
+    name: z.ZodString;
+    lastActiveAt: z.ZodNumber;
+    sessionCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    cwd: string;
+    name: string;
+    lastActiveAt: number;
+    sessionCount: number;
+}, {
+    cwd: string;
+    name: string;
+    lastActiveAt: number;
+    sessionCount: number;
+}>;
+export type ProjectSummary = z.infer<typeof projectSummarySchema>;
+export declare const machineInfoSchema: z.ZodObject<{
+    machineId: z.ZodString;
+    hostname: z.ZodString;
+    platform: z.ZodString;
+    hostVersion: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        tier: z.ZodEnum<["multi_client", "handoff", "remote", "terminal"]>;
+        installed: z.ZodBoolean;
+        version: z.ZodOptional<z.ZodString>;
+        /** Human-readable reason when the agent is installed but unusable. */
+        problem: z.ZodOptional<z.ZodString>;
+        auth: z.ZodOptional<z.ZodObject<{
+            state: z.ZodEnum<["ok", "missing", "unknown"]>;
+            /** e.g. "claude.ai", "api_key", "oauth_token", "chatgpt", "bedrock". */
+            method: z.ZodOptional<z.ZodString>;
+            /** What the user should do when state is "missing". */
+            hint: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            state: "unknown" | "ok" | "missing";
+            method?: string | undefined;
+            hint?: string | undefined;
+        }, {
+            state: "unknown" | "ok" | "missing";
+            method?: string | undefined;
+            hint?: string | undefined;
+        }>>;
+        capabilities: z.ZodObject<{
+            interrupt: z.ZodBoolean;
+            /** Inject a message into a running turn instead of queueing it. */
+            steer: z.ZodBoolean;
+            permissions: z.ZodBoolean;
+            images: z.ZodBoolean;
+            fork: z.ZodBoolean;
+            models: z.ZodBoolean;
+            modes: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            models: boolean;
+            modes: boolean;
+            steer: boolean;
+            images: boolean;
+            fork: boolean;
+            permissions: boolean;
+            interrupt: boolean;
+        }, {
+            models: boolean;
+            modes: boolean;
+            steer: boolean;
+            images: boolean;
+            fork: boolean;
+            permissions: boolean;
+            interrupt: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        capabilities: {
+            models: boolean;
+            modes: boolean;
+            steer: boolean;
+            images: boolean;
+            fork: boolean;
+            permissions: boolean;
+            interrupt: boolean;
+        };
+        tier: "multi_client" | "handoff" | "remote" | "terminal";
+        installed: boolean;
+        auth?: {
+            state: "unknown" | "ok" | "missing";
+            method?: string | undefined;
+            hint?: string | undefined;
+        } | undefined;
+        version?: string | undefined;
+        problem?: string | undefined;
+    }, {
+        id: string;
+        label: string;
+        capabilities: {
+            models: boolean;
+            modes: boolean;
+            steer: boolean;
+            images: boolean;
+            fork: boolean;
+            permissions: boolean;
+            interrupt: boolean;
+        };
+        tier: "multi_client" | "handoff" | "remote" | "terminal";
+        installed: boolean;
+        auth?: {
+            state: "unknown" | "ok" | "missing";
+            method?: string | undefined;
+            hint?: string | undefined;
+        } | undefined;
+        version?: string | undefined;
+        problem?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    machineId: string;
+    hostname: string;
+    platform: string;
+    agents: {
+        id: string;
+        label: string;
+        capabilities: {
+            models: boolean;
+            modes: boolean;
+            steer: boolean;
+            images: boolean;
+            fork: boolean;
+            permissions: boolean;
+            interrupt: boolean;
+        };
+        tier: "multi_client" | "handoff" | "remote" | "terminal";
+        installed: boolean;
+        auth?: {
+            state: "unknown" | "ok" | "missing";
+            method?: string | undefined;
+            hint?: string | undefined;
+        } | undefined;
+        version?: string | undefined;
+        problem?: string | undefined;
+    }[];
+    hostVersion: string;
+}, {
+    machineId: string;
+    hostname: string;
+    platform: string;
+    agents: {
+        id: string;
+        label: string;
+        capabilities: {
+            models: boolean;
+            modes: boolean;
+            steer: boolean;
+            images: boolean;
+            fork: boolean;
+            permissions: boolean;
+            interrupt: boolean;
+        };
+        tier: "multi_client" | "handoff" | "remote" | "terminal";
+        installed: boolean;
+        auth?: {
+            state: "unknown" | "ok" | "missing";
+            method?: string | undefined;
+            hint?: string | undefined;
+        } | undefined;
+        version?: string | undefined;
+        problem?: string | undefined;
+    }[];
+    hostVersion: string;
+}>;
+export type MachineInfo = z.infer<typeof machineInfoSchema>;
+/** A server listening on the host, which a device can preview through the encrypted channel. */
+export declare const portInfoSchema: z.ZodObject<{
+    port: z.ZodNumber;
+    /** The listening process ("node", "python3.12"). */
+    process: z.ZodString;
+    pid: z.ZodOptional<z.ZodNumber>;
+    /** The process's working directory: which project the server belongs to. */
+    cwd: z.ZodOptional<z.ZodString>;
+    /** The page title, when the port answers HTTP with an HTML page. */
+    title: z.ZodOptional<z.ZodString>;
+    /** Answers HTTP at all (a dev server, not a database). */
+    http: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    process: string;
+    http: boolean;
+    cwd?: string | undefined;
+    title?: string | undefined;
+    pid?: number | undefined;
+}, {
+    port: number;
+    process: string;
+    http: boolean;
+    cwd?: string | undefined;
+    title?: string | undefined;
+    pid?: number | undefined;
+}>;
+export type PortInfo = z.infer<typeof portInfoSchema>;
+/** A shell the host keeps open, independent of any device connection. */
+export declare const terminalInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** What's running in the foreground (the shell or its current command). */
+    title: z.ZodString;
+    cwd: z.ZodString;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    /** Last output time. */
+    activeAt: z.ZodNumber;
+    /** The command it was started to run, if any (else it's a plain shell). */
+    command: z.ZodOptional<z.ZodString>;
+    /** Set once the shell ended; the terminal and its output stay until deleted. */
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    /** Ended without an exit code: the host stopped while it ran. */
+    interrupted: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    cols: number;
+    rows: number;
+    cwd: string;
+    createdAt: number;
+    title: string;
+    activeAt: number;
+    exitCode?: number | null | undefined;
+    command?: string | undefined;
+    interrupted?: boolean | undefined;
+}, {
+    id: string;
+    cols: number;
+    rows: number;
+    cwd: string;
+    createdAt: number;
+    title: string;
+    activeAt: number;
+    exitCode?: number | null | undefined;
+    command?: string | undefined;
+    interrupted?: boolean | undefined;
+}>;
+export type TerminalInfo = z.infer<typeof terminalInfoSchema>;
+/** The host's link to a v2 gateway, for `linkshell status` and the app's computer page. */
+export declare const gatewayStatusSchema: z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["off", "connecting", "online", "offline"]>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>>;
+    machine: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+    }, {
+        id: string;
+        name: string;
+    }>>;
+    account: z.ZodOptional<z.ZodObject<{
+        userId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        email?: string | undefined;
+    }, {
+        userId: string;
+        email?: string | undefined;
+    }>>;
+    devices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        pairedAt: z.ZodNumber;
+        online: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        online: boolean;
+        pairedAt: number;
+    }, {
+        id: string;
+        name: string;
+        online: boolean;
+        pairedAt: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: "connecting" | "off" | "offline" | "online";
+    devices: {
+        id: string;
+        name: string;
+        online: boolean;
+        pairedAt: number;
+    }[];
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    url?: string | undefined;
+    machine?: {
+        id: string;
+        name: string;
+    } | undefined;
+    account?: {
+        userId: string;
+        email?: string | undefined;
+    } | undefined;
+}, {
+    status: "connecting" | "off" | "offline" | "online";
+    devices: {
+        id: string;
+        name: string;
+        online: boolean;
+        pairedAt: number;
+    }[];
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    url?: string | undefined;
+    machine?: {
+        id: string;
+        name: string;
+    } | undefined;
+    account?: {
+        userId: string;
+        email?: string | undefined;
+    } | undefined;
+}>;
+export type GatewayStatus = z.infer<typeof gatewayStatusSchema>;