@invect/ui 0.0.1

package/dist/components/PageLayout.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { LucideIcon } from 'lucide-react';
+export interface PageLayoutProps {
+    /** Page title shown in the header */
+    title: string;
+    /** Optional subtitle below the title */
+    subtitle?: string;
+    /** Optional Lucide icon component shown before the title */
+    icon?: LucideIcon;
+    /** Optional elements rendered on the right side of the header (buttons, links, etc.) */
+    actions?: ReactNode;
+    /** Page content */
+    children: ReactNode;
+    /** Max-width variant. Defaults to 'default' (max-w-6xl). */
+    maxWidth?: 'sm' | 'md' | 'default' | 'full';
+}
+export declare const PageLayout: import('react').ForwardRefExoticComponent<PageLayoutProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/chat/ChatInput.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ChatInput — Input area for the chat panel with send/stop controls.
+ *
+ * Copilot-style layout: textarea on top, toolbar row below with
+ * model selector, provider selector, and send button.
+ */
+interface ChatInputProps {
+    isStreaming: boolean;
+    isLoadingHistory: boolean;
+    hasConfiguredCredential: boolean;
+    hasAvailableLlmCredentials: boolean;
+    onSend: (text: string) => void;
+    onStop: () => void;
+    onOpenSettings: () => void;
+}
+export declare function ChatInput({ isStreaming, isLoadingHistory, hasConfiguredCredential, hasAvailableLlmCredentials, onSend, onStop, onOpenSettings, }: ChatInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat/ChatMessageList.d.ts

@@ -0,0 +1,14 @@
+import { ChatMessage } from './chat.store';
+interface ChatMessageListProps {
+    messages: ChatMessage[];
+    isStreaming: boolean;
+    isLoadingHistory: boolean;
+    streamingText: string;
+    error: string | null;
+    hasConfiguredCredential: boolean;
+    hasAvailableLlmCredentials: boolean;
+    onOpenSettings: () => void;
+    onSendMessage: (text: string) => void;
+}
+export declare function ChatMessageList({ messages, isStreaming, isLoadingHistory, streamingText, error, hasConfiguredCredential, hasAvailableLlmCredentials: _hasAvailableLlmCredentials, onOpenSettings: _onOpenSettings, onSendMessage, }: ChatMessageListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat/ChatModelSelector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ChatModelSelector — Combobox for selecting the LLM model in the chat input area.
+ *
+ * Shows models from the provider's API (server-filtered with debounced search),
+ * with a "Recent" section for recently used models tracked via localStorage.
+ */
+interface ChatModelSelectorProps {
+    className?: string;
+}
+export declare function ChatModelSelector({ className }: ChatModelSelectorProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/chat/ChatPanel.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ChatPanel — Main chat assistant sidebar component.
+ *
+ * Slim composition shell that wires up hooks and composes
+ * ChatMessageList, ChatInput, and ChatSettingsPanel.
+ */
+interface ChatPanelProps {
+    flowId?: string;
+    selectedNodeId?: string;
+    selectedRunId?: string;
+    viewMode?: 'edit' | 'runs';
+    basePath?: string;
+    className?: string;
+}
+export declare function ChatPanel({ flowId, selectedNodeId, selectedRunId, viewMode, basePath, className, }: ChatPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function ChatToggleButton({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat/ChatPromptOverlay.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ChatPromptOverlay — Centered empty-flow prompt.
+ *
+ * Appears in the center of the flow editor viewport when the flow
+ * has no nodes. Shows an "Add Node" button, an "or" separator,
+ * and a chat input encouraging users to describe what they need.
+ * On submit, opens the full ChatPanel and sends the prompt.
+ */
+interface ChatPromptOverlayProps {
+    className?: string;
+}
+export declare function ChatPromptOverlay({ className }: ChatPromptOverlayProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/chat/ChatProviderSelector.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ChatProviderSelector — Inline combobox for selecting the LLM credential/provider
+ * directly from the chat input toolbar.
+ */
+interface ChatProviderSelectorProps {
+    className?: string;
+}
+export declare function ChatProviderSelector({ className }: ChatProviderSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat/ChatSettingsPanel.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ChatSettingsPanel — Inline panel for configuring chat assistant settings.
+ *
+ * Renders within the ChatPanel as a slide-over view when the user clicks
+ * the settings gear icon. Settings are persisted to localStorage.
+ */
+interface ChatSettingsPanelProps {
+    onClose: () => void;
+}
+export declare function ChatSettingsPanel({ onClose }: ChatSettingsPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat/InlineCredentialSetup.d.ts

@@ -0,0 +1,9 @@
+/**
+ * InlineCredentialSetup — Inline form for creating an LLM credential
+ * directly inside the chat panel (no modal, no navigation).
+ *
+ * If existing LLM credentials exist, shows a quick picker first.
+ * Otherwise shows: Provider (OpenAI/Anthropic/OpenRouter), Name, API Key.
+ * On submit: creates credential → validates via list-models → auto-selects.
+ */
+export declare function InlineCredentialSetup(): import("react/jsx-runtime").JSX.Element;

package/dist/components/chat/MarkdownRenderer.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface MarkdownRendererProps {
+    content: string;
+    className?: string;
+}
+export declare const MarkdownRenderer: React.NamedExoticComponent<MarkdownRendererProps>;
+export {};

package/dist/components/chat/chat-memory.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Chat Memory — Browser-local persistence via localStorage.
+ *
+ * Stores notes in two scopes:
+ *   - Flow-scoped:     localStorage key = `invect:chat-memory:flow:<flowId>`
+ *   - Workspace-scoped: localStorage key = `invect:chat-memory:workspace`
+ *
+ * Each key stores a JSON array of strings (the note contents).
+ * Maximum 50 notes per scope to prevent unbounded growth.
+ */
+export declare function getMemoryNotes(scope: 'flow' | 'workspace', flowId?: string): string[];
+export declare function saveMemoryNote(scope: 'flow' | 'workspace', content: string, flowId?: string): void;
+export declare function deleteMemoryNote(scope: 'flow' | 'workspace', content: string, flowId?: string): void;
+/**
+ * Get all memory notes for a flow (flow-scoped + workspace-scoped).
+ * Returns the shape expected by ChatContext.memoryNotes.
+ */
+export declare function getAllMemoryNotes(flowId?: string): {
+    flowNotes: string[];
+    workspaceNotes: string[];
+};

package/dist/components/chat/chat.store.d.ts

@@ -0,0 +1,416 @@
+/**
+ * Chat Store (Zustand)
+ *
+ * Manages the chat assistant UI state: messages, streaming status,
+ * panel visibility, and the SSE connection lifecycle.
+ *
+ * Messages are scoped per flow — each flow has its own conversation.
+ * The store auto-loads messages from the backend when switching flows
+ * and saves them when the conversation changes.
+ */
+export interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }>;
+    toolCallId?: string;
+    /** Metadata for rendering tool call/result UI */
+    toolMeta?: {
+        toolName: string;
+        args?: Record<string, unknown>;
+        result?: {
+            success: boolean;
+            data?: unknown;
+            error?: string;
+        };
+        status: 'pending' | 'done' | 'error';
+        startedAt?: number;
+        durationMs?: number;
+    };
+    createdAt: number;
+}
+export interface ChatStreamEvent {
+    type: 'text_delta' | 'tool_call_start' | 'tool_call_result' | 'ui_action' | 'suggestions' | 'error' | 'done';
+    text?: string;
+    toolName?: string;
+    toolCallId?: string;
+    args?: Record<string, unknown>;
+    result?: {
+        success: boolean;
+        data?: unknown;
+        error?: string;
+    };
+    action?: string;
+    data?: Record<string, unknown>;
+    message?: string;
+    recoverable?: boolean;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+    };
+    suggestions?: Array<{
+        label: string;
+        prompt: string;
+    }>;
+}
+export interface PlanStep {
+    index: number;
+    title: string;
+    status: 'pending' | 'in_progress' | 'done' | 'skipped';
+}
+export interface ChatPlan {
+    summary: string;
+    steps: PlanStep[];
+}
+export interface ChatSettings {
+    /** Max tool-calling steps per message (1-200, default 50) */
+    maxSteps: number;
+    /** Selected credential ID for the chat assistant LLM provider */
+    credentialId: string | null;
+    /** Selected model ID override (null = provider default) */
+    model: string | null;
+    /** Recently used model IDs */
+    recentModels: string[];
+}
+interface ChatState {
+    /** Whether the chat panel is open */
+    isOpen: boolean;
+    /** The flow ID the current messages belong to (null = no flow) */
+    activeFlowId: string | null;
+    /** All messages in the current conversation (for the active flow) */
+    messages: ChatMessage[];
+    /** Whether we're loading messages from the backend */
+    isLoadingHistory: boolean;
+    /** Whether the assistant is currently streaming a response */
+    isStreaming: boolean;
+    /** Active AbortController for cancelling the stream */
+    abortController: AbortController | null;
+    /** Accumulated text for the current streaming assistant message */
+    streamingText: string;
+    /** Error message to display */
+    error: string | null;
+    /** Prompt queued from the overlay — ChatPanel consumes and clears it */
+    pendingPrompt: string | null;
+    /** Whether messages have been modified since last save */
+    _dirty: boolean;
+    /** Whether the settings panel is open */
+    isSettingsPanelOpen: boolean;
+    /** Chat settings (persisted to localStorage) */
+    settings: ChatSettings;
+    /** Current plan from the assistant (set via show_plan / update_plan uiActions) */
+    currentPlan: ChatPlan | null;
+    /** Suggested follow-up actions from the assistant */
+    suggestions: Array<{
+        label: string;
+        prompt: string;
+    }>;
+}
+interface ChatActions {
+    togglePanel: () => void;
+    setOpen: (open: boolean) => void;
+    /** Switch to a different flow's conversation. Clears current messages in-memory. */
+    setActiveFlow: (flowId: string | null) => void;
+    /** Load messages from the backend into the store */
+    loadMessages: (messages: ChatMessage[]) => void;
+    setLoadingHistory: (loading: boolean) => void;
+    addUserMessage: (content: string) => string;
+    startStreaming: (controller: AbortController) => void;
+    appendStreamingText: (text: string) => void;
+    addToolCallMessage: (toolName: string, toolCallId: string, args: Record<string, unknown>) => void;
+    updateToolCallResult: (toolCallId: string, result: {
+        success: boolean;
+        data?: unknown;
+        error?: string;
+    }) => void;
+    finalizeAssistantMessage: () => void;
+    stopStreaming: () => void;
+    setError: (error: string | null) => void;
+    clearMessages: () => void;
+    /** Mark any pending tool calls as errored (stream ended before result arrived) */
+    finalizePendingToolCalls: () => void;
+    /** Queue a prompt from the overlay — opens the panel automatically */
+    setPendingPrompt: (prompt: string) => void;
+    /** Consume (clear) the pending prompt — called by ChatPanel after sending */
+    consumePendingPrompt: () => string | null;
+    /** Mark messages as synced (not dirty) */
+    markClean: () => void;
+    /** Check if messages need saving */
+    isDirty: () => boolean;
+    /** Get messages suitable for backend persistence */
+    getSerializableMessages: () => Array<{
+        role: ChatMessage['role'];
+        content: string;
+        toolMeta?: Record<string, unknown> | null;
+    }>;
+    /** Toggle the settings panel open/closed */
+    toggleSettingsPanel: () => void;
+    /** Update chat settings (merges with existing) */
+    updateSettings: (patch: Partial<ChatSettings>) => void;
+    /** Truncate messages from a given message ID onwards (for edit+resend) */
+    truncateFrom: (messageId: string) => void;
+    /** Set or update the current plan */
+    setPlan: (plan: ChatPlan) => void;
+    /** Set follow-up suggestions (cleared on next user message) */
+    setSuggestions: (suggestions: Array<{
+        label: string;
+        prompt: string;
+    }>) => void;
+}
+type ChatStore = ChatState & ChatActions;
+export declare const useChatStore: import('zustand').UseBoundStore<Omit<Omit<import('zustand').StoreApi<ChatStore>, "setState" | "devtools"> & {
+    setState(partial: ChatStore | Partial<ChatStore> | ((state: ChatStore) => ChatStore | Partial<ChatStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: ChatStore | ((state: ChatStore) => ChatStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: ChatStore | Partial<ChatStore> | ((state: {
+        isOpen: boolean;
+        activeFlowId: string | null;
+        messages: {
+            id: string;
+            role: "user" | "assistant" | "system" | "tool";
+            content: string;
+            toolCalls?: {
+                id: string;
+                name: string;
+                input: {
+                    [x: string]: unknown;
+                };
+            }[] | undefined;
+            toolCallId?: string | undefined;
+            toolMeta?: {
+                toolName: string;
+                args?: {
+                    [x: string]: unknown;
+                } | undefined;
+                result?: {
+                    success: boolean;
+                    data?: unknown;
+                    error?: string | undefined;
+                } | undefined;
+                status: "pending" | "done" | "error";
+                startedAt?: number | undefined;
+                durationMs?: number | undefined;
+            } | undefined;
+            createdAt: number;
+        }[];
+        isLoadingHistory: boolean;
+        isStreaming: boolean;
+        abortController: {
+            signal: {
+                aborted: boolean;
+                onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                reason: any;
+                throwIfAborted: () => void;
+                addEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            };
+            abort: (reason?: any) => void;
+        } | null;
+        streamingText: string;
+        error: string | null;
+        pendingPrompt: string | null;
+        _dirty: boolean;
+        isSettingsPanelOpen: boolean;
+        settings: {
+            maxSteps: number;
+            credentialId: string | null;
+            model: string | null;
+            recentModels: string[];
+        };
+        currentPlan: {
+            summary: string;
+            steps: {
+                index: number;
+                title: string;
+                status: "pending" | "in_progress" | "done" | "skipped";
+            }[];
+        } | null;
+        suggestions: {
+            label: string;
+            prompt: string;
+        }[];
+        togglePanel: () => void;
+        setOpen: (open: boolean) => void;
+        setActiveFlow: (flowId: string | null) => void;
+        loadMessages: (messages: ChatMessage[]) => void;
+        setLoadingHistory: (loading: boolean) => void;
+        addUserMessage: (content: string) => string;
+        startStreaming: (controller: AbortController) => void;
+        appendStreamingText: (text: string) => void;
+        addToolCallMessage: (toolName: string, toolCallId: string, args: Record<string, unknown>) => void;
+        updateToolCallResult: (toolCallId: string, result: {
+            success: boolean;
+            data?: unknown;
+            error?: string;
+        }) => void;
+        finalizeAssistantMessage: () => void;
+        stopStreaming: () => void;
+        setError: (error: string | null) => void;
+        clearMessages: () => void;
+        finalizePendingToolCalls: () => void;
+        setPendingPrompt: (prompt: string) => void;
+        consumePendingPrompt: () => string | null;
+        markClean: () => void;
+        isDirty: () => boolean;
+        getSerializableMessages: () => Array<{
+            role: ChatMessage["role"];
+            content: string;
+            toolMeta?: Record<string, unknown> | null;
+        }>;
+        toggleSettingsPanel: () => void;
+        updateSettings: (patch: Partial<ChatSettings>) => void;
+        truncateFrom: (messageId: string) => void;
+        setPlan: (plan: ChatPlan) => void;
+        setSuggestions: (suggestions: Array<{
+            label: string;
+            prompt: string;
+        }>) => void;
+    }) => void), shouldReplace?: false, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(nextStateOrUpdater: ChatStore | ((state: {
+        isOpen: boolean;
+        activeFlowId: string | null;
+        messages: {
+            id: string;
+            role: "user" | "assistant" | "system" | "tool";
+            content: string;
+            toolCalls?: {
+                id: string;
+                name: string;
+                input: {
+                    [x: string]: unknown;
+                };
+            }[] | undefined;
+            toolCallId?: string | undefined;
+            toolMeta?: {
+                toolName: string;
+                args?: {
+                    [x: string]: unknown;
+                } | undefined;
+                result?: {
+                    success: boolean;
+                    data?: unknown;
+                    error?: string | undefined;
+                } | undefined;
+                status: "pending" | "done" | "error";
+                startedAt?: number | undefined;
+                durationMs?: number | undefined;
+            } | undefined;
+            createdAt: number;
+        }[];
+        isLoadingHistory: boolean;
+        isStreaming: boolean;
+        abortController: {
+            signal: {
+                aborted: boolean;
+                onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                reason: any;
+                throwIfAborted: () => void;
+                addEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            };
+            abort: (reason?: any) => void;
+        } | null;
+        streamingText: string;
+        error: string | null;
+        pendingPrompt: string | null;
+        _dirty: boolean;
+        isSettingsPanelOpen: boolean;
+        settings: {
+            maxSteps: number;
+            credentialId: string | null;
+            model: string | null;
+            recentModels: string[];
+        };
+        currentPlan: {
+            summary: string;
+            steps: {
+                index: number;
+                title: string;
+                status: "pending" | "in_progress" | "done" | "skipped";
+            }[];
+        } | null;
+        suggestions: {
+            label: string;
+            prompt: string;
+        }[];
+        togglePanel: () => void;
+        setOpen: (open: boolean) => void;
+        setActiveFlow: (flowId: string | null) => void;
+        loadMessages: (messages: ChatMessage[]) => void;
+        setLoadingHistory: (loading: boolean) => void;
+        addUserMessage: (content: string) => string;
+        startStreaming: (controller: AbortController) => void;
+        appendStreamingText: (text: string) => void;
+        addToolCallMessage: (toolName: string, toolCallId: string, args: Record<string, unknown>) => void;
+        updateToolCallResult: (toolCallId: string, result: {
+            success: boolean;
+            data?: unknown;
+            error?: string;
+        }) => void;
+        finalizeAssistantMessage: () => void;
+        stopStreaming: () => void;
+        setError: (error: string | null) => void;
+        clearMessages: () => void;
+        finalizePendingToolCalls: () => void;
+        setPendingPrompt: (prompt: string) => void;
+        consumePendingPrompt: () => string | null;
+        markClean: () => void;
+        isDirty: () => boolean;
+        getSerializableMessages: () => Array<{
+            role: ChatMessage["role"];
+            content: string;
+            toolMeta?: Record<string, unknown> | null;
+        }>;
+        toggleSettingsPanel: () => void;
+        updateSettings: (patch: Partial<ChatSettings>) => void;
+        truncateFrom: (messageId: string) => void;
+        setPlan: (plan: ChatPlan) => void;
+        setSuggestions: (suggestions: Array<{
+            label: string;
+            prompt: string;
+        }>) => void;
+    }) => void), shouldReplace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+}>;
+export declare const useChatOpen: () => boolean;
+export {};

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

@@ -0,0 +1,5 @@
+export { ChatPanel, ChatToggleButton } from './ChatPanel';
+export { ChatPromptOverlay } from './ChatPromptOverlay';
+export { MarkdownRenderer } from './MarkdownRenderer';
+export { useChat } from './use-chat';
+export * from './chat.store';

package/dist/components/chat/use-chat.d.ts

@@ -0,0 +1,28 @@
+import { ChatMessage } from './chat.store';
+interface UseChatOptions {
+    flowId?: string;
+    selectedNodeId?: string;
+    selectedRunId?: string;
+    viewMode?: 'edit' | 'runs';
+    basePath?: string;
+}
+export declare function useChat(options?: UseChatOptions): {
+    sendMessage: (content: string, opts?: {
+        isEdit?: boolean;
+    }) => Promise<void>;
+    stopStreaming: () => void;
+    clearMessages: () => Promise<void>;
+    messages: ChatMessage[];
+    isStreaming: boolean;
+    isLoadingHistory: boolean;
+    streamingText: string;
+    error: string | null;
+    isOpen: boolean;
+    togglePanel: () => void;
+    setOpen: (open: boolean) => void;
+    settings: import('./chat.store').ChatSettings;
+    isSettingsPanelOpen: boolean;
+    toggleSettingsPanel: () => void;
+    updateSettings: (patch: Partial<import('./chat.store').ChatSettings>) => void;
+};
+export {};

package/dist/components/credentials/CreateCredentialModal.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { CreateCredentialInput, CredentialType } from '../../api/types';
+interface CreateCredentialModalProps {
+    open: boolean;
+    onClose: () => void;
+    onSubmit: (data: CreateCredentialInput) => void;
+    isLoading?: boolean;
+    portalContainer?: HTMLElement | null;
+    /** Pre-select a credential type when the modal opens (e.g. 'llm') */
+    initialType?: CredentialType;
+}
+export declare const CreateCredentialModal: React.FC<CreateCredentialModalProps>;
+export {};

package/dist/components/credentials/CredentialDetailDialog.d.ts

@@ -0,0 +1,17 @@
+import { Credential, UpdateCredentialInput } from '../../api/types';
+interface CredentialDetailDialogProps {
+    credential: Credential | null;
+    onClose: () => void;
+    onDelete: (credential: Credential) => void;
+    onTest: (id: string) => void;
+    testingId: string | null;
+    testResult: {
+        success: boolean;
+        error?: string;
+    } | null;
+    onUpdate: (id: string, data: UpdateCredentialInput) => void;
+    isUpdating: boolean;
+    portalContainer: HTMLElement | null;
+}
+export declare function CredentialDetailDialog({ credential, onClose, onDelete, onTest, testingId, testResult, onUpdate, isUpdating, portalContainer, }: CredentialDetailDialogProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/credentials/EditCredentialModal.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { Credential, UpdateCredentialInput } from '../../api/types';
+interface EditCredentialModalProps {
+    credential: Credential;
+    open: boolean;
+    onClose: () => void;
+    onSubmit: (data: UpdateCredentialInput) => void;
+    isLoading?: boolean;
+}
+export declare const EditCredentialModal: React.FC<EditCredentialModalProps>;
+export {};