@otto-code/cli 0.8.10 → 0.8.13

package/dist/utils/client.js

@@ -141,7 +141,10 @@ function stripIpcPrefix(trimmed) {
     return trimmed;
 }
 export function resolveDaemonTarget(host) {
-    const trimmed = host.trim();
+    const trimmed = normalizeDaemonHost(host);
+    if (!trimmed) {
+        throw new Error(`Invalid daemon target: ${host}`);
+    }
     if (trimmed.startsWith("unix://") ||
         trimmed.startsWith("pipe://") ||
         trimmed.startsWith("\\\\.\\pipe\\")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/cli",
-  "version": "0.8.10",
+  "version": "0.8.13",
   "description": "Otto CLI - control your AI coding agents from the command line",
   "license": "AGPL-3.0-or-later",
   "bin": {
@@ -29,10 +29,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@otto-code/brain": "0.8.10",
-    "@otto-code/client": "0.8.10",
-    "@otto-code/protocol": "0.8.10",
-    "@otto-code/server": "0.8.10",
+    "@otto-code/brain": "0.8.13",
+    "@otto-code/client": "0.8.13",
+    "@otto-code/protocol": "0.8.13",
+    "@otto-code/server": "0.8.13",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",

package/dist/commands/chat/create.d.ts

@@ -1,9 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export interface ChatCreateOptions extends ChatCommandOptions {
-    purpose?: string;
-}
-export declare function runCreateCommand(name: string, options: ChatCreateOptions, _command: Command): Promise<SingleResult<ChatRoomRow>>;
-//# sourceMappingURL=create.d.ts.map

package/dist/commands/chat/create.js

@@ -1,23 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runCreateCommand(name, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.createChatRoom({
-            name,
-            purpose: options.purpose,
-        });
-        return {
-            type: "single",
-            data: toChatRoomRow(payload.room),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_CREATE_FAILED", "create chat room", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=create.js.map

package/dist/commands/chat/delete.d.ts

@@ -1,6 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export declare function runDeleteCommand(room: string, options: ChatCommandOptions, _command: Command): Promise<SingleResult<ChatRoomRow>>;
-//# sourceMappingURL=delete.d.ts.map

package/dist/commands/chat/delete.js

@@ -1,20 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runDeleteCommand(room, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.deleteChatRoom({ room });
-        return {
-            type: "single",
-            data: toChatRoomRow(payload.room),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_DELETE_FAILED", "delete chat room", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=delete.js.map

package/dist/commands/chat/index.d.ts

@@ -1,3 +0,0 @@
-import { Command } from "commander";
-export declare function createChatCommand(): Command;
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/chat/index.js

@@ -1,47 +0,0 @@
-import { Command } from "commander";
-import { withOutput } from "../../output/index.js";
-import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
-import { runCreateCommand } from "./create.js";
-import { runLsCommand } from "./ls.js";
-import { runInspectCommand } from "./inspect.js";
-import { runDeleteCommand } from "./delete.js";
-import { runPostCommand } from "./post.js";
-import { runReadCommand } from "./read.js";
-import { runWaitCommand } from "./wait.js";
-export function createChatCommand() {
-    const chat = new Command("chat").description("Manage chat rooms for agent coordination");
-    addJsonAndDaemonHostOptions(chat
-        .command("create")
-        .description("Create a chat room")
-        .argument("<name>", "Room name (must be unique)")
-        .option("--purpose <text>", "Room purpose/description")).action(withOutput(runCreateCommand));
-    addJsonAndDaemonHostOptions(chat.command("ls").description("List chat rooms")).action(withOutput(runLsCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("inspect")
-        .description("Inspect a chat room")
-        .argument("<name-or-id>", "Room name or ID")).action(withOutput(runInspectCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("delete")
-        .description("Delete a chat room")
-        .argument("<name-or-id>", "Room name or ID")).action(withOutput(runDeleteCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("post")
-        .description("Post a chat message")
-        .argument("<name-or-id>", "Room name or ID")
-        .argument("<message>", "Message body")
-        .option("--reply-to <msg-id>", "Reply to a specific message ID")).action(withOutput(runPostCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("read")
-        .description("Read chat messages")
-        .argument("<name-or-id>", "Room name or ID")
-        .option("--limit <n>", "Maximum number of messages to return")
-        .option("--since <duration-or-timestamp>", "Filter by relative duration or ISO timestamp")
-        .option("--agent <agent-id>", "Filter by author agent ID")).action(withOutput(runReadCommand));
-    addJsonAndDaemonHostOptions(chat
-        .command("wait")
-        .description("Wait for new chat messages")
-        .argument("<name-or-id>", "Room name or ID")
-        .option("--timeout <duration>", "Maximum wait time")).action(withOutput(runWaitCommand));
-    return chat;
-}
-//# sourceMappingURL=index.js.map

package/dist/commands/chat/inspect.d.ts

@@ -1,6 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export declare function runInspectCommand(room: string, options: ChatCommandOptions, _command: Command): Promise<SingleResult<ChatRoomRow>>;
-//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/chat/inspect.js

@@ -1,20 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runInspectCommand(room, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.inspectChatRoom({ room });
-        return {
-            type: "single",
-            data: toChatRoomRow(payload.room),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_INSPECT_FAILED", "inspect chat room", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=inspect.js.map

package/dist/commands/chat/ls.d.ts

@@ -1,6 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatRoomRow } from "./schema.js";
-export declare function runLsCommand(options: ChatCommandOptions, _command: Command): Promise<ListResult<ChatRoomRow>>;
-//# sourceMappingURL=ls.d.ts.map

package/dist/commands/chat/ls.js

@@ -1,20 +0,0 @@
-import { connectChatClient, toChatCommandError } from "./shared.js";
-import { chatRoomSchema, toChatRoomRow } from "./schema.js";
-export async function runLsCommand(options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.listChatRooms();
-        return {
-            type: "list",
-            data: payload.rooms.map(toChatRoomRow),
-            schema: chatRoomSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_LIST_FAILED", "list chat rooms", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=ls.js.map

package/dist/commands/chat/post.d.ts

@@ -1,9 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatMessageRow } from "./schema.js";
-export interface ChatPostOptions extends ChatCommandOptions {
-    replyTo?: string;
-}
-export declare function runPostCommand(room: string, body: string, options: ChatPostOptions, _command: Command): Promise<SingleResult<ChatMessageRow>>;
-//# sourceMappingURL=post.d.ts.map

package/dist/commands/chat/post.js

@@ -1,28 +0,0 @@
-import { attachAgentNamesToMessages, connectChatClient, resolveChatAuthorAgentId, toChatCommandError, } from "./shared.js";
-import { chatMessageSchema, toChatMessageRow } from "./schema.js";
-export async function runPostCommand(room, body, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.postChatMessage({
-            room,
-            body,
-            authorAgentId: resolveChatAuthorAgentId(),
-            replyToMessageId: options.replyTo,
-        });
-        const [message] = await attachAgentNamesToMessages(client, [
-            toChatMessageRow(payload.message),
-        ]);
-        return {
-            type: "single",
-            data: message,
-            schema: chatMessageSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_POST_FAILED", "post chat message", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=post.js.map

package/dist/commands/chat/read.d.ts

@@ -1,11 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatMessageRow } from "./schema.js";
-export interface ChatReadOptions extends ChatCommandOptions {
-    limit?: string;
-    since?: string;
-    agent?: string;
-}
-export declare function runReadCommand(room: string, options: ChatReadOptions, _command: Command): Promise<ListResult<ChatMessageRow>>;
-//# sourceMappingURL=read.d.ts.map

package/dist/commands/chat/read.js

@@ -1,40 +0,0 @@
-import { attachAgentNamesToMessages, connectChatClient, parseSinceValue, toChatCommandError, } from "./shared.js";
-import { chatMessageSchema, toChatMessageRow } from "./schema.js";
-function parseLimit(value) {
-    if (!value) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isInteger(parsed) || parsed < 0) {
-        throw {
-            code: "INVALID_LIMIT",
-            message: "Invalid --limit value",
-            details: "Use a non-negative integer.",
-        };
-    }
-    return parsed;
-}
-export async function runReadCommand(room, options, _command) {
-    const { client } = await connectChatClient(options.host);
-    try {
-        const payload = await client.readChatMessages({
-            room,
-            limit: parseLimit(options.limit),
-            since: parseSinceValue(options.since),
-            authorAgentId: options.agent,
-        });
-        const messages = await attachAgentNamesToMessages(client, payload.messages.map(toChatMessageRow));
-        return {
-            type: "list",
-            data: messages,
-            schema: chatMessageSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_READ_FAILED", "read chat messages", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=read.js.map

package/dist/commands/chat/schema.d.ts

@@ -1,36 +0,0 @@
-import type { OutputSchema } from "../../output/index.js";
-export interface ChatRoomRow {
-    name: string;
-    id: string;
-    purpose: string;
-    messages: number;
-    lastMessageAt: string;
-}
-export interface ChatMessageRow {
-    id: string;
-    author: string;
-    authorName: string | null;
-    createdAt: string;
-    replyTo: string;
-    mentionAgentIds: string[];
-    mentionLabels: string[];
-    body: string;
-}
-export declare const chatRoomSchema: OutputSchema<ChatRoomRow>;
-export declare const chatMessageSchema: OutputSchema<ChatMessageRow>;
-export declare function toChatRoomRow(room: {
-    id: string;
-    name: string;
-    purpose: string | null;
-    messageCount: number;
-    lastMessageAt: string | null;
-}): ChatRoomRow;
-export declare function toChatMessageRow(message: {
-    id: string;
-    authorAgentId: string;
-    createdAt: string;
-    replyToMessageId: string | null;
-    mentionAgentIds: string[];
-    body: string;
-}): ChatMessageRow;
-//# sourceMappingURL=schema.d.ts.map

package/dist/commands/chat/schema.js

@@ -1,81 +0,0 @@
-export const chatRoomSchema = {
-    idField: "id",
-    columns: [
-        { header: "NAME", field: "name", width: 22 },
-        { header: "ID", field: "id", width: 36 },
-        { header: "PURPOSE", field: "purpose", width: 30 },
-        { header: "MESSAGES", field: "messages", width: 10, align: "right" },
-        { header: "LAST MESSAGE", field: "lastMessageAt", width: 24 },
-    ],
-};
-export const chatMessageSchema = {
-    idField: "id",
-    columns: [
-        { header: "ID", field: "id", width: 36 },
-        { header: "AUTHOR", field: "author", width: 16 },
-        { header: "AUTHOR NAME", field: (row) => row.authorName ?? "-", width: 20 },
-        { header: "CREATED", field: "createdAt", width: 24 },
-        { header: "REPLY TO", field: "replyTo", width: 36 },
-        { header: "MENTIONS", field: (row) => row.mentionLabels.join(", ") || "-", width: 24 },
-        { header: "MESSAGE", field: "body", width: 60 },
-    ],
-    renderHuman: renderChatTranscript,
-};
-function renderChatTranscript(result, _options) {
-    const data = result.type === "list" ? result.data : [result.data];
-    if (data.length === 0) {
-        return "";
-    }
-    return data.map(renderChatMessageBlock).join("\n\n");
-}
-function renderChatMessageBlock(message) {
-    const authorLabel = message.authorName
-        ? `${message.authorName} (${message.author})`
-        : message.author;
-    const lines = [
-        `┌─ ${authorLabel} ── ${formatTimestamp(message.createdAt)} ── [msg ${message.id}]`,
-    ];
-    if (message.replyTo !== "-") {
-        lines.push(`│  reply-to: msg ${message.replyTo}`);
-    }
-    if (message.mentionLabels.length > 0) {
-        lines.push(`│  mentions: ${message.mentionLabels.join(", ")}`);
-    }
-    lines.push("│");
-    const bodyLines = message.body.split(/\r?\n/);
-    for (const line of bodyLines) {
-        lines.push(`│  ${line}`);
-    }
-    lines.push("│");
-    lines.push("└─");
-    return lines.join("\n");
-}
-function formatTimestamp(input) {
-    const date = new Date(input);
-    if (Number.isNaN(date.getTime())) {
-        return input;
-    }
-    return date.toISOString().replace("T", " ").replace(".000Z", "Z");
-}
-export function toChatRoomRow(room) {
-    return {
-        id: room.id,
-        name: room.name,
-        purpose: room.purpose ?? "-",
-        messages: room.messageCount,
-        lastMessageAt: room.lastMessageAt ?? "-",
-    };
-}
-export function toChatMessageRow(message) {
-    return {
-        id: message.id,
-        author: message.authorAgentId,
-        authorName: null,
-        createdAt: message.createdAt,
-        replyTo: message.replyToMessageId ?? "-",
-        mentionAgentIds: message.mentionAgentIds,
-        mentionLabels: message.mentionAgentIds,
-        body: message.body,
-    };
-}
-//# sourceMappingURL=schema.js.map

package/dist/commands/chat/shared.d.ts

@@ -1,19 +0,0 @@
-import { connectToDaemon } from "../../utils/client.js";
-import type { CommandError, CommandOptions } from "../../output/index.js";
-import type { ChatMessageRow } from "./schema.js";
-export interface ChatCommandOptions extends CommandOptions {
-    host?: string;
-}
-export declare function connectChatClient(host?: string): Promise<{
-    client: import("@otto-code/client/internal/daemon-client").DaemonClient;
-    daemonHost: string;
-}>;
-export declare function attachAgentNamesToMessages(client: Awaited<ReturnType<typeof connectToDaemon>>, messages: ChatMessageRow[], options?: {
-    timeout?: number;
-    bestEffort?: boolean;
-}): Promise<ChatMessageRow[]>;
-export declare function toChatCommandError(code: string, action: string, err: unknown): CommandError;
-export declare function parseSinceValue(input?: string): string | undefined;
-export declare function parseTimeoutMs(input?: string): number | undefined;
-export declare function resolveChatAuthorAgentId(): string;
-//# sourceMappingURL=shared.d.ts.map

package/dist/commands/chat/shared.js

@@ -1,118 +0,0 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import { parseDuration } from "../../utils/duration.js";
-export async function connectChatClient(host) {
-    const daemonHost = getDaemonHost({ host });
-    try {
-        const client = await connectToDaemon({ host });
-        return { client, daemonHost };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
-            details: "Start the daemon with: otto daemon start",
-        };
-        throw error;
-    }
-}
-export async function attachAgentNamesToMessages(client, messages, options = {}) {
-    const agentIds = new Set();
-    for (const message of messages) {
-        agentIds.add(message.author);
-        for (const mentionId of message.mentionAgentIds) {
-            agentIds.add(mentionId);
-        }
-    }
-    if (agentIds.size === 0) {
-        return messages;
-    }
-    let payload;
-    try {
-        payload = await client.fetchAgents({
-            filter: { includeArchived: true },
-            ...(typeof options.timeout === "number" ? { timeout: options.timeout } : {}),
-        });
-    }
-    catch (error) {
-        if (options.bestEffort) {
-            return messages;
-        }
-        throw error;
-    }
-    const agentNames = new Map();
-    for (const entry of payload.entries) {
-        const title = entry.agent.title?.trim();
-        if (title) {
-            agentNames.set(entry.agent.id, title);
-        }
-    }
-    return messages.map((message) => ({
-        ...message,
-        authorName: agentNames.get(message.author) ?? null,
-        mentionLabels: message.mentionAgentIds.map((agentId) => {
-            const name = agentNames.get(agentId);
-            return name ? `${name} (${agentId})` : agentId;
-        }),
-    }));
-}
-export function toChatCommandError(code, action, err) {
-    if (err && typeof err === "object" && "code" in err && "message" in err) {
-        return err;
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    const rpcCode = typeof err === "object" && err !== null && "code" in err && typeof err.code === "string"
-        ? err.code
-        : undefined;
-    return {
-        code: rpcCode ?? code,
-        message: `Failed to ${action}: ${message}`,
-    };
-}
-export function parseSinceValue(input) {
-    if (!input) {
-        return undefined;
-    }
-    try {
-        const durationMs = parseDuration(input);
-        return new Date(Date.now() - durationMs).toISOString();
-    }
-    catch {
-        const timestamp = new Date(input);
-        if (Number.isNaN(timestamp.getTime())) {
-            const error = {
-                code: "INVALID_SINCE",
-                message: "Invalid --since value",
-                details: "Use a duration like 10m or an ISO timestamp.",
-            };
-            throw error;
-        }
-        return timestamp.toISOString();
-    }
-}
-export function parseTimeoutMs(input) {
-    if (!input) {
-        return undefined;
-    }
-    try {
-        const timeoutMs = parseDuration(input);
-        if (timeoutMs <= 0) {
-            throw new Error("Timeout must be positive");
-        }
-        return timeoutMs;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "INVALID_TIMEOUT",
-            message: "Invalid timeout value",
-            details: message,
-        };
-        throw error;
-    }
-}
-export function resolveChatAuthorAgentId() {
-    const agentId = process.env.OTTO_AGENT_ID?.trim();
-    return agentId && agentId.length > 0 ? agentId : "manual";
-}
-//# sourceMappingURL=shared.js.map

package/dist/commands/chat/wait.d.ts

@@ -1,9 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatMessageRow } from "./schema.js";
-export interface ChatWaitOptions extends ChatCommandOptions {
-    timeout?: string;
-}
-export declare function runWaitCommand(room: string, options: ChatWaitOptions, _command: Command): Promise<ListResult<ChatMessageRow>>;
-//# sourceMappingURL=wait.d.ts.map

package/dist/commands/chat/wait.js

@@ -1,45 +0,0 @@
-import { attachAgentNamesToMessages, connectChatClient, parseTimeoutMs, toChatCommandError, } from "./shared.js";
-import { chatMessageSchema, toChatMessageRow } from "./schema.js";
-const CHAT_WAIT_PREFLIGHT_TIMEOUT_MS = 2000;
-export async function runWaitCommand(room, options, _command) {
-    const timeoutMs = parseTimeoutMs(options.timeout);
-    const { client } = await connectChatClient(options.host);
-    const deadline = typeof timeoutMs === "number" ? Date.now() + timeoutMs : null;
-    const hasExplicitTimeout = deadline !== null;
-    const remainingTimeoutMs = () => deadline === null ? undefined : Math.max(1, deadline - Date.now());
-    try {
-        const latest = await client.readChatMessages({
-            room,
-            limit: 1,
-            ...(hasExplicitTimeout
-                ? {
-                    timeout: Math.min(remainingTimeoutMs() ?? 1, CHAT_WAIT_PREFLIGHT_TIMEOUT_MS),
-                }
-                : {}),
-        });
-        const afterMessageId = latest.messages[0]?.id;
-        const payload = await client.waitForChatMessages({
-            room,
-            afterMessageId,
-            timeoutMs: remainingTimeoutMs() ?? timeoutMs,
-        });
-        const messages = await attachAgentNamesToMessages(client, payload.messages.map(toChatMessageRow), hasExplicitTimeout
-            ? {
-                timeout: remainingTimeoutMs(),
-                bestEffort: true,
-            }
-            : {});
-        return {
-            type: "list",
-            data: messages,
-            schema: chatMessageSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_WAIT_FAILED", "wait for chat messages", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=wait.js.map

package/dist/commands/hub/cloud-device-authorization.d.ts

@@ -1,45 +0,0 @@
-import { z } from "zod";
-declare const authorizationSchema: z.ZodObject<{
-    deviceCode: z.ZodString;
-    userCode: z.ZodString;
-    verificationUri: z.ZodURL;
-    verificationUriComplete: z.ZodURL;
-    expiresAt: z.ZodString;
-    interval: z.ZodNumber;
-}, z.core.$strip>;
-declare const pollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    status: z.ZodLiteral<"pending">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"slow_down">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"approved">;
-    interval: z.ZodNumber;
-    enrollmentToken: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"denied">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"expired">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"enrolled">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"retry_later">;
-}, z.core.$strip>], "status">;
-export type DeviceAuthorization = z.infer<typeof authorizationSchema>;
-export type DeviceAuthorizationPoll = z.infer<typeof pollSchema>;
-export interface CloudDeviceAuthorization {
-    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
-    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
-}
-export declare class CloudDeviceAuthorizationClient implements CloudDeviceAuthorization {
-    private readonly startTimeoutMilliseconds;
-    constructor(startTimeoutMilliseconds?: number);
-    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
-    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
-}
-export {};
-//# sourceMappingURL=cloud-device-authorization.d.ts.map