google-stitch-mcp 0.3.2

package/dist/services/project/spec.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export declare const SelectProjectInputSchema: z.ZodObject<{
+    allowSearch: z.ZodDefault<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    allowSearch: boolean;
+}, {
+    limit?: number | undefined;
+    allowSearch?: boolean | undefined;
+}>;
+export type SelectProjectInput = z.infer<typeof SelectProjectInputSchema>;
+export declare const ProjectErrorCode: z.ZodEnum<["NO_PROJECTS_FOUND", "SELECTION_CANCELLED", "SEARCH_FAILED", "PROJECT_FETCH_FAILED", "PROJECT_NOT_FOUND", "UNKNOWN_ERROR"]>;
+export declare const ProjectSelectionSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        projectId: z.ZodString;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        projectId: string;
+    }, {
+        name: string;
+        projectId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        name: string;
+        projectId: string;
+    };
+}, {
+    success: true;
+    data: {
+        name: string;
+        projectId: string;
+    };
+}>;
+export declare const ProjectSelectionFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["NO_PROJECTS_FOUND", "SELECTION_CANCELLED", "SEARCH_FAILED", "PROJECT_FETCH_FAILED", "PROJECT_NOT_FOUND", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type ProjectSelectionResult = z.infer<typeof ProjectSelectionSuccess> | z.infer<typeof ProjectSelectionFailure>;
+export interface ProjectService {
+    /**
+     * Prompt user to select a project
+     */
+    selectProject(input: SelectProjectInput): Promise<ProjectSelectionResult>;
+    /**
+     * Get details for a specific project
+     */
+    getProjectDetails(input: {
+        projectId: string;
+    }): Promise<ProjectSelectionResult>;
+}

package/dist/services/proxy/handler.d.ts

@@ -0,0 +1,26 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createWriteStream, existsSync, mkdirSync } from 'node:fs';
+import { type ProxyService, type StartProxyInput, type ProxyResult } from './spec.js';
+import { GcloudHandler } from '../gcloud/handler.js';
+import { getStitchDir } from '../../platform/detector.js';
+/**
+ * Internal dependencies for testing
+ */
+export declare const deps: {
+    createWriteStream: typeof createWriteStream;
+    existsSync: typeof existsSync;
+    mkdirSync: typeof mkdirSync;
+    getStitchDir: typeof getStitchDir;
+};
+export declare class ProxyHandler implements ProxyService {
+    private gcloud;
+    private transportFactory;
+    private currentToken;
+    private refreshTimer;
+    private pendingToolListIds;
+    constructor(gcloud?: GcloudHandler, transportFactory?: () => StdioServerTransport);
+    start(input: StartProxyInput): Promise<ProxyResult>;
+    private refreshToken;
+    private startRefreshTimer;
+    private stopRefreshTimer;
+}

package/dist/services/proxy/spec.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+export declare const StartProxyInputSchema: z.ZodObject<{
+    transport: z.ZodDefault<z.ZodEnum<["stdio", "sse"]>>;
+    port: z.ZodOptional<z.ZodNumber>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse";
+    debug?: boolean | undefined;
+    port?: number | undefined;
+}, {
+    debug?: boolean | undefined;
+    port?: number | undefined;
+    transport?: "stdio" | "sse" | undefined;
+}>;
+export type StartProxyInput = z.infer<typeof StartProxyInputSchema>;
+export declare const ProxyErrorCode: z.ZodEnum<["START_FAILED", "TRANSPORT_ERROR", "AUTH_REFRESH_FAILED", "UNKNOWN_ERROR"]>;
+export type ProxyErrorCodeType = z.infer<typeof ProxyErrorCode>;
+export declare const ProxySuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        status: z.ZodEnum<["running", "stopped"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "running" | "stopped";
+    }, {
+        status: "running" | "stopped";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        status: "running" | "stopped";
+    };
+}, {
+    success: true;
+    data: {
+        status: "running" | "stopped";
+    };
+}>;
+export declare const ProxyFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["START_FAILED", "TRANSPORT_ERROR", "AUTH_REFRESH_FAILED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type ProxyResult = z.infer<typeof ProxySuccess> | z.infer<typeof ProxyFailure>;
+export interface ProxyService {
+    /**
+     * Start the MCP proxy server
+     *
+     * @remarks
+     * This is a long-running operation. The promise settles only when the server stops
+     * or if initial startup fails.
+     */
+    start(input: StartProxyInput): Promise<ProxyResult>;
+}

package/dist/services/stitch/handler.d.ts

@@ -0,0 +1,17 @@
+import { type StitchService, type ConfigureIAMInput, type EnableAPIInput, type TestConnectionInput, type TestConnectionWithApiKeyInput, type IAMConfigResult, type APIEnableResult, type ConnectionTestResult } from './spec.js';
+export declare class StitchHandler implements StitchService {
+    private getGcloudEnv;
+    private gcloudBinaryPromise;
+    private getGcloudBinary;
+    configureIAM(input: ConfigureIAMInput): Promise<IAMConfigResult>;
+    enableAPI(input: EnableAPIInput): Promise<APIEnableResult>;
+    checkIAMRole(input: {
+        projectId: string;
+        userEmail: string;
+    }): Promise<boolean>;
+    checkAPIEnabled(input: {
+        projectId: string;
+    }): Promise<boolean>;
+    testConnectionWithApiKey(input: TestConnectionWithApiKeyInput): Promise<ConnectionTestResult>;
+    testConnection(input: TestConnectionInput): Promise<ConnectionTestResult>;
+}

package/dist/services/stitch/spec.d.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+export declare const ConfigureIAMInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    userEmail: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    userEmail: string;
+}, {
+    projectId: string;
+    userEmail: string;
+}>;
+export type ConfigureIAMInput = z.infer<typeof ConfigureIAMInputSchema>;
+export declare const EnableAPIInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+}, {
+    projectId: string;
+}>;
+export type EnableAPIInput = z.infer<typeof EnableAPIInputSchema>;
+export declare const TestConnectionInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    accessToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    accessToken: string;
+    projectId: string;
+}, {
+    accessToken: string;
+    projectId: string;
+}>;
+export type TestConnectionInput = z.infer<typeof TestConnectionInputSchema>;
+export declare const TestConnectionWithApiKeyInputSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+}, {
+    apiKey: string;
+}>;
+export type TestConnectionWithApiKeyInput = z.infer<typeof TestConnectionWithApiKeyInputSchema>;
+export declare const StitchErrorCode: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+export declare const IAMConfigSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        role: z.ZodString;
+        member: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        member: string;
+    }, {
+        role: string;
+        member: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        role: string;
+        member: string;
+    };
+}, {
+    success: true;
+    data: {
+        role: string;
+        member: string;
+    };
+}>;
+export declare const IAMConfigFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}>;
+export type IAMConfigResult = z.infer<typeof IAMConfigSuccess> | z.infer<typeof IAMConfigFailure>;
+export declare const APIEnableSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        api: z.ZodString;
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        api: string;
+        enabled: boolean;
+    }, {
+        api: string;
+        enabled: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        api: string;
+        enabled: boolean;
+    };
+}, {
+    success: true;
+    data: {
+        api: string;
+        enabled: boolean;
+    };
+}>;
+export declare const APIEnableFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}>;
+export type APIEnableResult = z.infer<typeof APIEnableSuccess> | z.infer<typeof APIEnableFailure>;
+export declare const ConnectionTestSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        connected: z.ZodBoolean;
+        statusCode: z.ZodNumber;
+        url: z.ZodString;
+        response: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    }, {
+        url: string;
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        url: string;
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    };
+}, {
+    success: true;
+    data: {
+        url: string;
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    };
+}>;
+export declare const ConnectionTestFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}>;
+export type ConnectionTestResult = z.infer<typeof ConnectionTestSuccess> | z.infer<typeof ConnectionTestFailure>;
+export interface StitchService {
+    /**
+     * Configure IAM permissions for Stitch API
+     */
+    configureIAM(input: ConfigureIAMInput): Promise<IAMConfigResult>;
+    /**
+     * Enable Stitch API for the project
+     */
+    enableAPI(input: EnableAPIInput): Promise<APIEnableResult>;
+    /**
+    * Test the connection to the Stitch API
+     */
+    testConnection(input: TestConnectionInput): Promise<ConnectionTestResult>;
+    /**
+     * Test the connection to the Stitch API using an API key
+     */
+    testConnectionWithApiKey(input: TestConnectionWithApiKeyInput): Promise<ConnectionTestResult>;
+    /**
+     * Check if a user has a specific IAM role on a project
+     */
+    checkIAMRole(input: {
+        projectId: string;
+        userEmail: string;
+    }): Promise<boolean>;
+    /**
+     * Check if the Stitch API is enabled for a project
+     */
+    checkAPIEnabled(input: {
+        projectId: string;
+    }): Promise<boolean>;
+}

package/dist/services/view/handler.d.ts

@@ -0,0 +1,7 @@
+import { type ViewSpec, type ViewInput, type ViewResult } from './spec.js';
+import { StitchMCPClient } from '../mcp-client/client.js';
+export declare class ViewHandler implements ViewSpec {
+    private client;
+    constructor(client?: StitchMCPClient);
+    execute(input: ViewInput): Promise<ViewResult>;
+}

package/dist/services/view/spec.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const ViewInputSchema: z.ZodObject<{
+    projects: z.ZodDefault<z.ZodBoolean>;
+    name: z.ZodOptional<z.ZodString>;
+    sourceScreen: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    screen: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projects: boolean;
+    name?: string | undefined;
+    sourceScreen?: string | undefined;
+    project?: string | undefined;
+    screen?: string | undefined;
+}, {
+    projects?: boolean | undefined;
+    name?: string | undefined;
+    sourceScreen?: string | undefined;
+    project?: string | undefined;
+    screen?: string | undefined;
+}>;
+export type ViewInput = z.infer<typeof ViewInputSchema>;
+export declare const ViewErrorCode: z.ZodEnum<["INVALID_ARGS", "FETCH_FAILED", "UNKNOWN_ERROR"]>;
+export declare const ViewSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data?: any;
+}, {
+    success: true;
+    data?: any;
+}>;
+export declare const ViewFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["INVALID_ARGS", "FETCH_FAILED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+    }, {
+        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+    };
+}, {
+    success: false;
+    error: {
+        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+    };
+}>;
+export type ViewResult = z.infer<typeof ViewSuccess> | z.infer<typeof ViewFailure>;
+export interface ViewSpec {
+    execute(input: ViewInput): Promise<ViewResult>;
+}

package/dist/ui/InteractiveViewer.d.ts

@@ -0,0 +1,17 @@
+export interface ViewerState {
+    data: any;
+    rootLabel?: string;
+    resourcePath?: string;
+}
+interface InteractiveViewerProps {
+    initialData: any;
+    initialRootLabel?: string;
+    /** Pre-populated navigation history (for back navigation from deep links) */
+    initialHistory?: ViewerState[];
+    /** Fetch function to load new resource data */
+    onFetch: (resourceName: string) => Promise<any>;
+    /** Called when exiting the viewer */
+    onExit?: () => void;
+}
+export declare const InteractiveViewer: ({ initialData, initialRootLabel, initialHistory, onFetch, onExit, }: InteractiveViewerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/JsonTree.d.ts

@@ -0,0 +1,12 @@
+import { type NavigationResult } from './navigation-behaviors/index.js';
+interface JsonTreeProps {
+    data: any;
+    /** Optional label for root object - when set, root is selectable for copying */
+    rootLabel?: string;
+    /** Called when user navigates into a resource (Enter on screenInstances) */
+    onNavigate?: (result: NavigationResult) => void;
+    /** Called when user wants to go back (Backspace/Delete) */
+    onBack?: () => void;
+}
+export declare const JsonTree: ({ data, rootLabel, onNavigate, onBack }: JsonTreeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/checklist/handler.d.ts

@@ -0,0 +1,23 @@
+import type { ChecklistUI, ChecklistConfig, UpdateItemInput, UpdateResult, RenderResult } from './spec.js';
+export declare class ChecklistUIHandler implements ChecklistUI {
+    private config;
+    private states;
+    private lastOutputLines;
+    initialize(config: ChecklistConfig): void;
+    updateItem(input: UpdateItemInput): UpdateResult;
+    render(): RenderResult;
+    print(options?: {
+        clearPrevious?: boolean;
+    }): void;
+    getProgress(): {
+        completed: number;
+        total: number;
+        percent: number;
+    };
+    isComplete(): boolean;
+    private getStateColor;
+}
+/**
+ * Create a new ChecklistUI instance
+ */
+export declare function createChecklistUI(): ChecklistUI;