SYMBOL INDEX (1599 symbols across 253 files)

FILE: electron/main.cjs
  function logToFile (line 19) | function logToFile(...args) {
  function httpFetch (line 33) | function httpFetch(url, options = {}) {
  function getBackendEntryPath (line 98) | function getBackendEntryPath() {
  function getBackendDataDir (line 105) | function getBackendDataDir() {
  function startBackendServer (line 114) | function startBackendServer() {
  function stopBackendServer (line 208) | function stopBackendServer() {
  function createTray (line 248) | function createTray() {
  function createWindow (line 304) | function createWindow() {
  constant GITHUB_API_BASE (line 480) | const GITHUB_API_BASE = "https://api.github.com";
  constant REPO_OWNER (line 481) | const REPO_OWNER = "Termix-SSH";
  constant REPO_NAME (line 482) | const REPO_NAME = "Termix";
  constant CACHE_DURATION (line 485) | const CACHE_DURATION = 30 * 60 * 1000;
  function fetchGitHubAPI (line 487) | async function fetchGitHubAPI(endpoint, cacheKey) {
  function createMenu (line 795) | function createMenu() {

FILE: public/sw.js
  constant CACHE_NAME (line 1) | const CACHE_NAME = "termix-v1";
  constant STATIC_ASSETS (line 2) | const STATIC_ASSETS = [

FILE: src/backend/dashboard.ts
  constant RATE_LIMIT_MS (line 23) | const RATE_LIMIT_MS = 1000;
  constant PORT (line 514) | const PORT = 30006;

FILE: src/backend/database/database.ts
  class GitHubCache (line 122) | class GitHubCache {
    method set (line 126) | set<T>(key: string, data: T): void {
    method get (line 135) | get<T>(key: string): T | null {
  constant GITHUB_API_BASE (line 152) | const GITHUB_API_BASE = "https://api.github.com";
  constant REPO_OWNER (line 153) | const REPO_OWNER = "Termix-SSH";
  constant REPO_NAME (line 154) | const REPO_NAME = "Termix";
  function fetchGitHubAPI (line 156) | async function fetchGitHubAPI<T>(
  constant HTTP_PORT (line 1815) | const HTTP_PORT = 30001;
  function initializeSecurity (line 1817) | async function initializeSecurity() {

FILE: src/backend/database/db/index.ts
  function initializeDatabaseAsync (line 27) | async function initializeDatabaseAsync(): Promise<void> {
  function initializeCompleteDatabase (line 129) | async function initializeCompleteDatabase(): Promise<void> {
  function saveMemoryDatabaseToFile (line 1258) | async function saveMemoryDatabaseToFile() {
  function handlePostInitFileEncryption (line 1294) | async function handlePostInitFileEncryption() {
  function initializeDatabase (line 1333) | async function initializeDatabase(): Promise<void> {
  function cleanupDatabase (line 1340) | async function cleanupDatabase() {
  function getDb (line 1417) | function getDb(): ReturnType<typeof drizzle<typeof schema>> {
  function getSqlite (line 1426) | function getSqlite(): Database.Database {

FILE: src/backend/database/routes/alerts.ts
  class AlertCache (line 15) | class AlertCache {
    method set (line 19) | set<T>(key: string, data: T): void {
    method get (line 28) | get<T>(key: string): T | null {
  constant GITHUB_RAW_BASE (line 45) | const GITHUB_RAW_BASE = "https://raw.githubusercontent.com";
  constant REPO_OWNER (line 46) | const REPO_OWNER = "Termix-SSH";
  constant REPO_NAME (line 47) | const REPO_NAME = "Docs";
  constant ALERTS_FILE (line 48) | const ALERTS_FILE = "main/termix-alerts.json";
  function fetchAlertsFromGitHub (line 50) | async function fetchAlertsFromGitHub(): Promise<TermixAlert[]> {

FILE: src/backend/database/routes/credentials.ts
  function generateSSHKeyPair (line 27) | function generateSSHKeyPair(
  function isNonEmptyString (line 79) | function isNonEmptyString(val: unknown): val is string {
  function formatCredentialOutput (line 933) | function formatCredentialOutput(
  function formatSSHHostOutput (line 959) | function formatSSHHostOutput(
  function deploySSHKeyToHost (line 1497) | async function deploySSHKeyToHost(

FILE: src/backend/database/routes/host.ts
  function isNonEmptyString (line 44) | function isNonEmptyString(value: unknown): value is string {
  function isValidPort (line 48) | function isValidPort(port: unknown): port is number {
  function transformHostResponse (line 52) | function transformHostResponse(
  function resolveHostCredentials (line 2469) | async function resolveHostCredentials(
  function rewriteOPKSSHHtml (line 3885) | function rewriteOPKSSHHtml(

FILE: src/backend/database/routes/rbac.ts
  function isNonEmptyString (line 25) | function isNonEmptyString(value: unknown): value is string {

FILE: src/backend/database/routes/snippets.ts
  function isNonEmptyString (line 12) | function isNonEmptyString(val: unknown): val is string {

FILE: src/backend/database/routes/terminal.ts
  function isNonEmptyString (line 12) | function isNonEmptyString(val: unknown): val is string {

FILE: src/backend/database/routes/users.ts
  function getOIDCConfigFromEnv (line 51) | function getOIDCConfigFromEnv(): {
  function isOIDCUserAllowed (line 93) | function isOIDCUserAllowed(
  function verifyOIDCToken (line 123) | async function verifyOIDCToken(
  function isNonEmptyString (line 220) | function isNonEmptyString(val: unknown): val is string {
  function deleteUserAndRelatedData (line 227) | async function deleteUserAndRelatedData(userId: string): Promise<void> {

FILE: src/backend/guacamole/guacamole-server.ts
  function parseGuacUrl (line 12) | function parseGuacUrl(url: string): { host: string; port: number } {
  function readGuacdOptions (line 20) | function readGuacdOptions(): { host: string; port: number } {
  constant GUAC_WS_PORT (line 39) | const GUAC_WS_PORT = 30008;
  function createGuacServer (line 98) | function createGuacServer(): GuacamoleLite {
  function restartGuacServer (line 144) | async function restartGuacServer(): Promise<void> {

FILE: src/backend/guacamole/token-service.ts
  type GuacamoleConnectionSettings (line 4) | interface GuacamoleConnectionSettings {
  type GuacamoleToken (line 28) | interface GuacamoleToken {
  constant CIPHER (line 32) | const CIPHER = "aes-256-cbc";
  constant KEY_LENGTH (line 33) | const KEY_LENGTH = 32;
  class GuacamoleTokenService (line 35) | class GuacamoleTokenService {
    method constructor (line 39) | private constructor() {
    method getInstance (line 43) | static getInstance(): GuacamoleTokenService {
    method initializeKey (line 50) | private initializeKey(): Buffer {
    method getEncryptionKey (line 78) | getEncryptionKey(): Buffer {
    method encryptToken (line 82) | encryptToken(tokenObject: GuacamoleToken): string {
    method decryptToken (line 101) | decryptToken(token: string): GuacamoleToken | null {
    method createRdpToken (line 119) | createRdpToken(
    method createVncToken (line 142) | createVncToken(
    method createTelnetToken (line 161) | createTelnetToken(

FILE: src/backend/ssh/auth-manager.ts
  type ResolvedCredentials (line 7) | interface ResolvedCredentials {
  type HostConfig (line 15) | interface HostConfig {
  type AuthContext (line 30) | interface AuthContext {
  class SSHAuthManager (line 44) | class SSHAuthManager {
    method constructor (line 47) | constructor(context: AuthContext) {
    method resolveCredentials (line 51) | async resolveCredentials(
    method handleKeyboardInteractive (line 105) | handleKeyboardInteractive(
    method handleWarpgateAuth (line 146) | private handleWarpgateAuth(
    method handleTotpAuth (line 196) | private handleTotpAuth(
    method handlePasswordAuth (line 278) | private handlePasswordAuth(
    method sendLog (line 351) | sendLog(
    method cleanup (line 370) | cleanup(): void {

FILE: src/backend/ssh/docker-console.ts
  type SSHSession (line 14) | interface SSHSession {
  function detectShell (line 51) | async function detectShell(
  function createJumpHostChain (line 94) | async function createJumpHostChain(

FILE: src/backend/ssh/docker.ts
  function createConnectionLog (line 22) | function createConnectionLog(
  type SSHSession (line 36) | interface SSHSession {
  type PendingTOTPSession (line 45) | interface PendingTOTPSession {
  constant SESSION_IDLE_TIMEOUT (line 66) | const SESSION_IDLE_TIMEOUT = 60 * 60 * 1000;
  function cleanupSession (line 83) | function cleanupSession(sessionId: string) {
  function scheduleSessionCleanup (line 109) | function scheduleSessionCleanup(sessionId: string) {
  type JumpHostConfig (line 120) | interface JumpHostConfig {
  function resolveJumpHost (line 134) | async function resolveJumpHost(
  function createJumpHostChain (line 193) | async function createJumpHostChain(
  function executeDockerCommand (line 347) | async function executeDockerCommand(
  constant PORT (line 3190) | const PORT = 30007;

FILE: src/backend/ssh/file-manager.ts
  function createConnectionLog (line 20) | function createConnectionLog(
  function isExecutableFile (line 34) | function isExecutableFile(permissions: string, fileName: string): boolean {
  function modeToPermissions (line 66) | function modeToPermissions(mode: number): string {
  function formatMtime (line 89) | function formatMtime(mtime: number): string {
  type JumpHostConfig (line 163) | interface JumpHostConfig {
  function resolveJumpHost (line 177) | async function resolveJumpHost(
  function createJumpHostChain (line 236) | async function createJumpHostChain(
  type SSHSession (line 393) | interface SSHSession {
  type PendingTOTPSession (line 404) | interface PendingTOTPSession {
  function execWithSudo (line 425) | function execWithSudo(
  function getSessionSftp (line 463) | function getSessionSftp(
  function cleanupSession (line 486) | function cleanupSession(sessionId: string) {
  function scheduleSessionCleanup (line 520) | function scheduleSessionCleanup(sessionId: string) {
  function getMimeType (line 534) | function getMimeType(fileName: string): string {
  function detectBinary (line 554) | function detectBinary(buffer: Buffer): boolean {
  constant PORT (line 5590) | const PORT = 30004;

FILE: src/backend/ssh/host-key-verifier.ts
  type HostKeyVerificationData (line 7) | interface HostKeyVerificationData {
  type VerificationResponse (line 19) | interface VerificationResponse {
  class SSHHostKeyVerifier (line 23) | class SSHHostKeyVerifier {
    method createHostVerifier (line 24) | static async createHostVerifier(
    method storeHostKey (line 272) | private static async storeHostKey(
    method updateHostKey (line 290) | private static async updateHostKey(
    method promptUserForNewKey (line 309) | private static async promptUserForNewKey(
    method promptUserForChangedKey (line 369) | private static async promptUserForChangedKey(
    method getKeyType (line 433) | private static getKeyType(key: Buffer): string {

FILE: src/backend/ssh/opkssh-auth.ts
  constant AUTH_TIMEOUT (line 17) | const AUTH_TIMEOUT = 60 * 1000;
  type OPKSSHAuthSession (line 19) | interface OPKSSHAuthSession {
  function getOPKConfigPath (line 52) | function getOPKConfigPath(): string {
  function ensureOPKConfigDir (line 58) | async function ensureOPKConfigDir(): Promise<void> {
  function createTemplateConfig (line 64) | async function createTemplateConfig(): Promise<void> {
  function checkOPKConfigExists (line 81) | async function checkOPKConfigExists(): Promise<{
  function startOPKSSHAuth (line 141) | async function startOPKSSHAuth(
  function handleOPKSSHOutput (line 334) | function handleOPKSSHOutput(requestId: string, output: string): void {
  function storeOPKSSHToken (line 448) | async function storeOPKSSHToken(session: OPKSSHAuthSession): Promise<voi...
  function getOPKSSHToken (line 548) | async function getOPKSSHToken(
  function deleteOPKSSHToken (line 615) | async function deleteOPKSSHToken(
  function invalidateOPKSSHToken (line 627) | async function invalidateOPKSSHToken(
  function handleOAuthCallback (line 649) | async function handleOAuthCallback(
  function cleanupAuthSession (line 679) | async function cleanupAuthSession(requestId: string): Promise<void> {
  function cancelAuthSession (line 729) | function cancelAuthSession(requestId: string): void {
  function getActiveAuthSession (line 736) | function getActiveAuthSession(
  function getActiveSessionsForUser (line 742) | function getActiveSessionsForUser(userId: string): OPKSSHAuthSession[] {
  function getActiveSessionsAll (line 752) | function getActiveSessionsAll(): OPKSSHAuthSession[] {
  function getUserIdFromRequest (line 756) | async function getUserIdFromRequest(req: {

FILE: src/backend/ssh/server-stats.ts
  function supportsMetrics (line 32) | function supportsMetrics(host: SSHHostWithCredentials): boolean {
  function isTcpPingEnabled (line 37) | function isTcpPingEnabled(statsConfig: StatsConfig): boolean {
  function createConnectionLog (line 41) | function createConnectionLog(
  type JumpHostConfig (line 55) | interface JumpHostConfig {
  function resolveJumpHost (line 69) | async function resolveJumpHost(
  function createJumpHostChain (line 128) | async function createJumpHostChain(
  type MetricsSession (line 285) | interface MetricsSession {
  type PendingTOTPSession (line 295) | interface PendingTOTPSession {
  type MetricsViewer (line 309) | interface MetricsViewer {
  function cleanupMetricsSession (line 319) | function cleanupMetricsSession(sessionId: string) {
  function scheduleMetricsSessionCleanup (line 345) | function scheduleMetricsSessionCleanup(sessionId: string) {
  function getSessionKey (line 359) | function getSessionKey(hostId: number, userId: string): string {
  class RequestQueue (line 363) | class RequestQueue {
    method queueRequest (line 368) | async queueRequest<T>(hostId: number, request: () => Promise<T>): Prom...
    method processQueue (line 399) | private async processQueue(hostId: number): Promise<void> {
  type CachedMetrics (line 424) | interface CachedMetrics {
  class MetricsCache (line 430) | class MetricsCache {
    method get (line 434) | get(hostId: number): unknown | null {
    method set (line 442) | set(hostId: number, data: unknown): void {
    method clear (line 450) | clear(hostId?: number): void {
  type AuthFailureRecord (line 459) | interface AuthFailureRecord {
  class AuthFailureTracker (line 466) | class AuthFailureTracker {
    method recordFailure (line 471) | recordFailure(
    method shouldSkip (line 492) | shouldSkip(hostId: number): boolean {
    method getSkipReason (line 510) | getSkipReason(hostId: number): string | null {
    method reset (line 537) | reset(hostId: number): void {
    method cleanup (line 541) | cleanup(): void {
  class PollingBackoff (line 553) | class PollingBackoff {
    method recordFailure (line 559) | recordFailure(hostId: number): void {
    method shouldSkip (line 571) | shouldSkip(hostId: number): boolean {
    method getBackoffInfo (line 582) | getBackoffInfo(hostId: number): string | null {
    method reset (line 599) | reset(hostId: number): void {
    method cleanup (line 603) | cleanup(): void {
  type HostStatus (line 622) | type HostStatus = "online" | "offline";
  type SSHHostWithCredentials (line 624) | interface SSHHostWithCredentials {
  type StatusEntry (line 659) | type StatusEntry = {
  type StatsConfig (line 664) | interface StatsConfig {
  constant DEFAULT_STATS_CONFIG (line 675) | const DEFAULT_STATS_CONFIG: StatsConfig = {
  type HostPollingConfig (line 683) | interface HostPollingConfig {
  class PollingManager (line 691) | class PollingManager {
    method constructor (line 705) | constructor() {
    method getGlobalDefaults (line 711) | private getGlobalDefaults(): {
    method parseStatsConfig (line 746) | parseStatsConfig(statsConfigStr?: string | StatsConfig): StatsConfig {
    method startPollingForHost (line 789) | async startPollingForHost(
    method pollHostStatus (line 878) | private async pollHostStatus(
    method pollHostMetrics (line 908) | private async pollHostMetrics(
    method stopPollingForHost (line 960) | stopPollingForHost(hostId: number, clearData = true): void {
    method stopMetricsOnly (line 980) | stopMetricsOnly(hostId: number): void {
    method getStatus (line 988) | getStatus(hostId: number): StatusEntry | undefined {
    method getAllStatuses (line 992) | getAllStatuses(): Map<number, StatusEntry> {
    method getMetrics (line 996) | getMetrics(
    method initializePolling (line 1004) | async initializePolling(userId: string): Promise<void> {
    method refreshHostPolling (line 1012) | async refreshHostPolling(userId: string): Promise<void> {
    method refreshAllPolling (line 1032) | async refreshAllPolling(): Promise<void> {
    method registerViewer (line 1060) | registerViewer(hostId: number, sessionId: string, userId: string): void {
    method updateHeartbeat (line 1078) | updateHeartbeat(sessionId: string): boolean {
    method unregisterViewer (line 1087) | unregisterViewer(hostId: number, sessionId: string): void {
    method startMetricsForHost (line 1100) | private async startMetricsForHost(
    method stopMetricsForHost (line 1118) | private stopMetricsForHost(hostId: number): void {
    method cleanupInactiveViewers (line 1122) | private cleanupInactiveViewers(): void {
    method destroy (line 1133) | destroy(): void {
  function validateHostId (line 1143) | function validateHostId(
  function fetchAllHosts (line 1197) | async function fetchAllHosts(
  function fetchHostById (line 1228) | async function fetchHostById(
  function resolveHostCredentials (line 1270) | async function resolveHostCredentials(
  function addLegacyCredentials (line 1422) | function addLegacyCredentials(
  function buildSshConfig (line 1432) | async function buildSshConfig(
  function getPoolKey (line 1577) | function getPoolKey(host: SSHHostWithCredentials): string {
  function createSshFactory (line 1584) | function createSshFactory(host: SSHHostWithCredentials): () => Promise<C...
  function withSshConnection (line 1732) | async function withSshConnection<T>(
  function collectMetrics (line 1741) | async function collectMetrics(host: SSHHostWithCredentials): Promise<{
  function tcpPing (line 1937) | function tcpPing(
  constant PORT (line 3278) | const PORT = 30005;

FILE: src/backend/ssh/ssh-connection-pool.ts
  type PooledConnection (line 4) | interface PooledConnection {
  class SSHConnectionPool (line 11) | class SSHConnectionPool {
    method constructor (line 16) | constructor() {
    method isConnectionHealthy (line 25) | private isConnectionHealthy(client: Client): boolean {
    method getConnection (line 41) | async getConnection(
    method releaseConnection (line 128) | releaseConnection(key: string, client: Client): void {
    method removeConnection (line 137) | private removeConnection(key: string, client: Client): void {
    method clearKeyConnections (line 148) | clearKeyConnections(key: string): void {
    method cleanup (line 160) | private cleanup(): void {
    method clearAllConnections (line 193) | clearAllConnections(): void {
    method destroy (line 206) | destroy(): void {
  function withConnection (line 214) | async function withConnection<T>(

FILE: src/backend/ssh/terminal-session-manager.ts
  constant MAX_BUFFER_BYTES (line 6) | const MAX_BUFFER_BYTES = 512 * 1024;
  constant DEFAULT_TIMEOUT_MINUTES (line 7) | const DEFAULT_TIMEOUT_MINUTES = 30;
  constant HEALTH_CHECK_INTERVAL_MS (line 8) | const HEALTH_CHECK_INTERVAL_MS = 60_000;
  constant MAX_SESSIONS_PER_USER (line 9) | const MAX_SESSIONS_PER_USER = 10;
  type TerminalSession (line 11) | interface TerminalSession {
  class TerminalSessionManager (line 37) | class TerminalSessionManager {
    method constructor (line 42) | private constructor() {
    method getInstance (line 49) | static getInstance(): TerminalSessionManager {
    method createSession (line 56) | createSession(
    method getSession (line 125) | getSession(sessionId: string | null): TerminalSession | null {
    method setSSHState (line 130) | setSSHState(
    method attachWs (line 147) | attachWs(
    method detachWs (line 262) | detachWs(sessionId: string): void {
    method destroySession (line 293) | destroySession(sessionId: string): void {
    method getUserSessions (line 349) | getUserSessions(userId: string): TerminalSession[] {
    method bufferOutput (line 359) | bufferOutput(sessionId: string, data: string): void {
    method flushBuffer (line 375) | flushBuffer(session: TerminalSession): string | null {
    method getBuffer (line 383) | getBuffer(session: TerminalSession): string | null {
    method getTimeoutMs (line 388) | private getTimeoutMs(): number {
    method healthCheck (line 408) | private healthCheck(): void {
    method cleanupOpksshFiles (line 452) | private async cleanupOpksshFiles(tempFiles: {
    method destroyAll (line 478) | destroyAll(): void {

FILE: src/backend/ssh/terminal.ts
  type ConnectToHostData (line 21) | interface ConnectToHostData {
  type ResizeData (line 55) | interface ResizeData {
  type TOTPResponseData (line 60) | interface TOTPResponseData {
  type WebSocketMessage (line 64) | interface WebSocketMessage {
  type JumpHostConfig (line 76) | interface JumpHostConfig {
  function resolveJumpHost (line 90) | async function resolveJumpHost(
  function createJumpHostChain (line 154) | async function createJumpHostChain(
  function resetConnectionState (line 465) | function resetConnectionState() {
  function handleConnectToHost (line 934) | async function handleConnectToHost(data: ConnectToHostData) {
  function handleResize (line 2188) | function handleResize(data: ResizeData) {
  function cleanupAuthState (line 2204) | function cleanupAuthState(timeoutId?: NodeJS.Timeout) {

FILE: src/backend/ssh/tunnel.ts
  function broadcastTunnelStatus (line 90) | function broadcastTunnelStatus(tunnelName: string, status: TunnelStatus)...
  function getAllTunnelStatus (line 108) | function getAllTunnelStatus(): Record<string, TunnelStatus> {
  function classifyError (line 116) | function classifyError(errorMessage: string): ErrorType {
  function getTunnelMarker (line 162) | function getTunnelMarker(tunnelName: string) {
  function normalizeTunnelName (line 166) | function normalizeTunnelName(
  function parseTunnelName (line 177) | function parseTunnelName(tunnelName: string): {
  function validateTunnelConfig (line 212) | function validateTunnelConfig(
  function cleanupTunnelResources (line 231) | async function cleanupTunnelResources(
  function resetRetryState (line 332) | function resetRetryState(tunnelName: string): void {
  function handleDisconnect (line 357) | async function handleDisconnect(
  function setupPingInterval (line 498) | function setupPingInterval(tunnelName: string): void {
  function connectSSHTunnel (line 526) | async function connectSSHTunnel(
  function killRemoteTunnelByMarker (line 1309) | async function killRemoteTunnelByMarker(
  function initializeAutoStartTunnels (line 2024) | async function initializeAutoStartTunnels(): Promise<void> {
  constant PORT (line 2158) | const PORT = 30003;

FILE: src/backend/ssh/widgets/common-utils.ts
  function execCommand (line 3) | function execCommand(
  function toFixedNum (line 91) | function toFixedNum(
  function kibToGiB (line 99) | function kibToGiB(kib: number): number {

FILE: src/backend/ssh/widgets/cpu-collector.ts
  function parseCpuLine (line 4) | function parseCpuLine(
  function collectCpuMetrics (line 19) | async function collectCpuMetrics(client: Client): Promise<{

FILE: src/backend/ssh/widgets/disk-collector.ts
  function collectDiskMetrics (line 4) | async function collectDiskMetrics(client: Client): Promise<{

FILE: src/backend/ssh/widgets/firewall-collector.ts
  function parseIptablesRule (line 9) | function parseIptablesRule(line: string): FirewallRule | null {
  function parseIptablesOutput (line 68) | function parseIptablesOutput(output: string): FirewallChain[] {
  function parseNftablesOutput (line 104) | function parseNftablesOutput(output: string): FirewallChain[] {
  function collectFirewallMetrics (line 201) | async function collectFirewallMetrics(

FILE: src/backend/ssh/widgets/login-stats-collector.ts
  type LoginRecord (line 4) | interface LoginRecord {
  type LoginStats (line 11) | interface LoginStats {
  function collectLoginStats (line 18) | async function collectLoginStats(client: Client): Promise<LoginStats> {

FILE: src/backend/ssh/widgets/memory-collector.ts
  function collectMemoryMetrics (line 4) | async function collectMemoryMetrics(client: Client): Promise<{

FILE: src/backend/ssh/widgets/network-collector.ts
  function collectNetworkMetrics (line 4) | async function collectNetworkMetrics(client: Client): Promise<{

FILE: src/backend/ssh/widgets/ports-collector.ts
  function parseSsOutput (line 8) | function parseSsOutput(output: string): ListeningPort[] {
  function parseNetstatOutput (line 57) | function parseNetstatOutput(output: string): ListeningPort[] {
  function collectPortsMetrics (line 116) | async function collectPortsMetrics(

FILE: src/backend/ssh/widgets/processes-collector.ts
  function collectProcessesMetrics (line 4) | async function collectProcessesMetrics(client: Client): Promise<{

FILE: src/backend/ssh/widgets/system-collector.ts
  function collectSystemMetrics (line 4) | async function collectSystemMetrics(client: Client): Promise<{

FILE: src/backend/ssh/widgets/uptime-collector.ts
  function collectUptimeMetrics (line 4) | async function collectUptimeMetrics(client: Client): Promise<{

FILE: src/backend/swagger.ts
  function generateOpenAPISpec (line 127) | async function generateOpenAPISpec() {

FILE: src/backend/utils/auth-manager.ts
  type AuthenticationResult (line 13) | interface AuthenticationResult {
  type JWTPayload (line 24) | interface JWTPayload {
  type AuthenticatedRequest (line 32) | interface AuthenticatedRequest extends Request {
  type RequestWithHeaders (line 38) | interface RequestWithHeaders extends Request {
  class AuthManager (line 44) | class AuthManager {
    method constructor (line 49) | private constructor() {
    method getInstance (line 73) | static getInstance(): AuthManager {
    method initialize (line 80) | async initialize(): Promise<void> {
    method registerUser (line 84) | async registerUser(userId: string, password: string): Promise<void> {
    method registerOIDCUser (line 88) | async registerOIDCUser(
    method authenticateOIDCUser (line 95) | async authenticateOIDCUser(
    method authenticateUser (line 116) | async authenticateUser(
    method convertToOIDCEncryption (line 139) | async convertToOIDCEncryption(userId: string): Promise<void> {
    method performLazyEncryptionMigration (line 143) | private async performLazyEncryptionMigration(userId: string): Promise<...
    method generateJWTToken (line 197) | async generateJWTToken(
    method parseExpiresIn (line 278) | private parseExpiresIn(expiresIn: string): number {
    method verifyJWTToken (line 299) | async verifyJWTToken(token: string): Promise<JWTPayload | null> {
    method invalidateJWTToken (line 345) | invalidateJWTToken(_token: string): void {
    method invalidateUserTokens (line 350) | invalidateUserTokens(_userId: string): void {
    method revokeSession (line 354) | async revokeSession(sessionId: string): Promise<boolean> {
    method revokeAllUserSessions (line 388) | async revokeAllUserSessions(
    method cleanupExpiredSessions (line 446) | async cleanupExpiredSessions(): Promise<number> {
    method getAllSessions (line 498) | async getAllSessions(): Promise<Record<string, unknown>[]> {
    method getUserSessions (line 510) | async getUserSessions(userId: string): Promise<Record<string, unknown>...
    method getSecureCookieOptions (line 526) | getSecureCookieOptions(
    method getClearCookieOptions (line 539) | getClearCookieOptions(req: RequestWithHeaders) {
    method createAuthMiddleware (line 548) | createAuthMiddleware() {
    method createDataAccessMiddleware (line 676) | createDataAccessMiddleware() {
    method createAdminMiddleware (line 690) | createAdminMiddleware() {
    method logoutUser (line 749) | async logoutUser(userId: string, sessionId?: string): Promise<void> {
    method getUserDataKey (line 792) | getUserDataKey(userId: string): Buffer | null {
    method isUserUnlocked (line 796) | isUserUnlocked(userId: string): boolean {
    method changeUserPassword (line 800) | async changeUserPassword(
    method resetUserPasswordWithPreservedDEK (line 812) | async resetUserPasswordWithPreservedDEK(
    method isTrustedDevice (line 822) | async isTrustedDevice(
    method addTrustedDevice (line 867) | async addTrustedDevice(
    method removeTrustedDevice (line 914) | async removeTrustedDevice(

FILE: src/backend/utils/auto-ssl-setup.ts
  class AutoSSLSetup (line 6) | class AutoSSLSetup {
    method initialize (line 19) | static async initialize(): Promise<void> {
    method isSSLConfigured (line 64) | private static async isSSLConfigured(): Promise<boolean> {
    method generateSSLCertificates (line 100) | private static async generateSSLCertificates(): Promise<void> {
    method logCertificateInfo (line 178) | private static async logCertificateInfo(): Promise<void> {
    method setupEnvironmentVariables (line 221) | private static async setupEnvironmentVariables(): Promise<void> {
    method getSSLConfig (line 272) | static getSSLConfig() {

FILE: src/backend/utils/credential-system-encryption-migration.ts
  class CredentialSystemEncryptionMigration (line 9) | class CredentialSystemEncryptionMigration {
    method migrateUserCredentials (line 10) | async migrateUserCredentials(userId: string): Promise<{

FILE: src/backend/utils/data-crypto.ts
  type DatabaseInstance (line 6) | interface DatabaseInstance {
  type DatabaseRecord (line 14) | interface DatabaseRecord {
  class DataCrypto (line 19) | class DataCrypto {
    method initialize (line 22) | static initialize() {
    method encryptRecord (line 26) | static encryptRecord<T extends Record<string, unknown>>(
    method decryptRecord (line 49) | static decryptRecord<T extends Record<string, unknown>>(
    method decryptRecords (line 74) | static decryptRecords<T extends Record<string, unknown>>(
    method migrateUserSensitiveFields (line 86) | static async migrateUserSensitiveFields(
    method getUserDataKey (line 237) | static getUserDataKey(userId: string): Buffer | null {
    method reencryptUserDataAfterPasswordReset (line 241) | static async reencryptUserDataAfterPasswordReset(
    method validateUserAccess (line 413) | static validateUserAccess(userId: string): Buffer {
    method encryptRecordForUser (line 421) | static encryptRecordForUser<T extends Record<string, unknown>>(
    method decryptRecordForUser (line 430) | static decryptRecordForUser<T extends Record<string, unknown>>(
    method decryptRecordsForUser (line 439) | static decryptRecordsForUser<T extends Record<string, unknown>>(
    method canUserAccessData (line 448) | static canUserAccessData(userId: string): boolean {
    method testUserEncryption (line 452) | static testUserEncryption(userId: string): boolean {
    method encryptRecordWithSystemKey (line 477) | static async encryptRecordWithSystemKey<T extends Record<string, unkno...

FILE: src/backend/utils/database-file-encryption.ts
  type EncryptedFileMetadata (line 7) | interface EncryptedFileMetadata {
  class DatabaseFileEncryption (line 18) | class DatabaseFileEncryption {
    method encryptDatabaseFromBuffer (line 25) | static async encryptDatabaseFromBuffer(
    method encryptDatabaseFile (line 109) | static async encryptDatabaseFile(
    method decryptDatabaseToBuffer (line 204) | static async decryptDatabaseToBuffer(encryptedPath: string): Promise<B...
    method decryptDatabaseFile (line 373) | static async decryptDatabaseFile(
    method isEncryptedDatabaseFile (line 405) | static isEncryptedDatabaseFile(filePath: string): boolean {
    method getEncryptedFileInfo (line 451) | static getEncryptedFileInfo(encryptedPath: string): {
    method getDiagnosticInfo (line 502) | static getDiagnosticInfo(encryptedPath: string): {
    method createEncryptedBackup (line 623) | static async createEncryptedBackup(
    method restoreFromEncryptedBackup (line 656) | static async restoreFromEncryptedBackup(
    method cleanupTempFiles (line 681) | static cleanupTempFiles(basePath: string): void {

FILE: src/backend/utils/database-migration.ts
  type MigrationResult (line 7) | interface MigrationResult {
  type MigrationStatus (line 16) | interface MigrationStatus {
  class DatabaseMigration (line 24) | class DatabaseMigration {
    method constructor (line 29) | constructor(dataDir: string) {
    method checkMigrationStatus (line 35) | checkMigrationStatus(): MigrationStatus {
    method createBackup (line 97) | private createBackup(): string {
    method verifyMigration (line 126) | private async verifyMigration(
    method migrateDatabase (line 200) | async migrateDatabase(): Promise<MigrationResult> {
    method cleanupOldBackups (line 347) | cleanupOldBackups(): void {

FILE: src/backend/utils/database-save-trigger.ts
  class DatabaseSaveTrigger (line 3) | class DatabaseSaveTrigger {
    method initialize (line 10) | static initialize(saveFunction: () => Promise<void>): void {
    method isDirty (line 15) | static get isDirty(): boolean {
    method markClean (line 19) | static markClean(): void {
    method triggerSave (line 23) | static async triggerSave(
    method forceSave (line 62) | static async forceSave(reason: string = "critical_operation"): Promise...
    method getStatus (line 99) | static getStatus(): {
    method cleanup (line 111) | static cleanup(): void {

FILE: src/backend/utils/field-crypto.ts
  type EncryptedData (line 3) | interface EncryptedData {
  class FieldCrypto (line 11) | class FieldCrypto {
    method encryptField (line 44) | static encryptField(
    method decryptField (line 80) | static decryptField(
    method shouldEncryptField (line 114) | static shouldEncryptField(tableName: string, fieldName: string): boole...

FILE: src/backend/utils/lazy-field-encryption.ts
  type DatabaseInstance (line 4) | interface DatabaseInstance {
  class LazyFieldEncryption (line 12) | class LazyFieldEncryption {
    method isPlaintextField (line 33) | static isPlaintextField(value: string): boolean {
    method safeGetFieldValue (line 55) | static safeGetFieldValue(
    method migrateFieldToEncrypted (line 117) | static migrateFieldToEncrypted(
    method migrateRecordSensitiveFields (line 192) | static migrateRecordSensitiveFields(
    method getSensitiveFieldsForTable (line 252) | static getSensitiveFieldsForTable(tableName: string): string[] {
    method propertyToColumn (line 276) | static propertyToColumn(propertyName: string): string {
    method fieldNeedsMigration (line 280) | static fieldNeedsMigration(
    method checkUserNeedsMigration (line 314) | static async checkUserNeedsMigration(

FILE: src/backend/utils/logger.ts
  type LogLevel (line 3) | type LogLevel = "debug" | "info" | "warn" | "error" | "success";
  type LogContext (line 5) | interface LogContext {
  constant SENSITIVE_FIELDS (line 17) | const SENSITIVE_FIELDS = [
  constant TRUNCATE_FIELDS (line 37) | const TRUNCATE_FIELDS = ["data", "content", "body", "response", "request"];
  class Logger (line 39) | class Logger {
    method constructor (line 47) | constructor(serviceName: string, serviceIcon: string, serviceColor: st...
    method getTimeStamp (line 53) | private getTimeStamp(): string {
    method sanitizeContext (line 57) | private sanitizeContext(context: LogContext): LogContext {
    method formatMessage (line 88) | private formatMessage(
    method getLevelColor (line 125) | private getLevelColor(level: LogLevel): chalk.Chalk {
    method shouldLog (line 142) | private shouldLog(level: LogLevel, message: string): boolean {
    method debug (line 168) | debug(message: string, context?: LogContext): void {
    method info (line 173) | info(message: string, context?: LogContext): void {
    method warn (line 178) | warn(message: string, context?: LogContext): void {
    method error (line 183) | error(message: string, error?: unknown, context?: LogContext): void {
    method success (line 191) | success(message: string, context?: LogContext): void {
    method auth (line 196) | auth(message: string, context?: LogContext): void {
    method db (line 200) | db(message: string, context?: LogContext): void {
    method ssh (line 204) | ssh(message: string, context?: LogContext): void {
    method tunnel (line 208) | tunnel(message: string, context?: LogContext): void {
    method file (line 212) | file(message: string, context?: LogContext): void {
    method api (line 216) | api(message: string, context?: LogContext): void {
    method request (line 220) | request(message: string, context?: LogContext): void {
    method response (line 224) | response(message: string, context?: LogContext): void {
    method connection (line 228) | connection(message: string, context?: LogContext): void {
    method disconnect (line 235) | disconnect(message: string, context?: LogContext): void {
    method retry (line 242) | retry(message: string, context?: LogContext): void {

FILE: src/backend/utils/login-rate-limiter.ts
  type LoginAttempt (line 1) | interface LoginAttempt {
  class LoginRateLimiter (line 7) | class LoginRateLimiter {
    method constructor (line 25) | constructor() {
    method cleanup (line 29) | private cleanup(): void {
    method recordFailedAttempt (line 77) | recordFailedAttempt(ip: string, username?: string): void {
    method resetAttempts (line 119) | resetAttempts(ip: string, username?: string): void {
    method isLocked (line 126) | isLocked(
    method getRemainingAttempts (line 153) | getRemainingAttempts(ip: string, username?: string): number {
    method recordFailedTOTPAttempt (line 177) | recordFailedTOTPAttempt(userId: string): void {
    method resetTOTPAttempts (line 199) | resetTOTPAttempts(userId: string): void {
    method isTOTPLocked (line 203) | isTOTPLocked(userId: string): { locked: boolean; remainingTime?: numbe...
    method getRemainingTOTPAttempts (line 217) | getRemainingTOTPAttempts(userId: string): number {
    method recordResetCodeAttempt (line 228) | recordResetCodeAttempt(username: string): void {
    method resetResetCodeAttempts (line 250) | resetResetCodeAttempts(username: string): void {
    method isResetCodeLocked (line 254) | isResetCodeLocked(username: string): {
    method getRemainingResetCodeAttempts (line 271) | getRemainingResetCodeAttempts(username: string): number {

FILE: src/backend/utils/opkssh-binary-manager.ts
  constant OPKSSH_REPO (line 7) | const OPKSSH_REPO = "openpubkey/opkssh";
  function getBinaryDir (line 9) | function getBinaryDir(): string {
  function getVersionFile (line 15) | function getVersionFile(): string {
  type GitHubAsset (line 19) | interface GitHubAsset {
  type GitHubRelease (line 24) | interface GitHubRelease {
  class OPKSSHBinaryManager (line 29) | class OPKSSHBinaryManager {
    method ensureBinary (line 32) | static async ensureBinary(): Promise<string> {
    method downloadBinary (line 62) | static async downloadBinary(): Promise<void> {
    method getBinaryPath (line 113) | static getBinaryPath(): string {
    method checkForUpdate (line 122) | private static async checkForUpdate(): Promise<boolean> {
    method getLatestRelease (line 149) | private static async getLatestRelease(): Promise<GitHubRelease> {
    method findMatchingAsset (line 164) | private static findMatchingAsset(assets: GitHubAsset[]): GitHubAsset |...
    method getBinaryName (line 205) | private static getBinaryName(): string {

FILE: src/backend/utils/permission-manager.ts
  type AuthenticatedRequest (line 13) | interface AuthenticatedRequest extends Request {
  type HostAccessInfo (line 18) | interface HostAccessInfo {
  type PermissionCheckResult (line 26) | interface PermissionCheckResult {
  class PermissionManager (line 31) | class PermissionManager {
    method constructor (line 39) | private constructor() {
    method getInstance (line 59) | static getInstance(): PermissionManager {
    method cleanupExpiredAccess (line 66) | private async cleanupExpiredAccess(): Promise<void> {
    method clearPermissionCache (line 84) | private clearPermissionCache(): void {
    method invalidateUserPermissionCache (line 88) | invalidateUserPermissionCache(userId: string): void {
    method getUserPermissions (line 92) | async getUserPermissions(userId: string): Promise<string[]> {
    method hasPermission (line 140) | async hasPermission(userId: string, permission: string): Promise<boole...
    method canAccessHost (line 162) | async canAccessHost(
    method isAdmin (line 279) | async isAdmin(userId: string): Promise<boolean> {
    method requirePermission (line 312) | requirePermission(permission: string) {
    method requireHostAccess (line 344) | requireHostAccess(
    method requireAdmin (line 392) | requireAdmin() {

FILE: src/backend/utils/proxy-agent.ts
  function getProxyAgent (line 4) | function getProxyAgent(targetUrl?: string): Agent | undefined {

FILE: src/backend/utils/proxy-helper.ts
  type SOCKS5Config (line 7) | interface SOCKS5Config {
  function createProxyConnection (line 16) | async function createProxyConnection(
  function createSingleProxyConnection (line 45) | async function createSingleProxyConnection(
  function createHttpConnectConnection (line 82) | async function createHttpConnectConnection(
  function createMixedProxyChainConnection (line 164) | async function createMixedProxyChainConnection(
  function createPureSocksChainConnection (line 182) | async function createPureSocksChainConnection(
  function createHopByHopConnection (line 216) | async function createHopByHopConnection(
  function testProxyConnectivity (line 280) | async function testProxyConnectivity(options: {

FILE: src/backend/utils/request-origin.ts
  function getRequestOrigin (line 4) | function getRequestOrigin(req: Request | IncomingMessage): string {
  function getRequestOriginWithForceHTTPS (line 55) | function getRequestOriginWithForceHTTPS(

FILE: src/backend/utils/shared-credential-manager.ts
  type CredentialData (line 14) | interface CredentialData {
  class SharedCredentialManager (line 23) | class SharedCredentialManager {
    method constructor (line 26) | private constructor() {}
    method getInstance (line 28) | static getInstance(): SharedCredentialManager {
    method createSharedCredentialForUser (line 35) | async createSharedCredentialForUser(
    method createSharedCredentialsForRole (line 114) | async createSharedCredentialsForRole(
    method getSharedCredentialForUser (line 161) | async getSharedCredentialForUser(
    method updateSharedCredentialsForOriginal (line 227) | async updateSharedCredentialsForOriginal(
    method deleteSharedCredentialsForOriginal (line 303) | async deleteSharedCredentialsForOriginal(
    method reEncryptPendingCredentialsForUser (line 318) | async reEncryptPendingCredentialsForUser(userId: string): Promise<void> {
    method getDecryptedCredential (line 346) | private async getDecryptedCredential(
    method getDecryptedCredentialViaSystemKey (line 389) | private async getDecryptedCredentialViaSystemKey(
    method encryptCredentialForUser (line 441) | private encryptCredentialForUser(
    method decryptSharedCredential (line 492) | private decryptSharedCredential(
    method decryptField (line 534) | private decryptField(
    method createPendingSharedCredential (line 557) | private async createPendingSharedCredential(
    method reEncryptSharedCredential (line 578) | private async reEncryptSharedCredential(

FILE: src/backend/utils/simple-db-ops.ts
  type TableName (line 6) | type TableName =
  class SimpleDBOps (line 13) | class SimpleDBOps {
    method insert (line 14) | static async insert<T extends Record<string, unknown>>(
    method select (line 67) | static async select<T extends Record<string, unknown>>(
    method selectOne (line 89) | static async selectOne<T extends Record<string, unknown>>(
    method update (line 112) | static async update<T extends Record<string, unknown>>(
    method delete (line 160) | static async delete(
    method healthCheck (line 175) | static async healthCheck(userId: string): Promise<boolean> {
    method isUserDataUnlocked (line 179) | static isUserDataUnlocked(userId: string): boolean {
    method selectEncrypted (line 183) | static async selectEncrypted(query: unknown): Promise<unknown[]> {

FILE: src/backend/utils/ssh-key-utils.ts
  function detectKeyTypeFromContent (line 4) | function detectKeyTypeFromContent(keyContent: string): string {
  function detectPublicKeyTypeFromContent (line 103) | function detectPublicKeyTypeFromContent(publicKeyContent: string): string {
  type KeyInfo (line 184) | interface KeyInfo {
  type PublicKeyInfo (line 192) | interface PublicKeyInfo {
  type KeyPairValidationResult (line 199) | interface KeyPairValidationResult {
  function parseSSHKey (line 207) | function parseSSHKey(
  function parsePublicKey (line 292) | function parsePublicKey(publicKeyData: string): PublicKeyInfo {
  function detectKeyType (line 314) | function detectKeyType(privateKeyData: string): string {
  function getFriendlyKeyTypeName (line 326) | function getFriendlyKeyTypeName(keyType: string): string {
  function validateKeyPair (line 342) | function validateKeyPair(

FILE: src/backend/utils/system-crypto.ts
  class SystemCrypto (line 6) | class SystemCrypto {
    method constructor (line 13) | private constructor() {}
    method getInstance (line 15) | static getInstance(): SystemCrypto {
    method initializeJWTSecret (line 22) | async initializeJWTSecret(): Promise<void> {
    method getJWTSecret (line 68) | async getJWTSecret(): Promise<string> {
    method initializeDatabaseKey (line 75) | async initializeDatabaseKey(): Promise<void> {
    method getDatabaseKey (line 110) | async getDatabaseKey(): Promise<Buffer> {
    method initializeInternalAuthToken (line 117) | async initializeInternalAuthToken(): Promise<void> {
    method getInternalAuthToken (line 149) | async getInternalAuthToken(): Promise<string> {
    method initializeCredentialSharingKey (line 156) | async initializeCredentialSharingKey(): Promise<void> {
    method getCredentialSharingKey (line 193) | async getCredentialSharingKey(): Promise<Buffer> {
    method generateAndGuideUser (line 200) | private async generateAndGuideUser(): Promise<void> {
    method generateAndGuideDatabaseKey (line 216) | private async generateAndGuideDatabaseKey(): Promise<void> {
    method generateAndGuideInternalAuthToken (line 233) | private async generateAndGuideInternalAuthToken(): Promise<void> {
    method generateAndGuideCredentialSharingKey (line 252) | private async generateAndGuideCredentialSharingKey(): Promise<void> {
    method validateJWTSecret (line 272) | async validateJWTSecret(): Promise<boolean> {
    method getSystemKeyStatus (line 293) | async getSystemKeyStatus() {
    method updateEnvFile (line 312) | private async updateEnvFile(key: string, value: string): Promise<void> {

FILE: src/backend/utils/user-agent-parser.ts
  type DeviceType (line 4) | type DeviceType = "web" | "desktop" | "mobile";
  type DeviceInfo (line 6) | interface DeviceInfo {
  function detectPlatform (line 14) | function detectPlatform(req: Request): DeviceType {
  function parseUserAgent (line 44) | function parseUserAgent(req: Request): DeviceInfo {
  function parseElectronUserAgent (line 59) | function parseElectronUserAgent(userAgent: string): DeviceInfo {
  function parseMobileUserAgent (line 93) | function parseMobileUserAgent(userAgent: string): DeviceInfo {
  function parseWebUserAgent (line 147) | function parseWebUserAgent(userAgent: string): DeviceInfo {
  function parseWindowsVersion (line 211) | function parseWindowsVersion(userAgent: string): string {
  function parseMacVersion (line 231) | function parseMacVersion(userAgent: string): string {
  function generateDeviceFingerprint (line 257) | function generateDeviceFingerprint(deviceInfo: DeviceInfo): string {

FILE: src/backend/utils/user-crypto.ts
  type KEKSalt (line 7) | interface KEKSalt {
  type EncryptedDEK (line 14) | interface EncryptedDEK {
  type UserSession (line 22) | interface UserSession {
  class UserCrypto (line 28) | class UserCrypto {
    method constructor (line 37) | private constructor() {
    method getInstance (line 46) | static getInstance(): UserCrypto {
    method setSessionExpiredCallback (line 53) | setSessionExpiredCallback(callback: (userId: string) => void): void {
    method setupUserEncryption (line 57) | async setupUserEncryption(userId: string, password: string): Promise<v...
    method setupOIDCUserEncryption (line 70) | async setupOIDCUserEncryption(
    method authenticateUser (line 114) | async authenticateUser(
    method authenticateOIDCUser (line 167) | async authenticateOIDCUser(
    method getUserDataKey (line 248) | getUserDataKey(userId: string): Buffer | null {
    method logoutUser (line 268) | logoutUser(userId: string): void {
    method isUserUnlocked (line 276) | isUserUnlocked(userId: string): boolean {
    method changeUserPassword (line 280) | async changeUserPassword(
    method resetUserPasswordWithPreservedDEK (line 325) | async resetUserPasswordWithPreservedDEK(
    method convertToOIDCEncryption (line 365) | async convertToOIDCEncryption(userId: string): Promise<void> {
    method validatePassword (line 432) | private async validatePassword(
    method cleanupExpiredSessions (line 455) | private cleanupExpiredSessions(): void {
    method generateKEKSalt (line 471) | private async generateKEKSalt(): Promise<KEKSalt> {
    method deriveKEK (line 480) | private deriveKEK(password: string, kekSalt: KEKSalt): Buffer {
    method deriveOIDCSystemKey (line 490) | private deriveOIDCSystemKey(userId: string): Buffer {
    method encryptDEK (line 503) | private encryptDEK(dek: Buffer, kek: Buffer): EncryptedDEK {
    method decryptDEK (line 520) | private decryptDEK(encryptedDEK: EncryptedDEK, kek: Buffer): Buffer {
    method storeKEKSalt (line 534) | private async storeKEKSalt(userId: string, kekSalt: KEKSalt): Promise<...
    method getKEKSalt (line 553) | private async getKEKSalt(userId: string): Promise<KEKSalt | null> {
    method storeEncryptedDEK (line 571) | private async storeEncryptedDEK(
    method getEncryptedDEK (line 593) | private async getEncryptedDEK(userId: string): Promise<EncryptedDEK | ...
    method getOIDCEncryptedDEK (line 611) | private async getOIDCEncryptedDEK(

FILE: src/backend/utils/user-data-export.ts
  type UserExportData (line 15) | interface UserExportData {
  class UserDataExport (line 37) | class UserDataExport {
    method exportUserData (line 40) | static async exportUserData(
    method exportUserDataToJSON (line 174) | static async exportUserDataToJSON(
    method validateExportData (line 188) | static validateExportData(data: unknown): {
    method getExportStats (line 256) | static getExportStats(data: UserExportData): {

FILE: src/backend/utils/user-data-import.ts
  type ImportOptions (line 16) | interface ImportOptions {
  type ImportResult (line 23) | interface ImportResult {
  class UserDataImport (line 36) | class UserDataImport {
    method importUserData (line 37) | static async importUserData(
    method importSshHosts (line 160) | private static async importSshHosts(
    method importSshCredentials (line 241) | private static async importSshCredentials(
    method importFileManagerData (line 327) | private static async importFileManagerData(
    method importDismissedAlerts (line 414) | private static async importDismissedAlerts(
    method importUserDataFromJSON (line 475) | static async importUserDataFromJSON(

FILE: src/components/theme-provider.tsx
  type Theme (line 4) | type Theme = "dark" | "light" | "system";
  type ThemeProviderProps (line 6) | type ThemeProviderProps = {
  type ThemeProviderState (line 12) | type ThemeProviderState = {
  function ThemeProvider (line 24) | function ThemeProvider({

FILE: src/components/ui/accordion.tsx
  function Accordion (line 7) | function Accordion({
  function AccordionItem (line 13) | function AccordionItem({
  function AccordionTrigger (line 26) | function AccordionTrigger({
  function AccordionContent (line 48) | function AccordionContent({

FILE: src/components/ui/alert-dialog.tsx
  function AlertDialog (line 7) | function AlertDialog({
  function AlertDialogTrigger (line 13) | function AlertDialogTrigger({
  function AlertDialogPortal (line 21) | function AlertDialogPortal({
  function AlertDialogOverlay (line 29) | function AlertDialogOverlay({
  function AlertDialogContent (line 45) | function AlertDialogContent({
  function AlertDialogHeader (line 64) | function AlertDialogHeader({
  function AlertDialogFooter (line 77) | function AlertDialogFooter({
  function AlertDialogTitle (line 93) | function AlertDialogTitle({
  function AlertDialogDescription (line 106) | function AlertDialogDescription({
  function AlertDialogAction (line 119) | function AlertDialogAction({
  function AlertDialogCancel (line 131) | function AlertDialogCancel({

FILE: src/components/ui/alert.tsx
  function Alert (line 22) | function Alert({
  function AlertTitle (line 37) | function AlertTitle({ className, ...props }: React.ComponentProps<"div">) {
  function AlertDescription (line 50) | function AlertDescription({

FILE: src/components/ui/badge.tsx
  function Badge (line 29) | function Badge({

FILE: src/components/ui/button-group.tsx
  type ButtonGroupProps (line 6) | interface ButtonGroupProps {

FILE: src/components/ui/button.tsx
  type ButtonProps (line 39) | interface ButtonProps
  function Button (line 44) | function Button({

FILE: src/components/ui/card.tsx
  function Card (line 5) | function Card({ className, ...props }: React.ComponentProps<"div">) {
  function CardHeader (line 18) | function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
  function CardTitle (line 31) | function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
  function CardDescription (line 41) | function CardDescription({ className, ...props }: React.ComponentProps<"...
  function CardAction (line 51) | function CardAction({ className, ...props }: React.ComponentProps<"div">) {
  function CardContent (line 64) | function CardContent({ className, ...props }: React.ComponentProps<"div"...
  function CardFooter (line 74) | function CardFooter({ className, ...props }: React.ComponentProps<"div">) {

FILE: src/components/ui/checkbox.tsx
  function Checkbox (line 7) | function Checkbox({

FILE: src/components/ui/command.tsx
  function Command (line 16) | function Command({
  function CommandDialog (line 32) | function CommandDialog({
  function CommandInput (line 63) | function CommandInput({
  function CommandList (line 85) | function CommandList({
  function CommandEmpty (line 101) | function CommandEmpty({
  function CommandGroup (line 113) | function CommandGroup({
  function CommandSeparator (line 129) | function CommandSeparator({
  function CommandItem (line 142) | function CommandItem({
  function CommandShortcut (line 158) | function CommandShortcut({

FILE: src/components/ui/dialog.tsx
  function Dialog (line 7) | function Dialog({
  function DialogTrigger (line 13) | function DialogTrigger({
  function DialogPortal (line 19) | function DialogPortal({
  function DialogClose (line 25) | function DialogClose({
  function DialogOverlay (line 31) | function DialogOverlay({
  function DialogContent (line 47) | function DialogContent({
  function DialogHeader (line 81) | function DialogHeader({ className, ...props }: React.ComponentProps<"div...
  function DialogFooter (line 91) | function DialogFooter({ className, ...props }: React.ComponentProps<"div...
  function DialogTitle (line 104) | function DialogTitle({
  function DialogDescription (line 117) | function DialogDescription({

FILE: src/components/ui/form.tsx
  type FormFieldContextValue (line 20) | type FormFieldContextValue<
  type FormItemContextValue (line 67) | type FormItemContextValue = {
  function FormItem (line 75) | function FormItem({ className, ...props }: React.ComponentProps<"div">) {
  function FormLabel (line 89) | function FormLabel({
  function FormControl (line 106) | function FormControl({ ...props }: React.ComponentProps<typeof Slot>) {
  function FormDescription (line 125) | function FormDescription({ className, ...props }: React.ComponentProps<"...
  function FormMessage (line 138) | function FormMessage({ className, ...props }: React.ComponentProps<"p">) {

FILE: src/components/ui/input.tsx
  function Input (line 5) | function Input({ className, type, ...props }: React.ComponentProps<"inpu...

FILE: src/components/ui/kbd.tsx
  function Kbd (line 3) | function Kbd({ className, ...props }: React.ComponentProps<"kbd">) {
  function KbdGroup (line 18) | function KbdGroup({ className, ...props }: React.ComponentProps<"div">) {

FILE: src/components/ui/label.tsx
  function Label (line 6) | function Label({

FILE: src/components/ui/password-input.tsx
  type PasswordInputProps (line 8) | type PasswordInputProps = React.InputHTMLAttributes<HTMLInputElement>;

FILE: src/components/ui/popover.tsx
  function Popover (line 6) | function Popover({
  function PopoverTrigger (line 12) | function PopoverTrigger({
  function PopoverContent (line 18) | function PopoverContent({
  function PopoverAnchor (line 40) | function PopoverAnchor({

FILE: src/components/ui/progress.tsx
  function Progress (line 6) | function Progress({

FILE: src/components/ui/resizable.tsx
  function ResizablePanelGroup (line 7) | function ResizablePanelGroup({
  function ResizablePanel (line 23) | function ResizablePanel({
  function ResizableHandle (line 29) | function ResizableHandle({

FILE: src/components/ui/scroll-area.tsx
  function ScrollArea (line 6) | function ScrollArea({
  function ScrollBar (line 29) | function ScrollBar({

FILE: src/components/ui/select.tsx
  function Select (line 7) | function Select({
  function SelectGroup (line 13) | function SelectGroup({
  function SelectValue (line 19) | function SelectValue({
  function SelectTrigger (line 25) | function SelectTrigger({
  function SelectContent (line 51) | function SelectContent({
  function SelectLabel (line 86) | function SelectLabel({
  function SelectItem (line 99) | function SelectItem({
  function SelectSeparator (line 123) | function SelectSeparator({
  function SelectScrollUpButton (line 136) | function SelectScrollUpButton({
  function SelectScrollDownButton (line 154) | function SelectScrollDownButton({

FILE: src/components/ui/separator.tsx
  function Separator (line 8) | function Separator({

FILE: src/components/ui/shadcn-io/status/index.tsx
  type StatusProps (line 6) | type StatusProps = ComponentProps<typeof Badge> & {
  type StatusIndicatorProps (line 18) | type StatusIndicatorProps = HTMLAttributes<HTMLSpanElement>;
  type StatusLabelProps (line 43) | type StatusLabelProps = HTMLAttributes<HTMLSpanElement>;

FILE: src/components/ui/sheet.tsx
  function Sheet (line 7) | function Sheet({ ...props }: React.ComponentProps<typeof SheetPrimitive....
  function SheetTrigger (line 11) | function SheetTrigger({
  function SheetClose (line 17) | function SheetClose({
  function SheetPortal (line 23) | function SheetPortal({
  function SheetOverlay (line 29) | function SheetOverlay({
  function SheetContent (line 45) | function SheetContent({
  function SheetHeader (line 82) | function SheetHeader({ className, ...props }: React.ComponentProps<"div"...
  function SheetFooter (line 92) | function SheetFooter({ className, ...props }: React.ComponentProps<"div"...
  function SheetTitle (line 102) | function SheetTitle({
  function SheetDescription (line 115) | function SheetDescription({

FILE: src/components/ui/sidebar.tsx
  constant SIDEBAR_COOKIE_NAME (line 20) | const SIDEBAR_COOKIE_NAME = "sidebar_state";
  constant SIDEBAR_COOKIE_MAX_AGE (line 21) | const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7;
  constant SIDEBAR_WIDTH (line 22) | const SIDEBAR_WIDTH = "16rem";
  constant SIDEBAR_WIDTH_ICON (line 23) | const SIDEBAR_WIDTH_ICON = "3rem";
  constant SIDEBAR_KEYBOARD_SHORTCUT (line 24) | const SIDEBAR_KEYBOARD_SHORTCUT = "b";
  type SidebarContextProps (line 26) | type SidebarContextProps = {
  function useSidebar (line 38) | function useSidebar() {
  function SidebarProvider (line 47) | function SidebarProvider({
  function Sidebar (line 145) | function Sidebar({
  function SidebarTrigger (line 247) | function SidebarTrigger({
  function SidebarRail (line 273) | function SidebarRail({ className, ...props }: React.ComponentProps<"butt...
  function SidebarInset (line 298) | function SidebarInset({ className, ...props }: React.ComponentProps<"mai...
  function SidebarInput (line 312) | function SidebarInput({
  function SidebarHeader (line 326) | function SidebarHeader({ className, ...props }: React.ComponentProps<"di...
  function SidebarFooter (line 337) | function SidebarFooter({ className, ...props }: React.ComponentProps<"di...
  function SidebarSeparator (line 348) | function SidebarSeparator({
  function SidebarContent (line 362) | function SidebarContent({ className, ...props }: React.ComponentProps<"d...
  function SidebarGroup (line 376) | function SidebarGroup({ className, ...props }: React.ComponentProps<"div...
  function SidebarGroupLabel (line 387) | function SidebarGroupLabel({
  function SidebarGroupAction (line 408) | function SidebarGroupAction({
  function SidebarGroupContent (line 431) | function SidebarGroupContent({
  function SidebarMenu (line 445) | function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">) {
  function SidebarMenuItem (line 456) | function SidebarMenuItem({ className, ...props }: React.ComponentProps<"...
  function SidebarMenuButton (line 489) | function SidebarMenuButton({
  function SidebarMenuAction (line 539) | function SidebarMenuAction({
  function SidebarMenuBadge (line 571) | function SidebarMenuBadge({
  function SidebarMenuSkeleton (line 593) | function SidebarMenuSkeleton({
  function SidebarMenuSub (line 631) | function SidebarMenuSub({ className, ...props }: React.ComponentProps<"u...
  function SidebarMenuSubItem (line 646) | function SidebarMenuSubItem({
  function SidebarMenuSubButton (line 660) | function SidebarMenuSubButton({

FILE: src/components/ui/skeleton.tsx
  function Skeleton (line 3) | function Skeleton({ className, ...props }: React.ComponentProps<"div">) {

FILE: src/components/ui/slider.tsx
  function Slider (line 6) | function Slider({

FILE: src/components/ui/switch.tsx
  function Switch (line 6) | function Switch({

FILE: src/components/ui/table.tsx
  function Table (line 5) | function Table({ className, ...props }: React.ComponentProps<"table">) {
  function TableHeader (line 20) | function TableHeader({ className, ...props }: React.ComponentProps<"thea...
  function TableBody (line 30) | function TableBody({ className, ...props }: React.ComponentProps<"tbody"...
  function TableFooter (line 40) | function TableFooter({ className, ...props }: React.ComponentProps<"tfoo...
  function TableRow (line 53) | function TableRow({ className, ...props }: React.ComponentProps<"tr">) {
  function TableHead (line 66) | function TableHead({ className, ...props }: React.ComponentProps<"th">) {
  function TableCell (line 79) | function TableCell({ className, ...props }: React.ComponentProps<"td">) {
  function TableCaption (line 92) | function TableCaption({

FILE: src/components/ui/tabs.tsx
  function Tabs (line 6) | function Tabs({
  function TabsList (line 19) | function TabsList({
  function TabsTrigger (line 35) | function TabsTrigger({
  function TabsContent (line 51) | function TabsContent({

FILE: src/components/ui/textarea.tsx
  type TextareaProps (line 5) | type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement>;

FILE: src/components/ui/tooltip.tsx
  function TooltipProvider (line 8) | function TooltipProvider({
  function Tooltip (line 21) | function Tooltip({
  function TooltipTrigger (line 31) | function TooltipTrigger({
  function TooltipContent (line 37) | function TooltipContent({

FILE: src/components/ui/version-alert.tsx
  type VersionAlertProps (line 7) | interface VersionAlertProps {
  function VersionAlert (line 27) | function VersionAlert({ updateInfo, onDownload }: VersionAlertProps) {

FILE: src/constants/terminal-themes.ts
  type TerminalTheme (line 1) | interface TerminalTheme {
  constant TERMINAL_THEMES (line 30) | const TERMINAL_THEMES: Record<string, TerminalTheme> = {
  constant TERMINAL_FONTS (line 676) | const TERMINAL_FONTS = [
  constant CURSOR_STYLES (line 723) | const CURSOR_STYLES = [
  constant BELL_STYLES (line 729) | const BELL_STYLES = [
  constant FAST_SCROLL_MODIFIERS (line 736) | const FAST_SCROLL_MODIFIERS = [
  constant DEFAULT_TERMINAL_CONFIG (line 742) | const DEFAULT_TERMINAL_CONFIG = {
  type TerminalConfigType (line 769) | type TerminalConfigType = typeof DEFAULT_TERMINAL_CONFIG;

FILE: src/hooks/use-confirmation.ts
  type ConfirmationOptions (line 4) | interface ConfirmationOptions {
  type ToastConfirmOptions (line 12) | interface ToastConfirmOptions {
  function useConfirmation (line 17) | function useConfirmation() {

FILE: src/hooks/use-mobile.ts
  constant MOBILE_BREAKPOINT (line 3) | const MOBILE_BREAKPOINT = 768;
  function useIsMobile (line 5) | function useIsMobile() {

FILE: src/hooks/use-service-worker.ts
  type ServiceWorkerState (line 5) | interface ServiceWorkerState {
  function useServiceWorker (line 11) | function useServiceWorker(): ServiceWorkerState {

FILE: src/lib/base-path.ts
  function getBasePath (line 1) | function getBasePath(): string {

FILE: src/lib/clipboard-provider.ts
  class RobustClipboardProvider (line 6) | class RobustClipboardProvider implements IClipboardProvider {
    method constructor (line 10) | constructor() {
    method dispose (line 23) | dispose(): void {
    method readText (line 29) | readText(selection: ClipboardSelectionType): string {
    method writeText (line 33) | async writeText(

FILE: src/lib/db-health-monitor.ts
  type EventListener (line 1) | type EventListener = (...args: any[]) => void;
  class DatabaseHealthMonitor (line 3) | class DatabaseHealthMonitor {
    method constructor (line 12) | private constructor() {}
    method getInstance (line 14) | static getInstance(): DatabaseHealthMonitor {
    method on (line 21) | on(event: string, listener: EventListener): void {
    method off (line 28) | off(event: string, listener: EventListener): void {
    method emit (line 38) | private emit(event: string, ...args: any[]): void {
    method reportSessionExpired (line 45) | reportSessionExpired() {
    method reportDatabaseError (line 49) | reportDatabaseError(error: any, _wasAuthenticated: boolean = false) {
    method reportDatabaseSuccess (line 86) | reportDatabaseSuccess() {
    method clearErrorTimer (line 100) | private clearErrorTimer(): void {
    method isDatabaseHealthy (line 107) | isDatabaseHealthy(): boolean {
    method reset (line 111) | reset() {

FILE: src/lib/frontend-logger.ts
  type LogLevel (line 1) | type LogLevel = "debug" | "info" | "warn" | "error" | "success";
  type LogContext (line 3) | interface LogContext {
  class FrontendLogger (line 23) | class FrontendLogger {
    method constructor (line 29) | constructor(serviceName: string, serviceIcon: string, serviceColor: st...
    method getTimeStamp (line 36) | private getTimeStamp(): string {
    method formatMessage (line 41) | private formatMessage(
    method getLevelTag (line 70) | private getLevelTag(level: LogLevel): string {
    method getServiceTag (line 81) | private getServiceTag(): string {
    method shouldLog (line 85) | private shouldLog(level: LogLevel): boolean {
    method log (line 92) | private log(
    method debug (line 124) | debug(message: string, context?: LogContext): void {
    method info (line 128) | info(message: string, context?: LogContext): void {
    method warn (line 132) | warn(message: string, context?: LogContext): void {
    method error (line 136) | error(message: string, error?: unknown, context?: LogContext): void {
    method success (line 140) | success(message: string, context?: LogContext): void {
    method api (line 144) | api(message: string, context?: LogContext): void {
    method request (line 148) | request(message: string, context?: LogContext): void {
    method response (line 152) | response(message: string, context?: LogContext): void {
    method auth (line 156) | auth(message: string, context?: LogContext): void {
    method ssh (line 160) | ssh(message: string, context?: LogContext): void {
    method tunnel (line 164) | tunnel(message: string, context?: LogContext): void {
    method file (line 168) | file(message: string, context?: LogContext): void {
    method connection (line 172) | connection(message: string, context?: LogContext): void {
    method disconnect (line 179) | disconnect(message: string, context?: LogContext): void {
    method retry (line 186) | retry(message: string, context?: LogContext): void {
    method performance (line 190) | performance(message: string, context?: LogContext): void {
    method security (line 197) | security(message: string, context?: LogContext): void {
    method requestStart (line 201) | requestStart(method: string, url: string, context?: LogContext): void {
    method requestSuccess (line 213) | requestSuccess(
    method requestError (line 237) | requestError(
    method networkError (line 259) | networkError(
    method authError (line 277) | authError(method: string, url: string, context?: LogContext): void {
    method retryAttempt (line 289) | retryAttempt(
    method apiOperation (line 306) | apiOperation(operation: string, details: string, context?: LogContext)...
    method requestSummary (line 313) | requestSummary(
    method getShortUrl (line 332) | private getShortUrl(url: string): string {
    method getStatusIcon (line 343) | private getStatusIcon(status: number): string {
    method getPerformanceIcon (line 351) | private getPerformanceIcon(responseTime: number): string {
    method sanitizeUrl (line 359) | private sanitizeUrl(url: string): string {

FILE: src/lib/terminal-syntax-highlighter.ts
  constant ANSI_CODES (line 1) | const ANSI_CODES = {
  type HighlightPattern (line 28) | interface HighlightPattern {
  type MatchResult (line 36) | interface MatchResult {
  constant MAX_LINE_LENGTH (line 43) | const MAX_LINE_LENGTH = 5000;
  constant MAX_ANSI_CODES (line 44) | const MAX_ANSI_CODES = 10;
  constant PATTERNS (line 46) | const PATTERNS: HighlightPattern[] = [
  function hasExistingAnsiCodes (line 113) | function hasExistingAnsiCodes(text: string): boolean {
  function hasIncompleteAnsiSequence (line 122) | function hasIncompleteAnsiSequence(text: string): boolean {
  type TextSegment (line 126) | interface TextSegment {
  function parseAnsiSegments (line 131) | function parseAnsiSegments(text: string): TextSegment[] {
  function highlightPlainText (line 163) | function highlightPlainText(text: string): string {
  function highlightTerminalOutput (line 227) | function highlightTerminalOutput(text: string): string {
  function isSyntaxHighlightingEnabled (line 257) | function isSyntaxHighlightingEnabled(): boolean {

FILE: src/lib/utils.ts
  function cn (line 4) | function cn(...inputs: ClassValue[]) {

FILE: src/main.tsx
  function useWindowWidth (line 47) | function useWindowWidth() {
  function RootApp (line 91) | function RootApp() {

FILE: src/types/connection-log.ts
  type ConnectionStage (line 1) | type ConnectionStage =
  type LogEntry (line 29) | type LogEntry = {
  type ConnectionLogResponse (line 38) | interface ConnectionLogResponse {

FILE: src/types/electron.d.ts
  type ServerConfig (line 1) | interface ServerConfig {
  type ConnectionTestResult (line 6) | interface ConnectionTestResult {
  type DialogOptions (line 12) | interface DialogOptions {
  type DialogResult (line 21) | interface DialogResult {
  type ElectronAPI (line 28) | interface ElectronAPI {
  type Window (line 88) | interface Window {

FILE: src/types/guacamole-common-js.d.ts
  class Client (line 3) | class Client {
  class Display (line 17) | class Display {
  class Tunnel (line 25) | class Tunnel {
  class WebSocketTunnel (line 30) | class WebSocketTunnel extends Tunnel {
  class Mouse (line 34) | class Mouse {
  class State (line 43) | class State {
  class Keyboard (line 72) | class Keyboard {
  class Status (line 78) | class Status {
  class InputStream (line 84) | class InputStream {
  class OutputStream (line 89) | class OutputStream {
  class StringReader (line 94) | class StringReader {
  class StringWriter (line 100) | class StringWriter {

FILE: src/types/index.ts
  type ConnectionType (line 8) | type ConnectionType = "ssh" | "rdp" | "vnc" | "telnet";
  type SSHAuthType (line 9) | type SSHAuthType = "password" | "key" | "credential" | "none" | "opkssh";
  type GuacamoleAuthType (line 10) | type GuacamoleAuthType = "password" | "credential";
  type HostFeatureFlags (line 12) | interface HostFeatureFlags {
  type JumpHost (line 20) | interface JumpHost {
  type QuickAction (line 24) | interface QuickAction {
  type Host (line 29) | interface Host {
  type JumpHostData (line 91) | interface JumpHostData {
  type QuickActionData (line 95) | interface QuickActionData {
  type ProxyNode (line 100) | interface ProxyNode {
  type HostData (line 108) | interface HostData {
  type SSHHost (line 157) | type SSHHost = Host;
  type SSHHostData (line 158) | type SSHHostData = HostData;
  type SSHFolder (line 160) | interface SSHFolder {
  type Credential (line 174) | interface Credential {
  type CredentialBackend (line 193) | interface CredentialBackend {
  type CredentialData (line 215) | interface CredentialData {
  type TunnelConnection (line 233) | interface TunnelConnection {
  type TunnelConfig (line 250) | interface TunnelConfig {
  type TunnelStatus (line 296) | interface TunnelStatus {
  type Tab (line 318) | interface Tab {
  type FileManagerFile (line 330) | interface FileManagerFile {
  type FileManagerShortcut (line 338) | interface FileManagerShortcut {
  type FileItem (line 343) | interface FileItem {
  type ShortcutItem (line 358) | interface ShortcutItem {
  type SSHConnection (line 363) | interface SSHConnection {
  type HostInfo (line 376) | interface HostInfo {
  type TermixAlert (line 388) | interface TermixAlert {
  type TerminalConfig (line 403) | interface TerminalConfig {
  type TabContextTab (line 434) | interface TabContextTab {
  type SplitLayout (line 458) | type SplitLayout = "2h" | "2v" | "3l" | "3r" | "3t" | "4grid";
  type SplitConfiguration (line 460) | interface SplitConfiguration {
  type SplitLayoutOption (line 465) | interface SplitLayoutOption {
  constant CONNECTION_STATES (line 477) | const CONNECTION_STATES = {
  type ConnectionState (line 489) | type ConnectionState =
  type ErrorType (line 492) | type ErrorType =
  type AuthType (line 503) | type AuthType = "password" | "key" | "credential" | "none" | "opkssh";
  type KeyType (line 505) | type KeyType = "rsa" | "ecdsa" | "ed25519";
  type ApiResponse (line 511) | interface ApiResponse<T = unknown> {
  type CredentialsManagerProps (line 522) | interface CredentialsManagerProps {
  type CredentialEditorProps (line 527) | interface CredentialEditorProps {
  type CredentialViewerProps (line 533) | interface CredentialViewerProps {
  type CredentialSelectorProps (line 539) | interface CredentialSelectorProps {
  type HostManagerProps (line 544) | interface HostManagerProps {
  type SSHManagerHostEditorProps (line 556) | interface SSHManagerHostEditorProps {
  type SSHManagerHostViewerProps (line 561) | interface SSHManagerHostViewerProps {
  type HostProps (line 566) | interface HostProps {
  type SSHTunnelProps (line 571) | interface SSHTunnelProps {
  type SSHTunnelViewerProps (line 575) | interface SSHTunnelViewerProps {
  type FileManagerProps (line 593) | interface FileManagerProps {
  type AlertCardProps (line 599) | interface AlertCardProps {
  type AlertManagerProps (line 604) | interface AlertManagerProps {
  type SSHTunnelObjectProps (line 610) | interface SSHTunnelObjectProps {
  type FolderStats (line 624) | interface FolderStats {
  type Snippet (line 636) | interface Snippet {
  type SnippetData (line 648) | interface SnippetData {
  type SnippetFolder (line 656) | interface SnippetFolder {
  type HostConfig (line 670) | interface HostConfig {
  type VerificationData (line 675) | interface VerificationData {
  type Optional (line 687) | type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
  type RequiredFields (line 689) | type RequiredFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
  type PartialExcept (line 691) | type PartialExcept<T, K extends keyof T> = Partial<T> & Pick<T, K>;
  type AuthenticatedRequest (line 697) | interface AuthenticatedRequest extends Request {
  type GitHubAsset (line 710) | interface GitHubAsset {
  type GitHubRelease (line 718) | interface GitHubRelease {
  type GitHubAPIResponse (line 730) | interface GitHubAPIResponse<T> {
  type CacheEntry (line 741) | interface CacheEntry<T = unknown> {
  type ExportSummary (line 751) | interface ExportSummary {
  type ImportResult (line 762) | interface ImportResult {
  type ExportRequestBody (line 767) | interface ExportRequestBody {
  type ImportRequestBody (line 771) | interface ImportRequestBody {
  type ExportPreviewBody (line 775) | interface ExportPreviewBody {
  type RestoreRequestBody (line 780) | interface RestoreRequestBody {
  type DockerContainer (line 789) | interface DockerContainer {
  type DockerStats (line 810) | interface DockerStats {
  type DockerLogOptions (line 822) | interface DockerLogOptions {
  type DockerValidation (line 830) | interface DockerValidation {

FILE: src/types/stats-widgets.ts
  type WidgetType (line 1) | type WidgetType =
  type ListeningPort (line 13) | interface ListeningPort {
  type PortsMetrics (line 22) | interface PortsMetrics {
  type FirewallRule (line 27) | interface FirewallRule {
  type FirewallChain (line 40) | interface FirewallChain {
  type FirewallMetrics (line 46) | interface FirewallMetrics {
  type StatsConfig (line 52) | interface StatsConfig {
  constant DEFAULT_STATS_CONFIG (line 63) | const DEFAULT_STATS_CONFIG: StatsConfig = {

FILE: src/ui/contexts/ServerStatusContext.tsx
  type StatusValue (line 13) | type StatusValue = "online" | "offline" | "degraded";
  type ServerStatusEntry (line 15) | interface ServerStatusEntry {
  type ServerStatusContextType (line 20) | interface ServerStatusContextType {
  constant POLL_INTERVAL (line 29) | const POLL_INTERVAL = 30000;
  function ServerStatusProvider (line 31) | function ServerStatusProvider({
  function useServerStatus (line 197) | function useServerStatus() {
  function useHostStatus (line 207) | function useHostStatus(

FILE: src/ui/desktop/DesktopApp.tsx
  function AppContent (line 32) | function AppContent({
  class TabErrorBoundary (line 630) | class TabErrorBoundary extends Component<
    method constructor (line 634) | constructor(props: { children: ReactNode }) {
    method getDerivedStateFromError (line 639) | static getDerivedStateFromError(error: Error) {
    method componentDidCatch (line 646) | componentDidCatch(error: Error, errorInfo: ErrorInfo) {
    method render (line 658) | render() {
  function DesktopApp (line 666) | function DesktopApp() {

FILE: src/ui/desktop/apps/FullScreenAppWrapper.tsx
  type FullScreenAppWrapperProps (line 10) | interface FullScreenAppWrapperProps {

FILE: src/ui/desktop/apps/admin/AdminSettings.tsx
  type AdminSettingsProps (line 35) | interface AdminSettingsProps {
  function AdminSettings (line 41) | function AdminSettings({

FILE: src/ui/desktop/apps/admin/dialogs/CreateUserDialog.tsx
  type CreateUserDialogProps (line 20) | interface CreateUserDialogProps {
  function CreateUserDialog (line 26) | function CreateUserDialog({

FILE: src/ui/desktop/apps/admin/dialogs/LinkAccountDialog.tsx
  type LinkAccountDialogProps (line 19) | interface LinkAccountDialogProps {
  function LinkAccountDialog (line 26) | function LinkAccountDialog({

FILE: src/ui/desktop/apps/admin/dialogs/UserEditDialog.tsx
  type User (line 42) | interface User {
  type UserEditDialogProps (line 50) | interface UserEditDialogProps {
  function UserEditDialog (line 59) | function UserEditDialog({

FILE: src/ui/desktop/apps/admin/tabs/DatabaseSecurityTab.tsx
  type DatabaseSecurityTabProps (line 11) | interface DatabaseSecurityTabProps {
  function DatabaseSecurityTab (line 17) | function DatabaseSecurityTab({

FILE: src/ui/desktop/apps/admin/tabs/GeneralSettingsTab.tsx
  type GeneralSettingsTabProps (line 25) | interface GeneralSettingsTabProps {
  function GeneralSettingsTab (line 41) | function GeneralSettingsTab({

FILE: src/ui/desktop/apps/admin/tabs/OIDCSettingsTab.tsx
  type OIDCSettingsTabProps (line 13) | interface OIDCSettingsTabProps {
  function OIDCSettingsTab (line 43) | function OIDCSettingsTab({

FILE: src/ui/desktop/apps/admin/tabs/RolesTab.tsx
  function RolesTab (line 35) | function RolesTab(): React.ReactElement {

FILE: src/ui/desktop/apps/admin/tabs/SessionManagementTab.tsx
  type Session (line 21) | interface Session {
  type SessionManagementTabProps (line 34) | interface SessionManagementTabProps {
  function SessionManagementTab (line 40) | function SessionManagementTab({

FILE: src/ui/desktop/apps/admin/tabs/UserManagementTab.tsx
  type User (line 17) | interface User {
  type UserManagementTabProps (line 25) | interface UserManagementTabProps {
  function UserManagementTab (line 36) | function UserManagementTab({

FILE: src/ui/desktop/apps/command-palette/CommandPalette.tsx
  type SSHHost (line 51) | interface SSHHost {
  function CommandPalette (line 86) | function CommandPalette({

FILE: src/ui/desktop/apps/dashboard/Dashboard.tsx
  type DashboardProps (line 36) | interface DashboardProps {
  function Dashboard (line 51) | function Dashboard({

FILE: src/ui/desktop/apps/dashboard/apps/UpdateLog.tsx
  type UpdateLogProps (line 16) | interface UpdateLogProps extends React.ComponentProps<"div"> {
  type ReleaseItem (line 20) | interface ReleaseItem {
  type RSSResponse (line 37) | interface RSSResponse {
  type VersionResponse (line 50) | interface VersionResponse {
  function UpdateLog (line 62) | function UpdateLog({ loggedIn }: UpdateLogProps) {

FILE: src/ui/desktop/apps/dashboard/apps/alerts/AlertCard.tsx
  type AlertCardProps (line 22) | interface AlertCardProps {
  function AlertCard (line 70) | function AlertCard({

FILE: src/ui/desktop/apps/dashboard/apps/alerts/AlertManager.tsx
  type AlertManagerProps (line 9) | interface AlertManagerProps {
  function AlertManager (line 14) | function AlertManager({

FILE: src/ui/desktop/apps/dashboard/cards/NetworkGraphCard.tsx
  constant AVAILABLE_COLORS (line 77) | const AVAILABLE_COLORS = [
  type HostMap (line 88) | interface HostMap {
  type ContextMenuState (line 92) | interface ContextMenuState {
  type NetworkGraphCardProps (line 100) | interface NetworkGraphCardProps {
  function NetworkGraphCard (line 107) | function NetworkGraphCard({

FILE: src/ui/desktop/apps/dashboard/cards/QuickActionsCard.tsx
  type QuickActionsCardProps (line 6) | interface QuickActionsCardProps {
  function QuickActionsCard (line 14) | function QuickActionsCard({

FILE: src/ui/desktop/apps/dashboard/cards/RecentActivityCard.tsx
  type RecentActivityCardProps (line 19) | interface RecentActivityCardProps {
  function RecentActivityCard (line 26) | function RecentActivityCard({

FILE: src/ui/desktop/apps/dashboard/cards/ServerOverviewCard.tsx
  type ServerOverviewCardProps (line 14) | interface ServerOverviewCardProps {
  function ServerOverviewCard (line 26) | function ServerOverviewCard({

FILE: src/ui/desktop/apps/dashboard/cards/ServerStatsCard.tsx
  type ServerStat (line 6) | interface ServerStat {
  type ServerStatsCardProps (line 13) | interface ServerStatsCardProps {
  function ServerStatsCard (line 19) | function ServerStatsCard({

FILE: src/ui/desktop/apps/dashboard/components/DashboardSettingsDialog.tsx
  type DashboardSettingsDialogProps (line 16) | interface DashboardSettingsDialogProps {
  function DashboardSettingsDialog (line 24) | function DashboardSettingsDialog({

FILE: src/ui/desktop/apps/dashboard/hooks/useDashboardPreferences.ts
  constant DEFAULT_LAYOUT (line 8) | const DEFAULT_LAYOUT: DashboardLayout = {
  function useDashboardPreferences (line 18) | function useDashboardPreferences(enabled: boolean = true) {

FILE: src/ui/desktop/apps/features/docker/DockerApp.tsx
  type DockerAppProps (line 5) | interface DockerAppProps {

FILE: src/ui/desktop/apps/features/docker/DockerManager.tsx
  type DockerManagerProps (line 37) | interface DockerManagerProps {
  type TabData (line 46) | interface TabData {
  function DockerManagerInner (line 52) | function DockerManagerInner({
  function DockerManager (line 756) | function DockerManager(props: DockerManagerProps): React.ReactElement {

FILE: src/ui/desktop/apps/features/docker/components/ConsoleTerminal.tsx
  type ConsoleTerminalProps (line 24) | interface ConsoleTerminalProps {
  function ConsoleTerminal (line 32) | function ConsoleTerminal({

FILE: src/ui/desktop/apps/features/docker/components/ContainerCard.tsx
  type ContainerCardProps (line 37) | interface ContainerCardProps {
  function ContainerCard (line 45) | function ContainerCard({

FILE: src/ui/desktop/apps/features/docker/components/ContainerDetail.tsx
  type ContainerDetailProps (line 17) | interface ContainerDetailProps {
  function ContainerDetail (line 25) | function ContainerDetail({

FILE: src/ui/desktop/apps/features/docker/components/ContainerList.tsx
  type ContainerListProps (line 15) | interface ContainerListProps {
  function ContainerList (line 23) | function ContainerList({

FILE: src/ui/desktop/apps/features/docker/components/ContainerStats.tsx
  type ContainerStatsProps (line 15) | interface ContainerStatsProps {
  function ContainerStats (line 22) | function ContainerStats({

FILE: src/ui/desktop/apps/features/docker/components/LogViewer.tsx
  type LogViewerProps (line 19) | interface LogViewerProps {
  function LogViewer (line 25) | function LogViewer({

FILE: src/ui/desktop/apps/features/file-manager/DragIndicator.tsx
  type DragIndicatorProps (line 13) | interface DragIndicatorProps {
  function DragIndicator (line 24) | function DragIndicator({

FILE: src/ui/desktop/apps/features/file-manager/FileManager.tsx
  type FileManagerProps (line 89) | interface FileManagerProps {
  type CreateIntent (line 94) | interface CreateIntent {
  function formatFileSize (line 101) | function formatFileSize(bytes?: number): string {
  function FileManagerContent (line 119) | function FileManagerContent({ initialHost, onClose }: FileManagerProps) {
  function FileManagerInner (line 2557) | function FileManagerInner({ initialHost, onClose }: FileManagerProps) {
  function FileManager (line 2565) | function FileManager(props: FileManagerProps) {

FILE: src/ui/desktop/apps/features/file-manager/FileManagerApp.tsx
  type FileManagerAppProps (line 5) | interface FileManagerAppProps {

FILE: src/ui/desktop/apps/features/file-manager/FileManagerContextMenu.tsx
  type FileItem (line 25) | interface FileItem {
  type ContextMenuProps (line 37) | interface ContextMenuProps {
  type MenuItem (line 69) | interface MenuItem {
  function FileManagerContextMenu (line 79) | function FileManagerContextMenu({

FILE: src/ui/desktop/apps/features/file-manager/FileManagerGrid.tsx
  type CreateIntent (line 30) | interface CreateIntent {
  function formatFileSize (line 37) | function formatFileSize(bytes?: number): string {
  type DragState (line 57) | interface DragState {
  type FileManagerGridProps (line 66) | interface FileManagerGridProps {
  function FileManagerGrid (line 191) | function FileManagerGrid({
  function CreateIntentGridItem (line 1384) | function CreateIntentGridItem({
  function CreateIntentListItem (line 1441) | function CreateIntentListItem({

FILE: src/ui/desktop/apps/features/file-manager/FileManagerSidebar.tsx
  type RecentFileData (line 26) | interface RecentFileData {
  type PinnedFileData (line 34) | interface PinnedFileData {
  type ShortcutData (line 41) | interface ShortcutData {
  type DirectoryItemData (line 48) | interface DirectoryItemData {
  type SidebarItem (line 55) | interface SidebarItem {
  type FileManagerSidebarProps (line 65) | interface FileManagerSidebarProps {
  function FileManagerSidebar (line 74) | function FileManagerSidebar({

FILE: src/ui/desktop/apps/features/file-manager/SudoPasswordDialog.tsx
  type SudoPasswordDialogProps (line 15) | interface SudoPasswordDialogProps {
  function SudoPasswordDialog (line 21) | function SudoPasswordDialog({

FILE: src/ui/desktop/apps/features/file-manager/components/CompressDialog.tsx
  type CompressDialogProps (line 22) | interface CompressDialogProps {
  function CompressDialog (line 29) | function CompressDialog({

FILE: src/ui/desktop/apps/features/file-manager/components/DiffViewer.tsx
  type DiffViewerProps (line 22) | interface DiffViewerProps {
  function DiffViewer (line 31) | function DiffViewer({

FILE: src/ui/desktop/apps/features/file-manager/components/DiffWindow.tsx
  type DiffWindowProps (line 8) | interface DiffWindowProps {
  function DiffWindow (line 18) | function DiffWindow({

FILE: src/ui/desktop/apps/features/file-manager/components/DraggableWindow.tsx
  type DraggableWindowProps (line 6) | interface DraggableWindowProps {
  function DraggableWindow (line 25) | function DraggableWindow({

FILE: src/ui/desktop/apps/features/file-manager/components/FileViewer.tsx
  type FileItem (line 65) | interface FileItem {
  type FileViewerProps (line 76) | interface FileViewerProps {
  function getLanguageIcon (line 92) | function getLanguageIcon(filename: string): React.ReactNode {
  function getFileType (line 141) | function getFileType(filename: string): {
  function getLanguageExtension (line 238) | function getLanguageExtension(filename: string) {
  function formatFileSize (line 284) | function formatFileSize(bytes?: number, t?: (key: string) => string): st...
  function FileViewer (line 291) | function FileViewer({

FILE: src/ui/desktop/apps/features/file-manager/components/FileWindow.tsx
  type FileItem (line 15) | interface FileItem {
  type SSHHost (line 26) | interface SSHHost {
  type FileWindowProps (line 40) | interface FileWindowProps {
  function isDisplayableText (line 50) | function isDisplayableText(str: string): boolean {
  function FileWindow (line 66) | function FileWindow({

FILE: src/ui/desktop/apps/features/file-manager/components/PermissionsDialog.tsx
  type FileItem (line 17) | interface FileItem {
  type PermissionsDialogProps (line 26) | interface PermissionsDialogProps {
  function PermissionsDialog (line 69) | function PermissionsDialog({

FILE: src/ui/desktop/apps/features/file-manager/components/TerminalWindow.tsx
  type SSHHost (line 7) | interface SSHHost {
  type TerminalWindowProps (line 21) | interface TerminalWindowProps {
  function TerminalWindow (line 30) | function TerminalWindow({

FILE: src/ui/desktop/apps/features/file-manager/components/WindowManager.tsx
  type WindowInstance (line 3) | interface WindowInstance {
  type WindowManagerProps (line 16) | interface WindowManagerProps {
  type WindowManagerContextType (line 20) | interface WindowManagerContextType {
  function WindowManager (line 33) | function WindowManager({ children }: WindowManagerProps) {
  function useWindowManager (line 132) | function useWindowManager() {

FILE: src/ui/desktop/apps/features/file-manager/hooks/useDragAndDrop.ts
  type DragAndDropState (line 3) | interface DragAndDropState {
  type UseDragAndDropProps (line 9) | interface UseDragAndDropProps {
  function useDragAndDrop (line 16) | function useDragAndDrop({

FILE: src/ui/desktop/apps/features/file-manager/hooks/useFileSelection.ts
  type FileItem (line 3) | interface FileItem {
  function useFileSelection (line 14) | function useFileSelection() {

FILE: src/ui/desktop/apps/features/guacamole/GuacamoleApp.tsx
  type GuacamoleAppProps (line 7) | interface GuacamoleAppProps {
  type GuacamoleAppInnerProps (line 47) | interface GuacamoleAppInnerProps {

FILE: src/ui/desktop/apps/features/guacamole/GuacamoleDisplay.tsx
  type GuacamoleConnectionType (line 14) | type GuacamoleConnectionType = "rdp" | "vnc" | "telnet";
  type GuacamoleConnectionConfig (line 16) | interface GuacamoleConnectionConfig {
  type GuacamoleDisplayHandle (line 31) | interface GuacamoleDisplayHandle {
  type GuacamoleDisplayProps (line 38) | interface GuacamoleDisplayProps {

FILE: src/ui/desktop/apps/features/server-stats/ServerStats.tsx
  type QuickAction (line 47) | interface QuickAction {
  type HostConfig (line 52) | interface HostConfig {
  type TabData (line 65) | interface TabData {
  type ServerProps (line 73) | interface ServerProps {
  function ServerStatsInner (line 81) | function ServerStatsInner({
  function ServerStats (line 869) | function ServerStats(props: ServerProps): React.ReactElement {

FILE: src/ui/desktop/apps/features/server-stats/ServerStatsApp.tsx
  type ServerStatsAppProps (line 5) | interface ServerStatsAppProps {

FILE: src/ui/desktop/apps/features/server-stats/widgets/CpuWidget.tsx
  type CpuWidgetProps (line 17) | interface CpuWidgetProps {
  function CpuWidget (line 22) | function CpuWidget({ metrics, metricsHistory }: CpuWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/DiskWidget.tsx
  type DiskWidgetProps (line 17) | interface DiskWidgetProps {
  function DiskWidget (line 22) | function DiskWidget({ metrics, metricsHistory }: DiskWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/FirewallWidget.tsx
  type FirewallWidgetProps (line 11) | interface FirewallWidgetProps {
  function RuleRow (line 16) | function RuleRow({ rule }: { rule: FirewallRule }) {
  function ChainSection (line 76) | function ChainSection({ chain }: { chain: FirewallChain }) {
  function FirewallWidget (line 143) | function FirewallWidget({ metrics }: FirewallWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/LoginStatsWidget.tsx
  type LoginRecord (line 5) | interface LoginRecord {
  type LoginStatsMetrics (line 12) | interface LoginStatsMetrics {
  type ServerMetrics (line 19) | interface ServerMetrics {
  type LoginStatsWidgetProps (line 23) | interface LoginStatsWidgetProps {
  function LoginStatsWidget (line 28) | function LoginStatsWidget({ metrics }: LoginStatsWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/MemoryWidget.tsx
  type MemoryWidgetProps (line 17) | interface MemoryWidgetProps {
  function MemoryWidget (line 22) | function MemoryWidget({ metrics, metricsHistory }: MemoryWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/NetworkWidget.tsx
  type NetworkWidgetProps (line 6) | interface NetworkWidgetProps {
  function NetworkWidget (line 11) | function NetworkWidget({ metrics }: NetworkWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/PortsWidget.tsx
  type PortsWidgetProps (line 7) | interface PortsWidgetProps {
  function PortRow (line 12) | function PortRow({ port }: { port: ListeningPort }) {
  function PortsWidget (line 43) | function PortsWidget({ metrics }: PortsWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/ProcessesWidget.tsx
  type ProcessesWidgetProps (line 6) | interface ProcessesWidgetProps {
  function ProcessesWidget (line 11) | function ProcessesWidget({ metrics }: ProcessesWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/SystemWidget.tsx
  type SystemWidgetProps (line 6) | interface SystemWidgetProps {
  function SystemWidget (line 11) | function SystemWidget({ metrics }: SystemWidgetProps) {

FILE: src/ui/desktop/apps/features/server-stats/widgets/UptimeWidget.tsx
  type UptimeWidgetProps (line 6) | interface UptimeWidgetProps {
  function UptimeWidget (line 11) | function UptimeWidget({ metrics }: UptimeWidgetProps) {

FILE: src/ui/desktop/apps/features/terminal/SudoPasswordPopup.tsx
  type SudoPasswordPopupProps (line 6) | interface SudoPasswordPopupProps {
  function SudoPasswordPopup (line 14) | function SudoPasswordPopup({

FILE: src/ui/desktop/apps/features/terminal/Terminal.tsx
  type HostConfig (line 51) | interface HostConfig {
  type TerminalHandle (line 67) | interface TerminalHandle {
  type SSHTerminalProps (line 75) | interface SSHTerminalProps {
  function hardRefresh (line 382) | function hardRefresh() {
  function performFit (line 399) | function performFit() {
  function handleTotpSubmit (line 435) | function handleTotpSubmit(code: string) {
  function handleTotpCancel (line 453) | function handleTotpCancel() {
  function handleWarpgateContinue (line 463) | function handleWarpgateContinue() {
  function handleWarpgateCancel (line 481) | function handleWarpgateCancel() {
  function handleWarpgateOpenUrl (line 492) | function handleWarpgateOpenUrl() {
  function handleAuthDialogSubmit (line 498) | function handleAuthDialogSubmit(credentials: {
  function handleAuthDialogCancel (line 527) | function handleAuthDialogCancel() {
  function scheduleNotify (line 532) | function scheduleNotify(cols: number, rows: number) {
  function getUseRightClickCopyPaste (line 614) | function getUseRightClickCopyPaste() {
  function attemptReconnection (line 618) | function attemptReconnection() {
  function connectToHost (line 709) | function connectToHost(cols: number, rows: number) {
  function setupWebSocketListeners (line 785) | function setupWebSocketListeners(
  function writeTextToClipboard (line 1470) | async function writeTextToClipboard(text: string): Promise<boolean> {
  function readTextFromClipboard (line 1496) | async function readTextFromClipboard(): Promise<string> {

FILE: src/ui/desktop/apps/features/terminal/TerminalApp.tsx
  type TerminalAppProps (line 5) | interface TerminalAppProps {

FILE: src/ui/desktop/apps/features/terminal/TerminalPreview.tsx
  type TerminalPreviewProps (line 8) | interface TerminalPreviewProps {
  function TerminalPreview (line 18) | function TerminalPreview({

FILE: src/ui/desktop/apps/features/terminal/command-history/CommandAutocomplete.tsx
  type CommandAutocompleteProps (line 4) | interface CommandAutocompleteProps {
  function CommandAutocomplete (line 12) | function CommandAutocomplete({

FILE: src/ui/desktop/apps/features/terminal/command-history/CommandHistoryContext.tsx
  type CommandHistoryContextType (line 9) | interface CommandHistoryContextType {
  function CommandHistoryProvider (line 26) | function CommandHistoryProvider({ children }: { children: ReactNode }) {
  function useCommandHistory (line 77) | function useCommandHistory() {

FILE: src/ui/desktop/apps/features/tunnel/Tunnel.tsx
  function Tunnel (line 19) | function Tunnel({ filterHostKey }: SSHTunnelProps): React.ReactElement {

FILE: src/ui/desktop/apps/features/tunnel/TunnelApp.tsx
  type TunnelAppProps (line 5) | interface TunnelAppProps {

FILE: src/ui/desktop/apps/features/tunnel/TunnelManager.tsx
  type HostConfig (line 8) | interface HostConfig {
  type TunnelManagerProps (line 19) | interface TunnelManagerProps {
  function TunnelManager (line 27) | function TunnelManager({

FILE: src/ui/desktop/apps/features/tunnel/TunnelObject.tsx
  function TunnelObject (line 25) | function TunnelObject({

FILE: src/ui/desktop/apps/features/tunnel/TunnelViewer.tsx
  type SSHTunnelViewerProps (line 6) | interface SSHTunnelViewerProps {
  function TunnelViewer (line 17) | function TunnelViewer({

FILE: src/ui/desktop/apps/host-manager/credentials/CredentialEditor.tsx
  function CredentialEditor (line 40) | function CredentialEditor({

FILE: src/ui/desktop/apps/host-manager/credentials/CredentialSelector.tsx
  type CredentialSelectorProps (line 10) | interface CredentialSelectorProps {
  function CredentialSelector (line 16) | function CredentialSelector({

FILE: src/ui/desktop/apps/host-manager/credentials/CredentialsManager.tsx
  function CredentialsManager (line 67) | function CredentialsManager({

FILE: src/ui/desktop/apps/host-manager/credentials/tabs/CredentialAuthenticationTab.tsx
  function CredentialAuthenticationTab (line 27) | function CredentialAuthenticationTab({

FILE: src/ui/desktop/apps/host-manager/credentials/tabs/CredentialGeneralTab.tsx
  function CredentialGeneralTab (line 13) | function CredentialGeneralTab({

FILE: src/ui/desktop/apps/host-manager/credentials/tabs/shared/tab-types.ts
  type CredentialGeneralTabProps (line 4) | interface CredentialGeneralTabProps {
  type CredentialAuthenticationTabProps (line 17) | interface CredentialAuthenticationTabProps {

FILE: src/ui/desktop/apps/host-manager/dialogs/FolderEditDialog.tsx
  type FolderEditDialogProps (line 26) | interface FolderEditDialogProps {
  constant AVAILABLE_COLORS (line 35) | const AVAILABLE_COLORS = [
  constant AVAILABLE_ICONS (line 46) | const AVAILABLE_ICONS = [
  function FolderEditDialog (line 59) | function FolderEditDialog({

FILE: src/ui/desktop/apps/host-manager/hosts/HostManager.tsx
  function HostManager (line 17) | function HostManager({

FILE: src/ui/desktop/apps/host-manager/hosts/HostManagerEditor.tsx
  type User (line 139) | interface User {
  type SSHManagerHostEditorProps (line 145) | interface SSHManagerHostEditorProps {
  function HostManagerEditor (line 151) | function HostManagerEditor({

FILE: src/ui/desktop/apps/host-manager/hosts/HostManagerViewer.tsx
  constant INITIAL_HOSTS_PER_FOLDER (line 103) | const INITIAL_HOSTS_PER_FOLDER = 12;
  function HostManagerViewer (line 105) | function HostManagerViewer({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostDockerTab.tsx
  function HostDockerTab (line 12) | function HostDockerTab({ form, t }: HostDockerTabProps) {

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostFileManagerTab.tsx
  function HostFileManagerTab (line 12) | function HostFileManagerTab({ form, t }: HostFileManagerTabProps) {

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostGeneralTab.tsx
  function HostGeneralTab (line 53) | function HostGeneralTab({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostRemoteDesktopTab.tsx
  function GuacField (line 26) | function GuacField({
  function GuacSelect (line 116) | function GuacSelect({
  function HostRemoteDesktopTab (line 161) | function HostRemoteDesktopTab({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostSharingTab.tsx
  type User (line 61) | interface User {
  type HostSharingTabProps (line 67) | interface HostSharingTabProps {
  function HostSharingTab (line 72) | function HostSharingTab({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostStatisticsTab.tsx
  function HostStatisticsTab (line 24) | function HostStatisticsTab({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostStatusTab.tsx
  function HostStatusTab (line 19) | function HostStatusTab({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostTerminalTab.tsx
  function HostTerminalTab (line 51) | function HostTerminalTab({ form, snippets, t }: HostTerminalTabProps) {

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/HostTunnelTab.tsx
  function HostTunnelTab (line 14) | function HostTunnelTab({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/shared/JumpHostItem.tsx
  function JumpHostItem (line 19) | function JumpHostItem({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/shared/QuickActionItem.tsx
  function QuickActionItem (line 20) | function QuickActionItem({

FILE: src/ui/desktop/apps/host-manager/hosts/tabs/shared/tab-types.ts
  type HostGeneralTabProps (line 5) | interface HostGeneralTabProps {
  type HostTerminalTabProps (line 36) | interface HostTerminalTabProps {
  type HostDockerTabProps (line 42) | interface HostDockerTabProps {
  type HostTunnelTabProps (line 47) | interface HostTunnelTabProps {
  type HostFileManagerTabProps (line 64) | interface HostFileManagerTabProps {
  type HostStatisticsTabProps (line 69) | interface HostStatisticsTabProps {
  type HostRemoteDesktopTabProps (line 79) | interface HostRemoteDesktopTabProps {
  type HostSharingTabProps (line 85) | interface HostSharingTabProps {
  type JumpHostItemProps (line 90) | interface JumpHostItemProps {
  type QuickActionItemProps (line 100) | interface QuickActionItemProps {

FILE: src/ui/desktop/apps/tools/SSHToolsSidebar.tsx
  type TabData (line 86) | interface TabData {
  type SSHToolsSidebarProps (line 102) | interface SSHToolsSidebarProps {
  constant AVAILABLE_COLORS (line 112) | const AVAILABLE_COLORS = [
  constant AVAILABLE_ICONS (line 123) | const AVAILABLE_ICONS = [
  function SSHToolsSidebar (line 136) | function SSHToolsSidebar({

FILE: src/ui/desktop/authentication/Auth.tsx
  function getCookie (line 41) | function getCookie(name: string): string | undefined {
  type ExtendedWindow (line 47) | interface ExtendedWindow extends Window {
  type AuthProps (line 51) | interface AuthProps extends React.ComponentProps<"div"> {
  function Auth (line 66) | function Auth({

FILE: src/ui/desktop/authentication/ElectronLoginForm.tsx
  type ElectronLoginFormProps (line 8) | interface ElectronLoginFormProps {
  function ElectronLoginForm (line 14) | function ElectronLoginForm({

FILE: src/ui/desktop/authentication/ElectronServerConfig.tsx
  type ServerConfigProps (line 17) | interface ServerConfigProps {
  function ElectronServerConfig (line 24) | function ElectronServerConfig({

FILE: src/ui/desktop/navigation/AppView.tsx
  type TabData (line 30) | interface TabData {
  type LayoutNode (line 46) | type LayoutNode =
  constant SPLIT_LAYOUTS (line 50) | const SPLIT_LAYOUTS: Record<number, LayoutNode> = {
  type TerminalViewProps (line 79) | interface TerminalViewProps {
  function AppView (line 85) | function AppView({

FILE: src/ui/desktop/navigation/LeftSidebar.tsx
  type SidebarProps (line 41) | interface SidebarProps {
  function handleLogout (line 49) | async function handleLogout() {
  function LeftSidebar (line 64) | function LeftSidebar({

FILE: src/ui/desktop/navigation/TopNavbar.tsx
  type TabData (line 14) | interface TabData {
  type TopNavbarProps (line 26) | interface TopNavbarProps {
  function TopNavbar (line 33) | function TopNavbar({

FILE: src/ui/desktop/navigation/animations/SimpleLoader.tsx
  type SimpleLoaderProps (line 4) | interface SimpleLoaderProps {
  function SimpleLoader (line 11) | function SimpleLoader({

FILE: src/ui/desktop/navigation/connection-log/ConnectionLog.tsx
  type ConnectionLogProps (line 16) | interface ConnectionLogProps {
  function ConnectionLog (line 23) | function ConnectionLog({

FILE: src/ui/desktop/navigation/connection-log/ConnectionLogContext.tsx
  type ConnectionLogContextType (line 4) | interface ConnectionLogContextType {
  function ConnectionLogProvider (line 18) | function ConnectionLogProvider({
  function useConnectionLog (line 81) | function useConnectionLog() {

FILE: src/ui/desktop/navigation/dialogs/HostKeyVerificationDialog.tsx
  type HostKeyVerificationDialogProps (line 14) | interface HostKeyVerificationDialogProps {
  function HostKeyVerificationDialog (line 30) | function HostKeyVerificationDialog({

FILE: src/ui/desktop/navigation/dialogs/OPKSSHDialog.tsx
  type OPKSSHDialogProps (line 9) | interface OPKSSHDialogProps {
  function OPKSSHDialog (line 20) | function OPKSSHDialog({

FILE: src/ui/desktop/navigation/dialogs/QuickConnectDialog.tsx
  type QuickConnectDialogProps (line 43) | interface QuickConnectDialogProps {
  function QuickConnectDialog (line 60) | function QuickConnectDialog({

FILE: src/ui/desktop/navigation/dialogs/SSHAuthDialog.tsx
  type SSHAuthDialogProps (line 26) | interface SSHAuthDialogProps {
  function SSHAuthDialog (line 44) | function SSHAuthDialog({

FILE: src/ui/desktop/navigation/dialogs/TOTPDialog.tsx
  type TOTPDialogProps (line 8) | interface TOTPDialogProps {
  function TOTPDialog (line 16) | function TOTPDialog({

FILE: src/ui/desktop/navigation/dialogs/WarpgateDialog.tsx
  type WarpgateDialogProps (line 9) | interface WarpgateDialogProps {
  function WarpgateDialog (line 19) | function WarpgateDialog({

FILE: src/ui/desktop/navigation/hosts/FolderCard.tsx
  type SSHHost (line 20) | interface SSHHost {
  type FolderCardProps (line 50) | interface FolderCardProps {
  function FolderCard (line 59) | function FolderCard({

FILE: src/ui/desktop/navigation/hosts/Host.tsx
  function Host (line 31) | function Host({ host: initialHost }: HostProps): React.ReactElement {

FILE: src/ui/desktop/navigation/tabs/Tab.tsx
  type TabProps (line 23) | interface TabProps {
  function Tab (line 43) | function Tab({

FILE: src/ui/desktop/navigation/tabs/TabContext.tsx
  type Tab (line 14) | type Tab = TabContextTab;
  type TabContextType (line 16) | interface TabContextType {
  function useTabs (line 41) | function useTabs() {
  type TabProviderProps (line 49) | interface TabProviderProps {
  function clearTermixSessionStorage (line 53) | function clearTermixSessionStorage() {
  function TabProvider (line 66) | function TabProvider({ children }: TabProviderProps) {

FILE: src/ui/desktop/navigation/tabs/TabDropdown.tsx
  function TabDropdown (line 26) | function TabDropdown(): React.ReactElement {

FILE: src/ui/desktop/user/ElectronVersionCheck.tsx
  type VersionCheckModalProps (line 8) | interface VersionCheckModalProps {
  function ElectronVersionCheck (line 13) | function ElectronVersionCheck({

FILE: src/ui/desktop/user/LanguageSwitcher.tsx
  function LanguageSwitcher (line 58) | function LanguageSwitcher() {

FILE: src/ui/desktop/user/PasswordReset.tsx
  type PasswordResetProps (line 18) | interface PasswordResetProps {
  function PasswordReset (line 27) | function PasswordReset({ userInfo }: PasswordResetProps) {

FILE: src/ui/desktop/user/TOTPSetup.tsx
  type TOTPSetupProps (line 36) | interface TOTPSetupProps {
  function TOTPSetup (line 41) | function TOTPSetup({

FILE: src/ui/desktop/user/UserProfile.tsx
  type UserProfileProps (line 47) | interface UserProfileProps {
  function handleLogout (line 53) | async function handleLogout() {
  function UserProfile (line 93) | function UserProfile({

FILE: src/ui/hooks/useCommandHistory.ts
  type UseCommandHistoryOptions (line 4) | interface UseCommandHistoryOptions {
  type CommandHistoryResult (line 9) | interface CommandHistoryResult {
  function useCommandHistory (line 17) | function useCommandHistory({

FILE: src/ui/hooks/useCommandTracker.ts
  type UseCommandTrackerOptions (line 4) | interface UseCommandTrackerOptions {
  type CommandTrackerResult (line 10) | interface CommandTrackerResult {
  function useCommandTracker (line 17) | function useCommandTracker({

FILE: src/ui/hooks/useDragToDesktop.ts
  type DragToDesktopState (line 6) | interface DragToDesktopState {
  type UseDragToDesktopProps (line 13) | interface UseDragToDesktopProps {
  type DragToDesktopOptions (line 18) | interface DragToDesktopOptions {
  function useDragToDesktop (line 24) | function useDragToDesktop({ sshSessionId }: UseDragToDesktopProps) {

FILE: src/ui/hooks/useDragToSystemDesktop.ts
  type DragToSystemState (line 6) | interface DragToSystemState {
  type UseDragToSystemProps (line 13) | interface UseDragToSystemProps {
  type DragToSystemOptions (line 18) | interface DragToSystemOptions {
  function useDragToSystemDesktop (line 24) | function useDragToSystemDesktop({ sshSessionId }: UseDragToSystemProps) {

FILE: src/ui/main-axios.ts
  type Role (line 24) | interface Role {
  type UserRole (line 35) | interface UserRole {
  type AccessRecord (line 45) | interface AccessRecord {
  type FileManagerOperation (line 72) | interface FileManagerOperation {
  type ServerStatus (line 80) | type ServerStatus = {
  type SSHHostWithStatus (line 85) | type SSHHostWithStatus = SSHHost & {
  type CpuMetrics (line 89) | interface CpuMetrics {
  type MemoryMetrics (line 95) | interface MemoryMetrics {
  type DiskMetrics (line 101) | interface DiskMetrics {
  type ServerMetrics (line 108) | type ServerMetrics = {
  type AuthResponse (line 115) | interface AuthResponse {
  type UserInfo (line 129) | interface UserInfo {
  type UserCount (line 139) | interface UserCount {
  type OIDCAuthorize (line 143) | interface OIDCAuthorize {
  function isElectron (line 151) | function isElectron(): boolean {
  function getLoggerForService (line 176) | function getLoggerForService(serviceName: string) {
  function setCookie (line 225) | function setCookie(name: string, value: string, days = 7): void {
  function getCookie (line 255) | function getCookie(name: string): string | undefined {
  function createApiInstance (line 284) | function createApiInstance(
  function isDev (line 507) | function isDev(): boolean {
  type ServerConfig (line 526) | interface ServerConfig {
  type AxiosRequestConfigExtended (line 531) | interface AxiosRequestConfigExtended extends AxiosRequestConfig {
  type AxiosResponseExtended (line 536) | interface AxiosResponseExtended extends AxiosResponse {
  type AxiosErrorExtended (line 540) | interface AxiosErrorExtended extends AxiosError {
  function getServerConfig (line 544) | async function getServerConfig(): Promise<ServerConfig | null> {
  function saveServerConfig (line 563) | async function saveServerConfig(config: ServerConfig): Promise<boolean> {
  function getConfiguredServerUrl (line 595) | function getConfiguredServerUrl(): string | null {
  type AxiosRequestConfigExtended (line 599) | interface AxiosRequestConfigExtended extends AxiosRequestConfig {
  type AxiosResponseExtended (line 604) | interface AxiosResponseExtended extends AxiosResponse {
  type AxiosErrorExtended (line 608) | interface AxiosErrorExtended extends AxiosError {
  function testServerConnection (line 612) | async function testServerConnection(
  function checkElectronUpdate (line 634) | async function checkElectronUpdate(): Promise<{
  function getEmbeddedServerStatus (line 669) | async function getEmbeddedServerStatus(): Promise<{
  function isEmbeddedMode (line 696) | function isEmbeddedMode(): boolean {
  function setEmbeddedMode (line 700) | function setEmbeddedMode(value: boolean): void {
  function getApiUrl (line 708) | function getApiUrl(path: string, defaultPort: number): string {
  function initializeApiInstances (line 733) | function initializeApiInstances() {
  function initializeApp (line 789) | function initializeApp() {
  function updateApiInstances (line 831) | function updateApiInstances() {
  class ApiError (line 858) | class ApiError extends Error {
    method constructor (line 859) | constructor(
  function handleApiError (line 869) | function handleApiError(error: unknown, operation: string): never {
  function getSSHHosts (line 1006) | async function getSSHHosts(): Promise<SSHHostWithStatus[]> {
  function createSSHHost (line 1023) | async function createSSHHost(hostData: SSHHostData): Promise<SSHHost> {
  function updateSSHHost (line 1107) | async function updateSSHHost(
  function bulkImportSSHHosts (line 1193) | async function bulkImportSSHHosts(
  function bulkUpdateSSHHosts (line 1215) | async function bulkUpdateSSHHosts(
  function deleteSSHHost (line 1230) | async function deleteSSHHost(
  function getSSHHostById (line 1241) | async function getSSHHostById(hostId: number): Promise<SSHHost> {
  function exportSSHHostWithCredentials (line 1250) | async function exportSSHHostWithCredentials(
  function enableAutoStart (line 1265) | async function enableAutoStart(
  function disableAutoStart (line 1278) | async function disableAutoStart(
  function getAutoStartStatus (line 1291) | async function getAutoStartStatus(): Promise<{
  function testProxyConnection (line 1313) | async function testProxyConnection(options: {
  function getTunnelStatuses (line 1339) | async function getTunnelStatuses(): Promise<
  function getTunnelStatusByName (line 1350) | async function getTunnelStatusByName(
  function connectTunnel (line 1357) | async function connectTunnel(
  function disconnectTunnel (line 1368) | async function disconnectTunnel(
  function cancelTunnel (line 1379) | async function cancelTunnel(
  function getFileManagerRecent (line 1394) | async function getFileManagerRecent(
  function addFileManagerRecent (line 1407) | async function addFileManagerRecent(
  function removeFileManagerRecent (line 1418) | async function removeFileManagerRecent(
  function getFileManagerPinned (line 1431) | async function getFileManagerPinned(
  function addFileManagerPinned (line 1444) | async function addFileManagerPinned(
  function removeFileManagerPinned (line 1455) | async function removeFileManagerPinned(
  function getFileManagerShortcuts (line 1468) | async function getFileManagerShortcuts(
  function addFileManagerShortcut (line 1481) | async function addFileManagerShortcut(
  function removeFileManagerShortcut (line 1492) | async function removeFileManagerShortcut(
  function connectSSH (line 1509) | async function connectSSH(
  function disconnectSSH (line 1568) | async function disconnectSSH(
  function verifySSHTOTP (line 1581) | async function verifySSHTOTP(
  function verifySSHWarpgate (line 1596) | async function verifySSHWarpgate(
  function quickConnect (line 1675) | async function quickConnect(
  function getSSHStatus (line 1686) | async function getSSHStatus(
  function keepSSHAlive (line 1699) | async function keepSSHAlive(
  function listSSHFiles (line 1712) | async function listSSHFiles(
  function identifySSHSymlink (line 1727) | async function identifySSHSymlink(
  function resolveSSHPath (line 1741) | async function resolveSSHPath(
  function readSSHFile (line 1755) | async function readSSHFile(
  function writeSSHFile (line 1783) | async function writeSSHFile(
  function uploadSSHFile (line 1813) | async function uploadSSHFile(
  function downloadSSHFile (line 1836) | async function downloadSSHFile(
  function createSSHFile (line 1855) | async function createSSHFile(
  function createSSHFolder (line 1878) | async function createSSHFolder(
  function deleteSSHItem (line 1899) | async function deleteSSHItem(
  function setSudoPassword (line 1922) | async function setSudoPassword(
  function copySSHItem (line 1936) | async function copySSHItem(
  function renameSSHItem (line 1964) | async function renameSSHItem(
  function moveSSHItem (line 1986) | async function moveSSHItem(
  function changeSSHPermissions (line 2014) | async function changeSSHPermissions(
  function extractSSHArchive (line 2059) | async function extractSSHArchive(
  function compressSSHFiles (line 2104) | async function compressSSHFiles(
  function getRecentFiles (line 2157) | async function getRecentFiles(
  function addRecentFile (line 2171) | async function addRecentFile(
  function removeRecentFile (line 2189) | async function removeRecentFile(
  function getPinnedFiles (line 2204) | async function getPinnedFiles(
  function addPinnedFile (line 2218) | async function addPinnedFile(
  function removePinnedFile (line 2236) | async function removePinnedFile(
  function getFolderShortcuts (line 2251) | async function getFolderShortcuts(
  function addFolderShortcut (line 2265) | async function addFolderShortcut(
  function removeFolderShortcut (line 2283) | async function removeFolderShortcut(
  function getAllServerStatuses (line 2302) | async function getAllServerStatuses(): Promise<
  function getServerStatusById (line 2313) | async function getServerStatusById(id: number): Promise<ServerStatus> {
  function getServerMetricsById (line 2323) | async function getServerMetricsById(id: number): Promise<ServerMetrics> {
  function startMetricsPolling (line 2333) | async function startMetricsPolling(hostId: number): Promise<{
  function stopMetricsPolling (line 2358) | async function stopMetricsPolling(
  function sendMetricsHeartbeat (line 2370) | async function sendMetricsHeartbeat(
  function registerMetricsViewer (line 2381) | async function registerMetricsViewer(
  function unregisterMetricsViewer (line 2395) | async function unregisterMetricsViewer(
  function submitMetricsTOTP (line 2410) | async function submitMetricsTOTP(
  function refreshServerPolling (line 2429) | async function refreshServerPolling(): Promise<void> {
  function notifyHostCreatedOrUpdated (line 2437) | async function notifyHostCreatedOrUpdated(
  function getGlobalMonitoringSettings (line 2451) | async function getGlobalMonitoringSettings(): Promise<{
  function updateGlobalMonitoringSettings (line 2463) | async function updateGlobalMonitoringSettings(settings: {
  function getGuacamoleSettings (line 2478) | async function getGuacamoleSettings(): Promise<{
  function updateGuacamoleSettings (line 2490) | async function updateGuacamoleSettings(settings: {
  function registerUser (line 2505) | async function registerUser(
  function loginUser (line 2520) | async function loginUser(
  function logoutUser (line 2577) | async function logoutUser(): Promise<{
  function getUserInfo (line 2627) | async function getUserInfo(): Promise<UserInfo> {
  function unlockUserData (line 2636) | async function unlockUserData(
  function getRegistrationAllowed (line 2647) | async function getRegistrationAllowed(): Promise<{ allowed: boolean }> {
  function getPasswordLoginAllowed (line 2656) | async function getPasswordLoginAllowed(): Promise<{ allowed: boolean }> {
  function getOIDCConfig (line 2665) | async function getOIDCConfig(): Promise<Record<string, unknown>> {
  function getAdminOIDCConfig (line 2678) | async function getAdminOIDCConfig(): Promise<Record<string, unknown>> {
  function getSetupRequired (line 2687) | async function getSetupRequired(): Promise<{ setup_required: boolean }> {
  function getUserCount (line 2696) | async function getUserCount(): Promise<UserCount> {
  function initiatePasswordReset (line 2705) | async function initiatePasswordReset(
  function verifyPasswordResetCode (line 2716) | async function verifyPasswordResetCode(
  function completePasswordReset (line 2731) | async function completePasswordReset(
  function changePassword (line 2748) | async function changePassword(oldPassword: string, newPassword: string) {
  function getOIDCAuthorizeUrl (line 2760) | async function getOIDCAuthorizeUrl(
  function getUserList (line 2777) | async function getUserList(): Promise<{ users: UserInfo[] }> {
  function getSessions (line 2786) | async function getSessions(): Promise<{
  function revokeSession (line 2808) | async function revokeSession(
  function revokeAllUserSessions (line 2819) | async function revokeAllUserSessions(
  function makeUserAdmin (line 2833) | async function makeUserAdmin(
  function removeAdminStatus (line 2844) | async function removeAdminStatus(
  function deleteUser (line 2855) | async function deleteUser(
  function deleteAccount (line 2868) | async function deleteAccount(
  function updateRegistrationAllowed (line 2881) | async function updateRegistrationAllowed(
  function updatePasswordLoginAllowed (line 2894) | async function updatePasswordLoginAllowed(
  function getPasswordResetAllowed (line 2907) | async function getPasswordResetAllowed(): Promise<boolean> {
  function updatePasswordResetAllowed (line 2916) | async function updatePasswordResetAllowed(
  function updateOIDCConfig (line 2929) | async function updateOIDCConfig(
  function disableOIDCConfig (line 2940) | async function disableOIDCConfig(): Promise<Record<string, unknown>> {
  function setupTOTP (line 2953) | async function setupTOTP(): Promise<{
  function enableTOTP (line 2966) | async function enableTOTP(
  function disableTOTP (line 2978) | async function disableTOTP(
  function verifyTOTPLogin (line 2994) | async function verifyTOTPLogin(
  function generateBackupCodes (line 3041) | async function generateBackupCodes(
  function getUserAlerts (line 3057) | async function getUserAlerts(): Promise<{
  function dismissAlert (line 3068) | async function dismissAlert(
  function getReleasesRSS (line 3083) | async function getReleasesRSS(
  function getVersionInfo (line 3094) | async function getVersionInfo(): Promise<Record<string, unknown>> {
  function getDatabaseHealth (line 3107) | async function getDatabaseHealth(): Promise<Record<string, unknown>> {
  function getCredentials (line 3120) | async function getCredentials(): Promise<Record<string, unknown>> {
  function getCredentialDetails (line 3129) | async function getCredentialDetails(
  function createCredential (line 3140) | async function createCredential(
  function updateCredential (line 3151) | async function updateCredential(
  function deleteCredential (line 3166) | async function deleteCredential(
  function getCredentialHosts (line 3177) | async function getCredentialHosts(
  function getCredentialFolders (line 3188) | async function getCredentialFolders(): Promise<Record<string, unknown>> {
  function getSSHHostWithCredentials (line 3197) | async function getSSHHostWithCredentials(
  function applyCredentialToHost (line 3210) | async function applyCredentialToHost(
  function removeCredentialFromHost (line 3225) | async function removeCredentialFromHost(
  function migrateHostToCredential (line 3236) | async function migrateHostToCredential(
  function getFoldersWithStats (line 3255) | async function getFoldersWithStats(): Promise<Record<string, unknown>> {
  function renameFolder (line 3264) | async function renameFolder(
  function getSSHFolders (line 3279) | async function getSSHFolders(): Promise<SSHFolder[]> {
  function updateFolderMetadata (line 3302) | async function updateFolderMetadata(
  function deleteAllHostsInFolder (line 3335) | async function deleteAllHostsInFolder(
  function renameCredentialFolder (line 3365) | async function renameCredentialFolder(
  function detectKeyType (line 3380) | async function detectKeyType(
  function detectPublicKeyType (line 3395) | async function detectPublicKeyType(
  function validateKeyPair (line 3408) | async function validateKeyPair(
  function generatePublicKeyFromPrivate (line 3425) | async function generatePublicKeyFromPrivate(
  function generateKeyPair (line 3440) | async function generateKeyPair(
  function deployCredentialToHost (line 3457) | async function deployCredentialToHost(
  function getSnippets (line 3476) | async function getSnippets(): Promise<Record<string, unknown>> {
  function createSnippet (line 3485) | async function createSnippet(
  function updateSnippet (line 3496) | async function updateSnippet(
  function deleteSnippet (line 3508) | async function deleteSnippet(
  function executeSnippet (line 3519) | async function executeSnippet(
  type NetworkTopologyData (line 3538) | interface NetworkTopologyData {
  function getNetworkTopology (line 3543) | async function getNetworkTopology(): Promise<NetworkTopologyData | null> {
  function saveNetworkTopology (line 3552) | async function saveNetworkTopology(
  function getSnippetFolders (line 3563) | async function getSnippetFolders(): Promise<Record<string, unknown>> {
  function createSnippetFolder (line 3572) | async function createSnippetFolder(folderData: {
  function updateSnippetFolderMetadata (line 3585) | async function updateSnippetFolderMetadata(
  function renameSnippetFolder (line 3600) | async function renameSnippetFolder(
  function deleteSnippetFolder (line 3615) | async function deleteSnippetFolder(
  function reorderSnippets (line 3628) | async function reorderSnippets(
  type UptimeInfo (line 3643) | interface UptimeInfo {
  type RecentActivityItem (line 3649) | interface RecentActivityItem {
  function getUptime (line 3666) | async function getUptime(): Promise<UptimeInfo> {
  function getRecentActivity (line 3675) | async function getRecentActivity(
  function logActivity (line 3688) | async function logActivity(
  function resetRecentActivity (line 3713) | async function resetRecentActivity(): Promise<{ message: string }> {
  function saveCommandToHistory (line 3726) | async function saveCommandToHistory(
  function getCommandHistory (line 3741) | async function getCommandHistory(
  function deleteCommandFromHistory (line 3755) | async function deleteCommandFromHistory(
  function clearCommandHistory (line 3770) | async function clearCommandHistory(
  function linkOIDCToPasswordAccount (line 3787) | async function linkOIDCToPasswordAccount(
  function unlinkOIDCFromPasswordAccount (line 3802) | async function unlinkOIDCFromPasswordAccount(
  type GuacamoleTokenRequest (line 3815) | interface GuacamoleTokenRequest {
  type GuacamoleTokenResponse (line 3885) | interface GuacamoleTokenResponse {
  function toGuacamoleParams (line 3889) | function toGuacamoleParams(
  function getGuacamoleToken (line 3964) | async function getGuacamoleToken(
  function getGuacamoleTokenFromHost (line 3987) | async function getGuacamoleTokenFromHost(
  function getRoles (line 4002) | async function getRoles(): Promise<{ roles: Role[] }> {
  function createRole (line 4011) | async function createRole(roleData: {
  function updateRole (line 4024) | async function updateRole(
  function deleteRole (line 4039) | async function deleteRole(
  function getUserRoles (line 4050) | async function getUserRoles(
  function assignRoleToUser (line 4061) | async function assignRoleToUser(
  function removeRoleFromUser (line 4075) | async function removeRoleFromUser(
  function shareHost (line 4089) | async function shareHost(
  function getHostAccess (line 4110) | async function getHostAccess(
  function revokeHostAccess (line 4121) | async function revokeHostAccess(
  function connectDockerSession (line 4139) | async function connectDockerSession(
  function verifyDockerTOTP (line 4198) | async function verifyDockerTOTP(
  function verifyDockerWarpgate (line 4213) | async function verifyDockerWarpgate(
  function disconnectDockerSession (line 4226) | async function disconnectDockerSession(
  function keepaliveDockerSession (line 4239) | async function keepaliveDockerSession(
  function getDockerSessionStatus (line 4252) | async function getDockerSessionStatus(
  function validateDockerAvailability (line 4265) | async function validateDockerAvailability(
  function listDockerContainers (line 4276) | async function listDockerContainers(
  function getDockerContainerDetails (line 4290) | async function getDockerContainerDetails(
  function startDockerContainer (line 4304) | async function startDockerContainer(
  function stopDockerContainer (line 4318) | async function stopDockerContainer(
  function restartDockerContainer (line 4332) | async function restartDockerContainer(
  function pauseDockerContainer (line 4346) | async function pauseDockerContainer(
  function unpauseDockerContainer (line 4360) | async function unpauseDockerContainer(
  function removeDockerContainer (line 4374) | async function removeDockerContainer(
  function getContainerLogs (line 4392) | async function getContainerLogs(
  function downloadContainerLogs (line 4410) | async function downloadContainerLogs(
  function getContainerStats (line 4429) | async function getContainerStats(
  type DashboardLayout (line 4443) | interface DashboardLayout {
  function getDashboardPreferences (line 4447) | async function getDashboardPreferences(): Promise<DashboardLayout> {
  function saveDashboardPreferences (line 4452) | async function saveDashboardPreferences(

FILE: src/ui/mobile/MobileApp.tsx
  function isReactNativeWebView (line 22) | function isReactNativeWebView(): boolean {
  function handleKeyboardInput (line 119) | function handleKeyboardInput(input: string) {
  class TabErrorBoundary (line 236) | class TabErrorBoundary extends Component<
    method constructor (line 240) | constructor(props: { children: ReactNode }) {
    method getDerivedStateFromError (line 245) | static getDerivedStateFromError(error: Error) {
    method componentDidCatch (line 252) | componentDidCatch(error: Error, errorInfo: ErrorInfo) {
    method render (line 264) | render() {

FILE: src/ui/mobile/apps/navigation/BottomNavbar.tsx
  type MenuProps (line 6) | interface MenuProps {
  function BottomNavbar (line 10) | function BottomNavbar({ onSidebarOpenClick }: MenuProps) {

FILE: src/ui/mobile/apps/navigation/LeftSidebar.tsx
  type SSHHost (line 27) | interface SSHHost {
  type LeftSidebarProps (line 57) | interface LeftSidebarProps {
  function handleLogout (line 65) | async function handleLogout() {
  function LeftSidebar (line 76) | function LeftSidebar({

FILE: src/ui/mobile/apps/navigation/hosts/FolderCard.tsx
  type SSHHost (line 8) | interface SSHHost {
  type FolderCardProps (line 38) | interface FolderCardProps {
  function FolderCard (line 44) | function FolderCard({

FILE: src/ui/mobile/apps/navigation/hosts/Host.tsx
  function Host (line 10) | function Host({ host, onHostConnect }: HostProps): React.ReactElement {

FILE: src/ui/mobile/apps/navigation/tabs/TabContext.tsx
  type Tab (line 10) | type Tab = TabContextTab;
  type TabContextType (line 12) | interface TabContextType {
  function useTabs (line 23) | function useTabs() {
  type TabProviderProps (line 31) | interface TabProviderProps {
  function TabProvider (line 35) | function TabProvider({ children }: TabProviderProps) {

FILE: src/ui/mobile/apps/terminal/Terminal.tsx
  type HostConfig (line 35) | interface HostConfig {
  type TerminalHandle (line 51) | interface TerminalHandle {
  type SSHTerminalProps (line 59) | interface SSHTerminalProps {
  function hardRefresh (line 173) | function hardRefresh() {
  function performFit (line 190) | function performFit() {
  function scheduleNotify (line 215) | function scheduleNotify(cols: number, rows: number) {
  function handleTotpSubmit (line 233) | function handleTotpSubmit(code: string) {
  function handleTotpCancel (line 251) | function handleTotpCancel() {
  function handleWarpgateContinue (line 261) | function handleWarpgateContinue() {
  function handleWarpgateCancel (line 279) | function handleWarpgateCancel() {
  function handleWarpgateOpenUrl (line 290) | function handleWarpgateOpenUrl() {
  function handleAuthDialogSubmit (line 296) | function handleAuthDialogSubmit(credentials: {
  function handleAuthDialogCancel (line 325) | function handleAuthDialogCancel() {
  function attemptReconnection (line 386) | function attemptReconnection() {
  function connectToHost (line 475) | function connectToHost(cols: number, rows: number) {
  function setupWebSocketListeners (line 549) | function setupWebSocketListeners(

FILE: src/ui/mobile/apps/terminal/TerminalKeyboard.tsx
  type TerminalKeyboardProps (line 8) | interface TerminalKeyboardProps {
  function TerminalKeyboard (line 13) | function TerminalKeyboard({

FILE: src/ui/mobile/authentication/Auth.tsx
  function isReactNativeWebView (line 31) | function isReactNativeWebView(): boolean {
  function postJWTToWebView (line 35) | function postJWTToWebView() {
  type AuthProps (line 61) | interface AuthProps extends React.ComponentProps<"div"> {
  function Auth (line 77) | function Auth({

FILE: src/ui/mobile/navigation/BottomNavbar.tsx
  type MenuProps (line 6) | interface MenuProps {
  function BottomNavbar (line 10) | function BottomNavbar({ onSidebarOpenClick }: MenuProps) {

FILE: src/ui/mobile/navigation/LeftSidebar.tsx
  type SSHHost (line 29) | interface SSHHost {
  type LeftSidebarProps (line 60) | interface LeftSidebarProps {
  function handleLogout (line 68) | async function handleLogout() {
  function LeftSidebar (line 78) | function LeftSidebar({

FILE: src/ui/mobile/navigation/hosts/FolderCard.tsx
  type SSHHost (line 8) | interface SSHHost {
  type FolderCardProps (line 38) | interface FolderCardProps {
  function FolderCard (line 44) | function FolderCard({

FILE: src/ui/mobile/navigation/hosts/Host.tsx
  function Host (line 11) | function Host({ host, onHostConnect }: HostProps): React.ReactElement {

FILE: src/ui/mobile/navigation/tabs/TabContext.tsx
  type Tab (line 10) | type Tab = TabContextTab;
  type TabContextType (line 12) | interface TabContextType {
  function useTabs (line 23) | function useTabs() {
  type TabProviderProps (line 31) | interface TabProviderProps {
  function TabProvider (line 35) | function TabProvider({ children }: TabProviderProps) {