@cjhyy/code-shell 0.1.0-alpha.0

package/dist/tool-system/permission.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Permission system — classifier + approval backend.
+ */
+import type { PermissionDecision, PermissionMode, PermissionRule, ApprovalRequest, ApprovalResult } from "../types.js";
+export interface ApprovalBackend {
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResult>;
+}
+export declare class HeadlessApprovalBackend implements ApprovalBackend {
+    private readonly mode;
+    constructor(mode: "approve-all" | "deny-all" | "approve-read-only");
+    requestApproval(req: ApprovalRequest): Promise<ApprovalResult>;
+}
+/**
+ * Auto approval backend — uses fast-path heuristics to auto-approve safe operations.
+ * Falls back to a delegate backend for uncertain cases.
+ */
+export declare class AutoApprovalBackend implements ApprovalBackend {
+    private readonly delegate?;
+    constructor(delegate?: ApprovalBackend | undefined);
+    requestApproval(req: ApprovalRequest): Promise<ApprovalResult>;
+    private isSafeOperation;
+}
+/**
+ * Interactive approval backend — prompts the user via a callback.
+ * Supports "always allow" rules that persist for the session.
+ */
+export declare class InteractiveApprovalBackend implements ApprovalBackend {
+    private sessionRules;
+    private promptFn;
+    setPromptFn(fn: (request: ApprovalRequest) => Promise<ApprovalResult>): void;
+    requestApproval(req: ApprovalRequest): Promise<ApprovalResult>;
+    private ruleKeyFromArgs;
+}
+export declare function getInteractiveApprovalBackend(): InteractiveApprovalBackend;
+export declare function setInteractiveApprovalFn(fn: (request: ApprovalRequest) => Promise<ApprovalResult>): void;
+type BashSafetyLevel = "safe-read" | "safe-write" | "unsafe" | "dangerous";
+export declare function classifyBashCommand(command: string): BashSafetyLevel;
+export declare class DenialTracker {
+    private denials;
+    private readonly periodMs;
+    private readonly maxDenials;
+    constructor(opts?: {
+        periodMs?: number;
+        maxDenials?: number;
+    });
+    record(toolName: string): void;
+    recordSuccess(toolName: string): void;
+    shouldWarn(toolName: string): boolean;
+    getWarningMessage(toolName: string): string;
+    clear(): void;
+}
+export declare function setRuntimeBypass(enabled: boolean): void;
+export declare function isRuntimeBypass(): boolean;
+export declare class PermissionClassifier {
+    private readonly rules;
+    private readonly defaultMode;
+    private readonly approvalBackend;
+    private denialTracker;
+    constructor(rules: PermissionRule[], defaultMode?: PermissionMode, approvalBackend?: ApprovalBackend);
+    classify(toolName: string, args: Record<string, unknown>): PermissionDecision;
+    handleAsk(toolName: string, args: Record<string, unknown>): Promise<boolean>;
+    /** Get denial warning message if the model keeps getting denied. */
+    getDenialWarning(toolName: string): string | undefined;
+    private matchesRule;
+    private isDangerousCommand;
+    private assessRisk;
+    private describeToolCall;
+}
+export {};

package/dist/tool-system/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Unified tool registry — built-in tools + MCP tools.
+ */
+import type { RegisteredTool, ToolDefinition, ToolResult } from "../types.js";
+import { type BuiltinToolFn } from "./builtin/index.js";
+export interface ToolRegistryOptions {
+    builtinTools?: readonly string[];
+}
+export declare class ToolRegistry {
+    private tools;
+    private builtinExecutors;
+    constructor(options?: ToolRegistryOptions);
+    private registerBuiltins;
+    registerTool(tool: RegisteredTool, executor?: BuiltinToolFn): void;
+    getToolDefinitions(): ToolDefinition[];
+    getTool(name: string): RegisteredTool | undefined;
+    hasTool(name: string): boolean;
+    executeTool(name: string, args: Record<string, unknown>, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<ToolResult>;
+    listTools(): string[];
+    listToolsDetailed(): RegisteredTool[];
+}

package/dist/tool-system/validation.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validate tool args against the tool's inputSchema.
+ * Returns null if valid, error string if invalid.
+ */
+export declare function validateToolArgs(toolName: string, args: Record<string, unknown>, schema: Record<string, unknown>): string | null;

package/dist/types.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Core type definitions for the code-shell orchestration framework.
+ */
+export interface ContentBlock {
+    type: "text" | "tool_use" | "tool_result" | "image";
+    text?: string;
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    content?: string | ContentBlock[];
+    tool_use_id?: string;
+    source?: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+}
+export interface Message {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ContentBlock[];
+    name?: string;
+    tool_call_id?: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface ToolCall {
+    id: string;
+    toolName: string;
+    serverName?: string;
+    args: Record<string, unknown>;
+}
+export interface ToolResult {
+    id: string;
+    toolName: string;
+    result?: string;
+    error?: string;
+    isError?: boolean;
+}
+export type ToolSource = "builtin" | "mcp";
+export interface RegisteredTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    source: ToolSource;
+    serverName?: string;
+    permissionDefault: PermissionDecision;
+    isConcurrencySafe?: boolean;
+    isReadOnly?: boolean;
+}
+export type TranscriptEventType = "message" | "tool_use" | "tool_result" | "summary" | "content_replace" | "file_history" | "plan_operation" | "session_meta" | "turn_boundary" | "error";
+export interface TranscriptEvent {
+    id: string;
+    type: TranscriptEventType;
+    timestamp: number;
+    turnNumber: number;
+    data: Record<string, unknown>;
+}
+export type SessionStatus = "active" | "paused" | "completed" | "errored";
+export interface SessionState {
+    sessionId: string;
+    cwd: string;
+    startedAt: number;
+    model: string;
+    provider: string;
+    tokenUsage: TokenUsage;
+    turnCount: number;
+    invokedSkills: string[];
+    parentSessionId?: string;
+    status: SessionStatus;
+    /** Short summary derived from the first user message */
+    summary?: string;
+    /** Persisted cost tracking state (survives process restart). */
+    costState?: Record<string, unknown>;
+}
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+}
+export interface CompiledInput {
+    messages: Message[];
+    rawText: string;
+    options: InputOptions;
+}
+export interface InputOptions {
+    slashCommand?: string;
+    attachments?: Attachment[];
+    mentionedFiles?: string[];
+    images?: ImageAttachment[];
+    allowedTools?: string[];
+    modelOverride?: string;
+}
+export interface Attachment {
+    path: string;
+    content: string;
+    mimeType: string;
+}
+export interface ImageAttachment {
+    data: string;
+    mediaType: string;
+}
+export type PermissionDecision = "allow" | "deny" | "ask";
+export type PermissionMode = "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
+export interface PermissionRule {
+    tool: string;
+    argsPattern?: Record<string, string | RegExp>;
+    decision: PermissionDecision;
+    reason?: string;
+}
+export interface ApprovalRequest {
+    toolName: string;
+    args: Record<string, unknown>;
+    description: string;
+    riskLevel: "low" | "medium" | "high";
+}
+export type ApprovalResult = {
+    approved: true;
+    permanent?: boolean;
+    always?: boolean;
+} | {
+    approved: false;
+    reason?: string;
+    always?: boolean;
+};
+export type TurnPhase = "pre_check" | "model_call" | "post_check" | "tool_exec" | "context_mgmt" | "hook_notify" | "complete" | "error";
+export interface TurnResult {
+    text: string;
+    toolCalls: ToolCall[];
+    status: "completed" | "tool_use" | "error" | "max_turns" | "aborted";
+    error?: string;
+}
+export type TerminalReason = "completed" | "stop_hook_prevented" | "hook_stopped" | "prompt_too_long" | "model_error" | "aborted_streaming" | "aborted_tools" | "max_turns" | "image_error";
+export interface TaskInfo {
+    id: string;
+    subject: string;
+    activeForm?: string;
+    status: "pending" | "in_progress" | "completed" | "stopped";
+}
+export type StreamEvent = {
+    type: "stream_request_start";
+    turnNumber: number;
+    agentId?: string;
+} | {
+    type: "text_delta";
+    text: string;
+    agentId?: string;
+} | {
+    type: "tool_use_start";
+    toolCall: ToolCall;
+    agentId?: string;
+} | {
+    type: "tool_result";
+    result: ToolResult;
+    agentId?: string;
+} | {
+    type: "assistant_message";
+    message: Message;
+    agentId?: string;
+} | {
+    type: "turn_complete";
+    reason: TerminalReason;
+    agentId?: string;
+} | {
+    type: "error";
+    error: string;
+    agentId?: string;
+} | {
+    type: "tombstone";
+    messageId: string;
+} | {
+    type: "task_update";
+    tasks: TaskInfo[];
+} | {
+    type: "thinking_delta";
+    text: string;
+    agentId?: string;
+} | {
+    type: "agent_start";
+    agentId: string;
+    description: string;
+} | {
+    type: "agent_end";
+    agentId: string;
+    description: string;
+    error?: string;
+} | {
+    type: "tool_summary";
+    summary: string;
+};
+export type StreamCallback = (event: StreamEvent) => void | Promise<void>;
+export interface LLMConfig {
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    timeout?: number;
+    retryMaxAttempts?: number;
+    enableStreaming?: boolean;
+}
+export interface LLMResponse {
+    text: string;
+    toolCalls: ToolCall[];
+    usage?: TokenUsage;
+    stopReason?: string;
+}
+export interface LLMStreamChunk {
+    type: "text" | "tool_use_start" | "tool_use_delta" | "tool_use_end" | "stop";
+    text?: string;
+    toolCall?: Partial<ToolCall>;
+    stopReason?: string;
+}
+export type MCPTransport = "stdio" | "sse" | "streamable-http" | "inprocess";
+export interface MCPServerConfig {
+    name: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    transport?: MCPTransport;
+    headers?: Record<string, string>;
+}
+export interface Settings {
+    model: {
+        provider: string;
+        name: string;
+        apiKey?: string;
+        baseUrl?: string;
+        temperature?: number;
+        maxTokens?: number;
+    };
+    permissions: {
+        defaultMode: PermissionMode;
+        rules: PermissionRule[];
+    };
+    context: {
+        maxTokens: number;
+        compactAtRatio: number;
+        summarizeAtRatio: number;
+    };
+    session: {
+        storageDir: string;
+        maxHistory: number;
+    };
+    mcpServers: Record<string, MCPServerConfig>;
+    instructions: {
+        fileName: string;
+        scanDirs: string[];
+    };
+    output: {
+        format: "text" | "json" | "jsonl" | "stream-json";
+    };
+}

package/dist/ui/App.d.ts

@@ -0,0 +1,14 @@
+import { AgentClient } from "../protocol/client.js";
+interface AppProps {
+    client: AgentClient;
+    model: string;
+    effort: string;
+    maxTurns: number;
+    cwd: string;
+    maxContextTokens: number;
+    sessionId?: string;
+    /** Pre-fill the input box without submitting (--prefill flag). */
+    prefill?: string;
+}
+export declare function App({ client, model: initialModel, effort, maxTurns, cwd, maxContextTokens, sessionId: initialSessionId, prefill }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/AgentBlock.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Agent block — renders sub-agent activity with CC-style tree-line nesting.
+ *
+ * Running:
+ *   ├─ Agent description · Nk tokens
+ *   │  ⎿  Running tool…
+ *
+ * Completed:
+ *   └─ Agent description · Done
+ *      ⎿  completed
+ */
+import React from "react";
+interface AgentBlockStartProps {
+    description: string;
+    running?: boolean;
+    isLast?: boolean;
+}
+export declare function AgentBlockStart({ description, running, isLast }: AgentBlockStartProps): import("react/jsx-runtime").JSX.Element;
+interface AgentBlockEndProps {
+    description: string;
+    error?: string;
+    isLast?: boolean;
+}
+export declare function AgentBlockEnd({ description, error, isLast }: AgentBlockEndProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Tree line prefix for nested content under an agent.
+ */
+export declare function NestedPrefix({ children, isLast }: {
+    children: React.ReactNode;
+    isLast?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/BabyHand.d.ts

@@ -0,0 +1 @@
+export declare function BabyHand(): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/Banner.d.ts

@@ -0,0 +1,8 @@
+interface BannerProps {
+    model: string;
+    effort: string;
+    maxTurns: number;
+    cwd: string;
+}
+export declare function Banner({ model, effort, cwd }: BannerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/CodeBlock.d.ts

@@ -0,0 +1,7 @@
+interface CodeBlockProps {
+    code: string;
+    language?: string;
+    showLineNumbers?: boolean;
+}
+export declare function CodeBlock({ code, language, showLineNumbers }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/CommandInput.d.ts

@@ -0,0 +1,13 @@
+interface CommandDef {
+    name: string;
+    description: string;
+}
+interface CommandInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    commands: CommandDef[];
+    placeholder?: string;
+}
+export declare function CommandInput({ value, onChange, onSubmit, commands, placeholder, }: CommandInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/ContextUsageBar.d.ts

@@ -0,0 +1,7 @@
+interface ContextUsageBarProps {
+    usedTokens: number;
+    maxTokens: number;
+    width?: number;
+}
+export declare function ContextUsageBar({ usedTokens, maxTokens, width }: ContextUsageBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/DiffView.d.ts

@@ -0,0 +1,6 @@
+interface DiffViewProps {
+    diff: string;
+    maxLines?: number;
+}
+export declare function DiffView({ diff, maxLines }: DiffViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/DogLogo.d.ts

@@ -0,0 +1 @@
+export declare function DogLogo(): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/FullscreenLayout.d.ts

@@ -0,0 +1,51 @@
+/**
+ * FullscreenLayout — CC-style fullscreen terminal layout.
+ *
+ * Structure:
+ *   ┌──────────────────────────┐
+ *   │  scrollable (messages)   │  ← grows, scrollable
+ *   │  overlay (permissions)   │  ← renders inside scroll area
+ *   ├──────────────────────────┤
+ *   │  bottom (prompt/spinner) │  ← pinned at bottom
+ *   └──────────────────────────┘
+ *   [pill: "N new messages"]      ← absolute, shown when scrolled away
+ *
+ * Supports:
+ * - Scrollable message area with sticky-scroll
+ * - Overlay content (permission dialogs inside scroll)
+ * - "N new messages" pill when user scrolls up
+ * - Modal pane for slash-command dialogs
+ */
+import { type ReactNode } from "react";
+interface FullscreenLayoutProps {
+    /** Main scrollable content (messages). */
+    scrollable: ReactNode;
+    /** Bottom-pinned content (prompt input, spinner). */
+    bottom: ReactNode;
+    /** Overlay content rendered after scrollable (permission dialogs). */
+    overlay?: ReactNode;
+    /** Count of unseen messages (for pill display). */
+    newMessageCount?: number;
+    /** Called when user clicks "jump to new" pill. */
+    onJumpToNew?: () => void;
+    /** Whether to show the unseen messages pill. */
+    showPill?: boolean;
+}
+export declare function FullscreenLayout({ scrollable, bottom, overlay, newMessageCount, onJumpToNew, showPill, }: FullscreenLayoutProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook for tracking unseen messages when user scrolls up.
+ *
+ * Returns:
+ * - dividerIndex: where the "new messages" boundary is
+ * - showPill: whether to display the unseen pill
+ * - onNewMessage: call when a new message arrives
+ * - onScrollToBottom: call when user scrolls to bottom or types
+ */
+export declare function useUnseenDivider(messageCount: number): {
+    dividerIndex: number | null;
+    showPill: boolean;
+    unseenCount: number;
+    onScrollAway: () => void;
+    onScrollToBottom: () => void;
+};
+export {};

package/dist/ui/components/KunHead.d.ts

@@ -0,0 +1 @@
+export declare function KunHead(): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/KunLogo.d.ts

@@ -0,0 +1 @@
+export declare function KunLogo(): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/MessageContent.d.ts

@@ -0,0 +1,22 @@
+interface MessageContentProps {
+    text: string;
+    streaming?: boolean;
+}
+export declare function MessageContent({ text, streaming }: MessageContentProps): import("react/jsx-runtime").JSX.Element | null;
+interface UserMessageProps {
+    text: string;
+}
+export declare function UserMessage({ text }: UserMessageProps): import("react/jsx-runtime").JSX.Element;
+interface ErrorMessageProps {
+    error: string;
+}
+export declare function ErrorMessage({ error }: ErrorMessageProps): import("react/jsx-runtime").JSX.Element;
+export declare function RateLimitMessage({ text }: {
+    text: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ContextLimitMessage(): import("react/jsx-runtime").JSX.Element;
+export declare function ThinkingMessage({ content, collapsed }: {
+    content?: string;
+    collapsed?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/PermissionDialog.d.ts

@@ -0,0 +1,8 @@
+interface PermissionDialogProps {
+    toolName: string;
+    description: string;
+    riskLevel: "low" | "medium" | "high";
+    onDecision: (approved: boolean, permanent?: boolean) => void;
+}
+export declare function PermissionDialog({ toolName, description, riskLevel, onDecision }: PermissionDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/PermissionPrompt.d.ts

@@ -0,0 +1,8 @@
+interface PermissionPromptProps {
+    toolName: string;
+    description: string;
+    riskLevel: string;
+    onDecision: (approved: boolean, always: boolean) => void;
+}
+export declare function PermissionPrompt({ toolName, description, riskLevel, onDecision }: PermissionPromptProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/ScrollView.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ScrollView — virtual scrolling container for terminal UI.
+ *
+ * Inspired by Claude Code's ScrollBox component. Key design:
+ * - Manages scrollTop + viewport height
+ * - Only renders children visible in the viewport (virtual scrolling)
+ * - stickyScroll: auto-follows new content (like "tail -f")
+ * - Mouse wheel scrolling support
+ * - Exposes imperative handle for programmatic scroll control
+ *
+ * Unlike CC's ScrollBox which uses a custom Yoga-based renderer,
+ * this implementation works with standard Ink by slicing the
+ * children array to only render visible items.
+ */
+import { type ReactNode } from "react";
+export interface ScrollViewHandle {
+    scrollTo: (y: number) => void;
+    scrollBy: (dy: number) => void;
+    scrollToBottom: () => void;
+    getScrollTop: () => number;
+    isAtBottom: () => boolean;
+}
+interface ScrollViewProps {
+    /** Total number of items (not pixels). */
+    itemCount: number;
+    /** Render a single item by index. */
+    renderItem: (index: number) => ReactNode;
+    /** If true, auto-scroll to bottom when new items appear. */
+    stickyScroll?: boolean;
+    /** Height in terminal rows to reserve for non-scrollable UI (input, status). */
+    reservedRows?: number;
+}
+export declare const ScrollView: import("react").ForwardRefExoticComponent<ScrollViewProps & import("react").RefAttributes<ScrollViewHandle>>;
+export {};

package/dist/ui/components/Spinner.d.ts

@@ -0,0 +1,8 @@
+interface SpinnerProps {
+    label?: string;
+    color?: string;
+    showElapsed?: boolean;
+    tokens?: number;
+}
+export declare function Spinner({ label, color, showElapsed, tokens }: SpinnerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/SpinnerWithVerb.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SpinnerWithVerb — animated spinner with random verbs, elapsed time, and token count.
+ */
+import { type MutableRefObject } from "react";
+export type SpinnerMode = "responding" | "tool-use" | "thinking";
+interface SpinnerWithVerbProps {
+    mode: SpinnerMode;
+    streamingCharsRef?: MutableRefObject<number>;
+    runStartRef?: MutableRefObject<number>;
+    thinkingContent?: string;
+}
+export declare function SpinnerWithVerb({ mode, streamingCharsRef, runStartRef, thinkingContent, }: SpinnerWithVerbProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/StatusLine.d.ts

@@ -0,0 +1,22 @@
+/**
+ * StatusLine — compact bottom status bar matching Claude Code's style.
+ *
+ * Layout: [running indicator] model · context bar % · $cost
+ *
+ * Manages its own 1s interval so the parent App doesn't re-render.
+ */
+import { type MutableRefObject } from "react";
+interface StatusLineProps {
+    model: string;
+    effort: string;
+    tokens: number;
+    cost: number;
+    sessionId?: string;
+    contextPercent?: number;
+    gitBranch?: string;
+    isRunning?: boolean;
+    streamingCharsRef?: MutableRefObject<number>;
+    runStartRef?: MutableRefObject<number>;
+}
+export declare function StatusLine({ model, effort, tokens, cost, sessionId, contextPercent, gitBranch, isRunning, streamingCharsRef, runStartRef, }: StatusLineProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/StructuredDiff.d.ts

@@ -0,0 +1,8 @@
+interface StructuredDiffProps {
+    filePath: string;
+    oldString: string;
+    newString: string;
+    replaceAll?: boolean;
+}
+export declare function StructuredDiff({ filePath, oldString, newString, replaceAll }: StructuredDiffProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/TaskList.d.ts

@@ -0,0 +1,6 @@
+import type { TaskInfo } from "../../types.js";
+interface TaskListProps {
+    tasks: TaskInfo[];
+}
+export declare function TaskList({ tasks }: TaskListProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/ui/components/TextInput.d.ts

@@ -0,0 +1,9 @@
+interface TextInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    placeholder?: string;
+    focus?: boolean;
+}
+export default function TextInput({ value, onChange, onSubmit, placeholder, focus, }: TextInputProps): import("react/jsx-runtime").JSX.Element;
+export {};