@trilogy-data/trilogy-studio-components 0.1.0

package/dist/components/sidebar/LLMConnectionList.vue.d.ts

@@ -0,0 +1,978 @@
+import { LLMProvider } from '../../llm/base';
+import { Chat } from '../../chats/chat';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    activeLLMKey: {
+        type: StringConstructor;
+        default: string;
+        optional: boolean;
+    };
+    testTag: {
+        type: StringConstructor;
+        default: string;
+        optional: boolean;
+    };
+}>, {
+    llmConnectionStore: import('pinia').Store<"llmConnections", {
+        connections: Record<string, LLMProvider>;
+        activeConnection: string;
+    }, {
+        connectionList: (state: {
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        }>) => LLMProvider[];
+        unsavedConnections: (state: {
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        }>) => number;
+        getConnection: (state: {
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        }>) => (name: string) => LLMProvider;
+        getAllConnections: (state: {
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        }>) => LLMProvider[];
+        getConnectionStatus: (state: {
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        }>) => (name: string) => "running" | "failed" | "disabled" | "connected";
+        hasActiveDefaultConnection: (state: {
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, LLMProvider>;
+            activeConnection: string;
+        }>) => boolean;
+    }, {
+        addConnection(connection: LLMProvider, checkForDefault?: boolean): LLMProvider;
+        resetConnection(name: string): Promise<void>;
+        connectionStateToStatus(connection: LLMProvider | null): "running" | "failed" | "disabled" | "connected";
+        newConnection(name: string, type: string, options: Record<string, any>): LLMProvider;
+        fetchModelsForProvider(type: string, apiKey: string): Promise<string[]>;
+        generateValidatedCompletion(base: string, validator?: Function | null, maxAttempts?: number, modelOverride?: string | null, messageHistory?: import('../../llm').LLMMessage[] | null, addUserMessage?: boolean): Promise<import('../../stores/llmStore').ValidatedResponse>;
+        generateDashboardCompletion(inputString: string, validator?: Function | null, concepts?: import('../../llm').ModelConceptInput[], maxAttempts?: number): Promise<string | null>;
+        generateQueryCompletion(inputString: string, concepts: import('../../llm').ModelConceptInput[], validator?: Function | null, maxAttempts?: number, modelOverride?: string | null): Promise<import('../../stores/llmStore').ValidatedResponse>;
+        generateSQLQueryCompletion(inputString: string): Promise<import('../../stores/llmStore').ValidatedResponse>;
+        generateFilterQuery(inputString: string, concepts: import('../../llm').ModelConceptInput[], validator?: Function | null, maxAttempts?: number): Promise<string | null>;
+        generateChatName(connectionName: string, messages: import('../../llm').LLMMessage[]): Promise<string>;
+        generateCompletion(name: string, options: import('../../llm').LLMRequestOptions, history?: import('../../llm').LLMMessage[] | null): Promise<import('../../llm').LLMResponse>;
+        shouldAutoContinue(connectionName: string, lastAssistantMessage: string): Promise<boolean>;
+    }>;
+    chatStore: import('pinia').Store<"chats", {
+        chats: Record<string, Chat>;
+        activeChatId: string;
+        chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+    }, {
+        chatList: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => Chat[];
+        unsavedChats: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => number;
+        activeChat: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => Chat | null;
+        getConnectionChats: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => (llmConnectionName: string) => Chat[];
+        getChatById: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => (chatId: string) => Chat | null;
+        getChatExecution: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => (chatId: string) => import('../../stores/chatStore').ChatExecution | null;
+        isChatExecuting: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => (chatId: string) => boolean;
+        getChatActiveToolName: (state: {
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            chats: Record<string, Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }>) => (chatId: string) => string;
+    }, {
+        newChat(llmConnectionName: string, dataConnectionName?: string, name?: string): Chat;
+        addChat(chat: Chat): void;
+        removeChat(id: string): void;
+        setActiveChat(id: string): void;
+        clearActiveChat(): void;
+        updateChatName(chatId: string, name: string): void;
+        updateChatDataConnection(chatId: string, connectionName: string): void;
+        addMessageToChat(chatId: string, message: import('../../chats').ChatMessage): void;
+        addArtifactToChat(chatId: string, artifact: import('../../chats').ChatArtifact): number;
+        setActiveArtifact(chatId: string, index: number): void;
+        setImports(chatId: string, imports: import('../../chats/chat').ChatImport[]): void;
+        addImportToChat(chatId: string, imp: import('../../chats/chat').ChatImport): boolean;
+        removeImportFromChat(chatId: string, importId: string): boolean;
+        clearChatMessages(chatId: string): void;
+        loadChats(serializedChats: Record<string, any>): void;
+        serializeChats(): Record<string, any>;
+        markAllSaved(): void;
+        purgeDeleted(): void;
+        startExecution(chatId: string): void;
+        setActiveToolName(chatId: string, toolName: string): void;
+        completeExecution(chatId: string, error?: string): void;
+        clearExecution(chatId: string): void;
+        executeMessage(chatId: string, message: string, deps: import('../../stores/chatStore').ChatExecutionDependencies, options?: {
+            onSymbolsRefresh?: () => Promise<import('../../stores/resolver').CompletionItem[]>;
+        }): Promise<{
+            response?: string;
+            artifacts?: import('../../chats').ChatArtifact[];
+        } | void>;
+        buildSystemPrompt(chatId: string, deps: import('../../stores/chatStore').ChatExecutionDependencies): string;
+    }>;
+    contentList: import('vue').ComputedRef<{
+        id: string;
+        name: string;
+        indent: number;
+        count: number;
+        type: "model" | "fast-model" | "connection" | "toggle-save-credential" | "refresh-connection" | "error" | "api-key" | "loading" | "open-chat" | "open-validation" | "new-chat" | "chat-item" | "chats-header";
+        connection: any | undefined;
+        chat?: Chat;
+        chatId?: string;
+    }[]>;
+    toggleCollapse: (id: string, connectionName: string, type: string, extraData?: any) => Promise<void>;
+    collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+    saveConnections: Function;
+    updateApiKey: (connection: LLMProvider, apiKey: string) => Promise<void>;
+    updateModel: (connection: LLMProvider, model: string) => void;
+    updateFastModel: (connection: LLMProvider, fastModel: string | null) => void;
+    refreshId: (id: string, connectionName: string, type: string) => Promise<void>;
+    rightSplit: (str: string) => string;
+    creatorVisible: import('vue').Ref<boolean, boolean>;
+    isItemSelected: (item: any) => boolean;
+}, {}, {
+    connections(): LLMProvider[];
+}, {
+    resetConnection(connection: LLMProvider): Promise<void>;
+    setActiveConnection(connectionName: string): void;
+    deleteConnection(id: string, connectionName: string): void;
+    deleteChat(chatId: string, _connectionName: string): void;
+    toggleSaveCredential(connection: LLMProvider): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("open-chat" | "llm-open-view" | "create-new-chat")[], "open-chat" | "llm-open-view" | "create-new-chat", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    activeLLMKey: {
+        type: StringConstructor;
+        default: string;
+        optional: boolean;
+    };
+    testTag: {
+        type: StringConstructor;
+        default: string;
+        optional: boolean;
+    };
+}>> & Readonly<{
+    "onOpen-chat"?: ((...args: any[]) => any) | undefined;
+    "onLlm-open-view"?: ((...args: any[]) => any) | undefined;
+    "onCreate-new-chat"?: ((...args: any[]) => any) | undefined;
+}>, {
+    testTag: string;
+    activeLLMKey: string;
+}, {}, {
+    SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>, {
+        title: string;
+        isMobile: boolean | undefined;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LLMConnectionListItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        item: {
+            type: import('vue').PropType<import('./LLMConnectionListItem.vue').ListItem>;
+            required: true;
+        };
+        isCollapsed: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isSelected: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        apiKeyInput: import('vue').Ref<string, string>;
+        selectedModel: import('vue').Ref<string, string>;
+        selectedFastModel: import('vue').Ref<string, string>;
+        isExpandable: import('vue').ComputedRef<boolean>;
+        getItemName: () => string;
+        handleItemClick: () => void;
+        handleRefreshConnectionClick: (event: Event) => void;
+        getProviderType: (connection: LLMProvider) => string;
+        isConnected: (connection: LLMProvider) => boolean;
+        setAsActive: (id: string) => void;
+        updateApiKey: (connection: LLMProvider, apiKey: string) => void;
+        updateModel: (connection: LLMProvider, model: string) => void;
+        updateFastModel: (connection: LLMProvider, fastModel: string | null) => void;
+        toggleSaveCredential: (connection: LLMProvider) => void;
+        deleteConnection: (id: string) => void;
+        deleteChat: (chatId: string | undefined) => void;
+        contextMenuVisible: import('vue').Ref<boolean, boolean>;
+        contextMenuPosition: import('vue').Ref<{
+            x: number;
+            y: number;
+        }, import('../ContextMenu.vue').Position | {
+            x: number;
+            y: number;
+        }>;
+        contextMenuItems: import('vue').ComputedRef<import('../ContextMenu.vue').ContextMenuItem[]>;
+        showContextMenu: (event: MouseEvent) => void;
+        handleContextMenuItemClick: (item: import('../ContextMenu.vue').ContextMenuItem) => void;
+        toggleCollapse: (id: string) => void;
+        showApiKey: import('vue').Ref<boolean, boolean>;
+        toggleApiKeyVisibility: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("toggle" | "deleteConnection" | "refresh" | "toggleSaveCredential" | "setActive" | "updateApiKey" | "updateModel" | "updateFastModel" | "deleteChat")[], "toggle" | "deleteConnection" | "refresh" | "toggleSaveCredential" | "setActive" | "updateApiKey" | "updateModel" | "updateFastModel" | "deleteChat", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        item: {
+            type: import('vue').PropType<import('./LLMConnectionListItem.vue').ListItem>;
+            required: true;
+        };
+        isCollapsed: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isSelected: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onToggle?: ((...args: any[]) => any) | undefined;
+        onRefresh?: ((...args: any[]) => any) | undefined;
+        onDeleteConnection?: ((...args: any[]) => any) | undefined;
+        onToggleSaveCredential?: ((...args: any[]) => any) | undefined;
+        onSetActive?: ((...args: any[]) => any) | undefined;
+        onUpdateApiKey?: ((...args: any[]) => any) | undefined;
+        onUpdateModel?: ((...args: any[]) => any) | undefined;
+        onUpdateFastModel?: ((...args: any[]) => any) | undefined;
+        onDeleteChat?: ((...args: any[]) => any) | undefined;
+    }>, {
+        isSelected: boolean;
+        isCollapsed: boolean;
+    }, {}, {
+        SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            itemId: {
+                type: StringConstructor;
+                required: true;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            indent: {
+                type: NumberConstructor;
+                default: number;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: StringConstructor;
+                default: string;
+            };
+            extraInfo: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemType: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {}, {}, {
+            handleClick(): void;
+            handleToggle(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("toggle" | "click")[], "toggle" | "click", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            itemId: {
+                type: StringConstructor;
+                required: true;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            indent: {
+                type: NumberConstructor;
+                default: number;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: StringConstructor;
+                default: string;
+            };
+            extraInfo: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemType: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onToggle?: ((...args: any[]) => any) | undefined;
+        }>, {
+            icon: string;
+            indent: number;
+            isSelected: boolean;
+            isCollapsible: boolean;
+            isCollapsed: boolean;
+            extraInfo: string | number;
+            itemType: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LLMProviderIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            providerType: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            providerType: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ConnectionRefresh: import('vue').DefineComponent<import('./ConnectionRefresh.vue').RefreshButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            refresh: (connectionName: string) => any;
+        }, string, import('vue').PublicProps, Readonly<import('./ConnectionRefresh.vue').RefreshButtonProps> & Readonly<{
+            onRefresh?: ((connectionName: string) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        ConnectionStatusIcon: import('vue').DefineComponent<import('./ConnectionStatusIcon.vue').StatusIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./ConnectionStatusIcon.vue').StatusIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ContextMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            items: {
+                type: import('vue').PropType<import('../ContextMenu.vue').ContextMenuItem[]>;
+                required: true;
+            };
+            position: {
+                type: import('vue').PropType<import('../ContextMenu.vue').Position>;
+                default: () => {
+                    x: number;
+                    y: number;
+                };
+            };
+            isVisible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            positionStyle: import('vue').ComputedRef<{
+                left: string;
+                top: string;
+            }>;
+            handleItemClick: (item: import('../ContextMenu.vue').ContextMenuItem) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("close" | "item-click")[], "close" | "item-click", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            items: {
+                type: import('vue').PropType<import('../ContextMenu.vue').ContextMenuItem[]>;
+                required: true;
+            };
+            position: {
+                type: import('vue').PropType<import('../ContextMenu.vue').Position>;
+                default: () => {
+                    x: number;
+                    y: number;
+                };
+            };
+            isVisible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            "onItem-click"?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+        }>, {
+            id: string;
+            position: import('../ContextMenu.vue').Position;
+            isVisible: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LLMConnectionCreator: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        visible: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        testTag: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+    }>, {
+        connectionDetails: import('vue').Ref<{
+            name: string;
+            type: string;
+            options: {
+                apiKey: string;
+                model: string;
+                saveCredential: boolean;
+            };
+        }, {
+            name: string;
+            type: string;
+            options: {
+                apiKey: string;
+                model: string;
+                saveCredential: boolean;
+            };
+        } | {
+            name: string;
+            type: string;
+            options: {
+                apiKey: string;
+                model: string;
+                saveCredential: boolean;
+            };
+        }>;
+        connections: Record<string, LLMProvider>;
+        createConnection: () => void;
+        handleSubmitConnection: () => Promise<string>;
+        submitConnectionCreation: () => Promise<void>;
+        updateDefaultModel: (providerType: string) => void;
+    }, {}, {}, {
+        close(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        visible: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        testTag: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        testTag: string;
+    }, {}, {
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        errorMessage: import('vue').Ref<string | null, string | null>;
+        isLoading: import('vue').Ref<boolean, boolean>;
+        status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+        handleClick: () => Promise<void>;
+        handleKeydown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+        useDefaultStyle: boolean;
+        keyCombination: string[];
+        testId: string;
+    }, {}, {
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    StatusIcon: import('vue').DefineComponent<{
+        status: import('../StatusIcon.vue').Status;
+        message?: string;
+        testName?: string;
+    }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+        status: import('../StatusIcon.vue').Status;
+        message?: string;
+        testName?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        visible: boolean;
+        hoverTimeout: ReturnType<typeof setTimeout> | null;
+    }, {
+        positionClass(): string;
+    }, {
+        showTooltip(): void;
+        hideTooltip(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        position: string;
+        inline: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=LLMConnectionList.vue.d.ts.map