windmill-components 1.493.10 → 1.501.4

package/package/githubApp.d.ts

@@ -0,0 +1,58 @@
+import { type GetGlobalConnectedRepositoriesResponse } from './gen';
+export interface GitHubAppState {
+    loadingGithubInstallations: boolean;
+    githubInstallations: GetGlobalConnectedRepositoriesResponse;
+    workspaceGithubInstallations: GetGlobalConnectedRepositoriesResponse;
+    selectedGHAppAccountId: string | undefined;
+    selectedGHAppRepository: string | undefined;
+    githubInstallationUrl: string | undefined;
+    installationCheckInterval: number | undefined;
+    isCheckingInstallation: boolean;
+    importJwt: string;
+}
+export interface GitHubRepository {
+    name: string;
+    url: string;
+}
+export interface GitHubAppError extends Error {
+    code: 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTH_ERROR' | 'UNKNOWN_ERROR';
+    details?: unknown;
+}
+export declare function createGitHubAppState(): GitHubAppState;
+/**
+ * Loads GitHub installations for the current workspace
+ */
+export declare function loadGithubInstallations(state: GitHubAppState, currentWorkspace: string): Promise<void>;
+/**
+ * Starts polling for new GitHub installations
+ */
+export declare function startInstallationCheck(state: GitHubAppState, currentWorkspace: string, onInstallationFound?: () => void): void;
+export declare function stopInstallationCheck(state: GitHubAppState): void;
+/**
+ * Gets repositories for a specific GitHub account
+ */
+export declare function getRepositories(state: GitHubAppState, accountId: string): GitHubRepository[];
+/**
+ * Adds a GitHub installation to the current workspace
+ */
+export declare function addInstallationToWorkspace(currentWorkspace: string, installationId: number, sourceWorkspaceId: string, onSuccess?: () => void): Promise<void>;
+/**
+ * Deletes a GitHub installation from the current workspace
+ */
+export declare function deleteInstallation(currentWorkspace: string, installationId: number, onSuccess?: () => void): Promise<void>;
+/**
+ * Exports a GitHub installation as a JWT token
+ */
+export declare function exportInstallation(currentWorkspace: string, installationId: number): Promise<void>;
+/**
+ * Imports a GitHub installation using a JWT token
+ */
+export declare function importInstallation(currentWorkspace: string, jwt: string, onSuccess?: () => void): Promise<void>;
+/**
+ * Applies the selected repository URL to the form arguments
+ */
+export declare function applyRepositoryURL(state: GitHubAppState, args: Record<string, any>, description: string, onArgsUpdate: (newArgs: Record<string, any>) => void, onDescriptionUpdate: (newDescription: string) => void): void;
+/**
+ * Handles the install button click
+ */
+export declare function handleInstallClick(state: GitHubAppState, currentWorkspace: string, onInstallationFound?: () => void): void;

package/package/githubApp.js

@@ -0,0 +1,338 @@
+import { GitSyncService } from './gen';
+import { sendUserToast } from './toast';
+import { base } from './base';
+/**
+ * Creates a standardized GitHub App error
+ */
+function createGitHubAppError(message, code, details) {
+    const error = new Error(message);
+    error.code = code;
+    error.details = details;
+    return error;
+}
+/**
+ * Validates JWT token format
+ */
+function validateJwtToken(token) {
+    if (!token || typeof token !== 'string')
+        return false;
+    // Basic JWT structure validation (header.payload.signature)
+    const parts = token.trim().split('.');
+    if (parts.length !== 3)
+        return false;
+    // Check if each part is valid base64
+    try {
+        parts.forEach((part) => {
+            if (!part)
+                throw new Error('Empty JWT part');
+            // Add padding if needed for base64 decoding
+            const padded = part + '='.repeat((4 - (part.length % 4)) % 4);
+            atob(padded.replace(/-/g, '+').replace(/_/g, '/'));
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Handles errors consistently across GitHub App operations
+ */
+function handleGitHubAppError(error, operation) {
+    console.error(`GitHub App ${operation} failed:`, error);
+    // Check if it's already a GitHubAppError by checking for the code property
+    if (error && typeof error === 'object' && 'code' in error && 'message' in error) {
+        return error;
+    }
+    if (error instanceof Error) {
+        if (error.message.includes('401') || error.message.includes('403')) {
+            return createGitHubAppError(`Authentication failed during ${operation}`, 'AUTH_ERROR', error);
+        }
+        if (error.message.includes('network') || error.message.includes('fetch')) {
+            return createGitHubAppError(`Network error during ${operation}`, 'NETWORK_ERROR', error);
+        }
+    }
+    return createGitHubAppError(`Unknown error during ${operation}`, 'UNKNOWN_ERROR', error);
+}
+export function createGitHubAppState() {
+    return {
+        loadingGithubInstallations: false,
+        githubInstallations: [],
+        workspaceGithubInstallations: [],
+        selectedGHAppAccountId: undefined,
+        selectedGHAppRepository: undefined,
+        githubInstallationUrl: undefined,
+        installationCheckInterval: undefined,
+        isCheckingInstallation: false,
+        importJwt: ''
+    };
+}
+/**
+ * Loads GitHub installations for the current workspace
+ */
+export async function loadGithubInstallations(state, currentWorkspace) {
+    if (!currentWorkspace) {
+        throw createGitHubAppError('Workspace is required', 'VALIDATION_ERROR');
+    }
+    try {
+        state.loadingGithubInstallations = true;
+        const installations = await GitSyncService.getGlobalConnectedRepositories();
+        const workspaceInstallations = installations.filter((installation) => installation.workspace_id === currentWorkspace);
+        // Update state in a way that ensures Svelte 5 reactivity
+        state.githubInstallations = [...installations];
+        state.workspaceGithubInstallations = [...workspaceInstallations];
+        const stateParam = encodeURIComponent(JSON.stringify({
+            workspace_id: currentWorkspace,
+            base_url: window.location.origin + base
+        }));
+        state.githubInstallationUrl = `https://github.com/apps/windmill-sync-helper/installations/new?state=${stateParam}`;
+    }
+    catch (err) {
+        const githubError = handleGitHubAppError(err, 'load installations');
+        sendUserToast(`Failed to load GitHub installations: ${githubError.message}`, true);
+        // Reset state on error
+        state.githubInstallations = [];
+        state.workspaceGithubInstallations = [];
+        throw githubError;
+    }
+    finally {
+        state.loadingGithubInstallations = false;
+    }
+}
+/**
+ * Starts polling for new GitHub installations
+ */
+export function startInstallationCheck(state, currentWorkspace, onInstallationFound) {
+    if (!currentWorkspace) {
+        throw createGitHubAppError('Workspace is required', 'VALIDATION_ERROR');
+    }
+    // Stop any existing check first
+    stopInstallationCheck(state);
+    // Remember initial count to detect new installations
+    const initialInstallationCount = state.githubInstallations.length;
+    state.isCheckingInstallation = true;
+    let pollCount = 0;
+    const maxPolls = 150; // 5 minutes (150 * 2 seconds)
+    state.installationCheckInterval = window.setInterval(async () => {
+        pollCount++;
+        // Stop polling after timeout
+        if (pollCount >= maxPolls) {
+            stopInstallationCheck(state);
+            return;
+        }
+        try {
+            const installations = await GitSyncService.getGlobalConnectedRepositories();
+            // Check if we have MORE installations than when we started
+            if (installations.length > initialInstallationCount) {
+                stopInstallationCheck(state);
+                state.githubInstallations = [...installations];
+                state.workspaceGithubInstallations = [
+                    ...installations.filter((installation) => installation.workspace_id === currentWorkspace)
+                ];
+                // Call callback with delay to allow popover to open
+                if (onInstallationFound) {
+                    setTimeout(onInstallationFound, 100);
+                }
+            }
+        }
+        catch (error) {
+            const githubError = handleGitHubAppError(error, 'check installations');
+            console.error('Installation check failed:', githubError);
+            // Continue polling despite errors
+        }
+    }, 2000);
+}
+export function stopInstallationCheck(state) {
+    if (state.installationCheckInterval) {
+        clearInterval(state.installationCheckInterval);
+        state.installationCheckInterval = undefined;
+    }
+    state.isCheckingInstallation = false;
+}
+/**
+ * Gets repositories for a specific GitHub account
+ */
+export function getRepositories(state, accountId) {
+    if (!accountId)
+        return [];
+    return (state.githubInstallations.find((installation) => installation.account_id === accountId)
+        ?.repositories || []);
+}
+/**
+ * Adds a GitHub installation to the current workspace
+ */
+export async function addInstallationToWorkspace(currentWorkspace, installationId, sourceWorkspaceId, onSuccess) {
+    // Input validation
+    if (!currentWorkspace) {
+        throw createGitHubAppError('Current workspace is required', 'VALIDATION_ERROR');
+    }
+    if (!installationId || installationId <= 0) {
+        throw createGitHubAppError('Valid installation ID is required', 'VALIDATION_ERROR');
+    }
+    if (!sourceWorkspaceId) {
+        throw createGitHubAppError('Source workspace ID is required', 'VALIDATION_ERROR');
+    }
+    try {
+        await GitSyncService.installFromWorkspace({
+            workspace: currentWorkspace,
+            requestBody: {
+                source_workspace_id: sourceWorkspaceId,
+                installation_id: installationId
+            }
+        });
+        sendUserToast('Successfully added installation to workspace', false);
+        onSuccess?.();
+    }
+    catch (err) {
+        const githubError = handleGitHubAppError(err, 'add installation to workspace');
+        sendUserToast(`Failed to add installation: ${githubError.message}`, true);
+        throw githubError;
+    }
+}
+/**
+ * Deletes a GitHub installation from the current workspace
+ */
+export async function deleteInstallation(currentWorkspace, installationId, onSuccess) {
+    // Input validation
+    if (!currentWorkspace) {
+        throw createGitHubAppError('Workspace is required', 'VALIDATION_ERROR');
+    }
+    if (!installationId || installationId <= 0) {
+        throw createGitHubAppError('Valid installation ID is required', 'VALIDATION_ERROR');
+    }
+    try {
+        await GitSyncService.deleteFromWorkspace({
+            workspace: currentWorkspace,
+            installationId: installationId
+        });
+        sendUserToast('Successfully deleted installation', false);
+        onSuccess?.();
+    }
+    catch (err) {
+        const githubError = handleGitHubAppError(err, 'delete installation');
+        sendUserToast(`Failed to delete installation: ${githubError.message}`, true);
+        throw githubError;
+    }
+}
+/**
+ * Exports a GitHub installation as a JWT token
+ */
+export async function exportInstallation(currentWorkspace, installationId) {
+    // Input validation
+    if (!currentWorkspace) {
+        throw createGitHubAppError('Workspace is required', 'VALIDATION_ERROR');
+    }
+    if (!installationId || installationId <= 0) {
+        throw createGitHubAppError('Valid installation ID is required', 'VALIDATION_ERROR');
+    }
+    try {
+        const response = await GitSyncService.exportInstallation({
+            workspace: currentWorkspace,
+            installationId: installationId
+        });
+        if (!response.jwt_token) {
+            throw createGitHubAppError('No JWT token received from server', 'UNKNOWN_ERROR');
+        }
+        const jwtToken = response.jwt_token;
+        // Copy to clipboard with fallback for unsecure contexts
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+            await navigator.clipboard.writeText(jwtToken);
+            sendUserToast('JWT token copied to clipboard. This token is sensitive and should be kept secret!', false, undefined, undefined, 10000);
+        }
+        else {
+            // Fallback: show the token in the toast for manual copying
+            sendUserToast(`JWT token (copy manually): ${jwtToken}`, false, [
+                {
+                    label: 'Copy',
+                    callback: () => {
+                        // Try to copy using the older execCommand method as fallback
+                        const textArea = document.createElement('textarea');
+                        textArea.value = jwtToken;
+                        document.body.appendChild(textArea);
+                        textArea.select();
+                        try {
+                            document.execCommand('copy');
+                            sendUserToast('JWT token copied to clipboard!', false);
+                        }
+                        catch (err) {
+                            console.error('Failed to copy to clipboard:', err);
+                            sendUserToast('Could not copy to clipboard. Please copy manually.', true);
+                        }
+                        document.body.removeChild(textArea);
+                    }
+                }
+            ], undefined, 15000);
+        }
+    }
+    catch (err) {
+        const githubError = handleGitHubAppError(err, 'export installation');
+        sendUserToast(`Failed to export installation: ${githubError.message}`, true);
+        throw githubError;
+    }
+}
+/**
+ * Imports a GitHub installation using a JWT token
+ */
+export async function importInstallation(currentWorkspace, jwt, onSuccess) {
+    // Input validation
+    if (!currentWorkspace) {
+        throw createGitHubAppError('Workspace is required', 'VALIDATION_ERROR');
+    }
+    if (!jwt || !validateJwtToken(jwt)) {
+        throw createGitHubAppError('Valid JWT token is required', 'VALIDATION_ERROR');
+    }
+    try {
+        await GitSyncService.importInstallation({
+            workspace: currentWorkspace,
+            requestBody: { jwt_token: jwt.trim() }
+        });
+        sendUserToast('Installation imported successfully', false);
+        onSuccess?.();
+    }
+    catch (err) {
+        const githubError = handleGitHubAppError(err, 'import installation');
+        sendUserToast(`Failed to import installation: ${githubError.message}`, true);
+        throw githubError;
+    }
+}
+/**
+ * Applies the selected repository URL to the form arguments
+ */
+export function applyRepositoryURL(state, args, description, onArgsUpdate, onDescriptionUpdate) {
+    if (!state.selectedGHAppRepository) {
+        throw createGitHubAppError('No repository selected', 'VALIDATION_ERROR');
+    }
+    // Validate args object
+    if (!args || typeof args !== 'object') {
+        throw createGitHubAppError('Invalid arguments object', 'VALIDATION_ERROR');
+    }
+    const newArgs = {
+        ...args,
+        url: state.selectedGHAppRepository,
+        is_github_app: true
+    };
+    // Check if description already contains GitHub App text to avoid duplication
+    const githubAppText = `Repository ${state.selectedGHAppRepository} with permissions fetched using Windmill Github App.`;
+    const existingDescription = description ?? '';
+    const newDescription = existingDescription.includes('with permissions fetched using Windmill Github App')
+        ? existingDescription.replace(/Repository [^ ]+ with permissions fetched using Windmill Github App\. ?/, githubAppText + ' ')
+        : `${githubAppText} ${existingDescription}`.trim();
+    try {
+        onArgsUpdate(newArgs);
+        onDescriptionUpdate(newDescription);
+    }
+    catch (err) {
+        const githubError = handleGitHubAppError(err, 'apply repository URL');
+        throw githubError;
+    }
+}
+/**
+ * Handles the install button click
+ */
+export function handleInstallClick(state, currentWorkspace, onInstallationFound) {
+    if (state.githubInstallations.length === 0) {
+        if (!state.isCheckingInstallation) {
+            startInstallationCheck(state, currentWorkspace, onInstallationFound);
+        }
+    }
+}

package/package/hubPaths.json

@@ -7,7 +7,8 @@
 	"gitSync_5": "hub/11641/sync-script-to-git-repo-windmill",
 	"gitSync_6": "hub/11666/sync-script-to-git-repo-windmill",
 	"gitSync_7": "hub/11668/sync-script-to-git-repo-windmill",
-	"gitSync": "hub/19673/sync-script-to-git-repo-windmill",
+	"gitSync_8": "hub/19673/sync-script-to-git-repo-windmill",
+	"gitSync": "hub/19738/sync-script-to-git-repo-windmill",
 	"gitSyncTest_0": "hub/9073/git-repo-test-read-write-windmill",
 	"gitSyncTest_1": "hub/11499/git-repo-test-read-write-windmill",
 	"gitSyncTest_2": "hub/11667/git-repo-test-read-write-windmill",

package/package/logout.js

@@ -3,14 +3,18 @@ import { UserService } from './gen';
 import { clearStores } from './storeUtils';
 import { sendUserToast } from './toast';
 export async function logoutWithRedirect(rd) {
+    console.log('logoutWithRedirect', rd);
     await clearUser();
-    if (rd && rd != '/' && rd?.split('?')[0] != '/user/login') {
+    const splitted = rd?.split('?')[0];
+    if (rd && rd != '/' && splitted != '/user/login' && splitted != '/user/logout') {
         const error = document.cookie.includes('token')
             ? `error=${encodeURIComponent('You have been logged out because your session has expired.')}&`
             : '';
+        console.log('login redirect with error', error, rd);
         goto(`/user/login?${error}${rd ? 'rd=' + encodeURIComponent(rd) : ''}`, { replaceState: true });
     }
     else {
+        console.log('login redirect vanilla');
         goto('/user/login', { replaceState: true });
     }
 }

package/package/process.d.ts.txt

@@ -174,7 +174,6 @@ declare module 'process' {
 				WM_STATE_PATH: string
 				WM_FLOW_STEP_ID: string
 				WM_OBJECT_PATH: string
-				WM_OIDC_JWT: string
 				WM_WORKER_GROUP: string
 			}
 			interface HRTime {

package/package/refreshUser.js

@@ -1,7 +1,6 @@
 import { get } from 'svelte/store';
 import { UserService } from './gen';
 import { superadmin, devopsRole } from './stores.js';
-import { goto } from './navigation';
 export async function refreshSuperadmin() {
     if (get(superadmin) == undefined) {
         try {
@@ -15,7 +14,7 @@ export async function refreshSuperadmin() {
         }
         catch {
             superadmin.set(false);
-            goto('/user/logout');
+            // goto('/user/logout')
         }
     }
     if (get(devopsRole) == undefined) {
@@ -30,7 +29,7 @@ export async function refreshSuperadmin() {
         }
         catch {
             devopsRole.set(false);
-            goto('/user/logout');
+            // goto('/user/logout')
         }
     }
 }

package/package/scripts.d.ts

@@ -1,6 +1,6 @@
 import type { Schema, SupportedLanguage } from './common';
 import { type Script } from './gen';
-export declare function scriptLangToEditorLang(lang: Script['language'] | 'bunnative' | 'javascript' | 'frontend' | 'jsx' | 'tsx' | 'text' | 'json' | undefined): "sql" | "go" | "powershell" | "graphql" | "php" | "rust" | "csharp" | "nu" | "java" | "javascript" | "text" | "yaml" | "typescript" | "json" | "python" | "shell";
+export declare function scriptLangToEditorLang(lang: Script['language'] | 'bunnative' | 'javascript' | 'frontend' | 'jsx' | 'tsx' | 'text' | 'json' | undefined): "javascript" | "go" | "powershell" | "graphql" | "php" | "sql" | "rust" | "csharp" | "nu" | "java" | "yaml" | "json" | "text" | "typescript" | "python" | "shell";
 export type ScriptSchedule = {
     summary: string | undefined;
     args: Record<string, any>;

package/package/svelte5Utils.svelte.d.ts

@@ -1,4 +1,26 @@
+import type { StateStore } from './utils';
 export declare function withProps<Component, Props>(component: Component, props: Props): {
     component: Component;
     props: Props;
 };
+export declare function stateSnapshot<T>(state: T): $state.Snapshot<T>;
+export declare function refreshStateStore<T>(store: StateStore<T>): void;
+export type UsePromiseResult<T> = ({
+    status: 'loading';
+    value?: undefined;
+    error?: undefined;
+} | {
+    status: 'error';
+    error: any;
+    value?: undefined;
+} | {
+    status: 'ok';
+    value: T;
+    error?: undefined;
+}) & {
+    refresh: () => void;
+};
+export type UsePromiseOptions = {
+    loadInit?: boolean;
+};
+export declare function usePromise<T>(createPromise: () => Promise<T>, { loadInit }?: UsePromiseOptions): UsePromiseResult<T>;

package/package/svelte5Utils.svelte.js

@@ -6,3 +6,38 @@ export function withProps(component, props) {
     });
     return ret;
 }
+export function stateSnapshot(state) {
+    return $state.snapshot(state);
+}
+export function refreshStateStore(store) {
+    store.val = $state.snapshot(store.val);
+}
+export function usePromise(createPromise, { loadInit = true } = {}) {
+    const ret = $state({
+        status: 'loading',
+        __promise: undefined,
+        refresh: () => {
+            let promise = createPromise();
+            ret.__promise = promise;
+            ret.status = 'loading';
+            ret.value = undefined;
+            ret.error = undefined;
+            promise
+                .then((value) => {
+                if (ret.__promise !== promise)
+                    return;
+                ret.value = value;
+                ret.status = 'ok';
+            })
+                .catch((error) => {
+                if (ret.__promise !== promise)
+                    return;
+                ret.error = error;
+                ret.status = 'error';
+            });
+        }
+    });
+    if (loadInit)
+        ret.refresh();
+    return ret;
+}

package/package/utils.d.ts

@@ -1,14 +1,39 @@
 import { type UserExt } from './stores';
 import { sendUserToast } from './toast';
-import type { Job, Script } from './gen';
+import type { Job, Script, ScriptLang } from './gen';
 import type { EnumType, SchemaProperty } from './common';
 import type { Schema } from './common';
 export { sendUserToast };
 import type { AnyMeltElement } from '@melt-ui/svelte';
 import type { RunsSelectionMode } from './components/runs/RunsBatchActionsDropdown.svelte';
 import type { TriggerKind } from './components/triggers';
+export declare namespace OpenApi {
+    enum OpenApiVersion {
+        V2 = 0,
+        V3 = 1,
+        V3_1 = 2
+    }
+    function isV2(doc: OpenAPI.Document): doc is OpenAPIV2.Document;
+    function isV3(doc: OpenAPI.Document): doc is OpenAPIV3.Document;
+    function isV3_1(doc: OpenAPI.Document): doc is OpenAPIV3_1.Document;
+    function getOpenApiVersion(version: string): OpenApiVersion;
+    /**
+     * Parses and validates an OpenAPI specification provided as a string in either JSON or YAML format.
+     *
+     * @param api - A string containing a valid OpenAPI specification in JSON or YAML format.
+     * @returns A promise that resolves to a tuple:
+     *   - The first element is the validated OpenAPI document.
+     *   - The second element is the detected OpenAPI version (2, 3.0, or 3.1).
+     *
+     * @throws Will throw an error if the specification is invalid or cannot be parsed.
+     */
+    function parse(api: string): Promise<[OpenAPI.Document, OpenApiVersion]>;
+}
 export declare function isJobCancelable(j: Job): boolean;
 export declare function isJobReRunnable(j: Job): boolean;
+export declare const WORKER_NAME_PREFIX = "wk";
+export declare const AGENT_WORKER_NAME_PREFIX = "ag";
+export declare function isAgentWorkerShell(workerName: string): boolean;
 export declare function isJobSelectable(selectionType: RunsSelectionMode): (j: Job) => boolean;
 export declare function validateUsername(username: string): string;
 export declare function parseQueryParams(url: string | undefined): Record<string, string>;
@@ -30,6 +55,7 @@ interface ClickOutsideOptions {
     exclude?: (() => Promise<HTMLElement[]>) | HTMLElement[] | undefined;
     stopPropagation?: boolean;
     customEventName?: string;
+    onClickOutside?: (event: MouseEvent) => void;
 }
 export declare function clickOutside(node: Node, options?: ClickOutsideOptions | boolean): {
     destroy(): void;
@@ -74,15 +100,20 @@ export declare function isString(value: any): value is string | String;
 export type InputCat = 'string' | 'email' | 'number' | 'boolean' | 'list' | 'resource-object' | 'enum' | 'date' | 'base64' | 'resource-string' | 'object' | 'sql' | 'yaml' | 'currency' | 'oneOf' | 'dynselect';
 export declare function setInputCat(type: string | undefined, format: string | undefined, itemsType: string | undefined, enum_: any, contentEncoding: string | undefined): InputCat;
 export declare function formatCron(inp: string): string;
+export declare function scriptLangArrayToCommaList(languages: ScriptLang[]): string;
 export declare function cronV1toV2(inp: string): string;
 export declare function classNames(...classes: Array<string | undefined>): string;
+export declare function download(filename: string, fileContent: string, mimeType?: string): void;
 export declare function copyToClipboard(value?: string, sendToast?: boolean): Promise<boolean>;
 export declare function pluralize(quantity: number, word: string, customPlural?: string): string;
 export declare function addDeterminant(word: string): string;
 export declare function capitalize(word: string): string;
 export declare function addWhitespaceBeforeCapitals(word?: string): string;
 export declare function isObject(obj: any): obj is Record<string, any>;
-export declare function debounce(func: (...args: any[]) => any, wait: number): (...args: any[]) => void;
+export declare function debounce(func: (...args: any[]) => any, wait: number): {
+    debounced: (...args: any[]) => void;
+    clearDebounce: () => void;
+};
 export declare function throttle<T>(func: (...args: any[]) => T, wait: number): (...args: any[]) => void;
 export declare function isMac(): boolean;
 export declare function getModifierKey(): string;
@@ -130,7 +161,7 @@ export declare function getSchemaFromProperties(properties: {
 }): Schema;
 export declare function validateFileExtension(ext: string): boolean;
 export declare function isFlowPreview(job_kind: Job['job_kind'] | undefined): job_kind is "flowpreview" | "flownode";
-export declare function isNotFlow(job_kind: Job['job_kind'] | undefined): job_kind is "script" | "preview" | "dependencies" | "flowdependencies" | "appdependencies" | "script_hub" | "identity" | "deploymentcallback" | "flowscript" | "appscript" | undefined;
+export declare function isNotFlow(job_kind: Job['job_kind'] | undefined): job_kind is "script" | "identity" | "preview" | "dependencies" | "flowdependencies" | "appdependencies" | "script_hub" | "deploymentcallback" | "flowscript" | "appscript" | undefined;
 export declare function isScriptPreview(job_kind: Job['job_kind'] | undefined): job_kind is "preview" | "flowscript" | "appscript";
 export declare function conditionalMelt(node: HTMLElement, meltItem: AnyMeltElement | undefined): void | import("svelte/action").ActionReturn<undefined, Record<never, any>>;
 export type Item = {
@@ -139,6 +170,7 @@ export type Item = {
     icon?: any;
     iconColor?: string;
     href?: string;
+    hrefTarget?: '_blank' | '_self' | '_parent' | '_top';
     disabled?: boolean;
     type?: 'action' | 'delete';
     hide?: boolean | undefined;
@@ -152,4 +184,16 @@ export declare function toJsonStr(result: any): string;
 export declare function getOS(): "Windows" | "macOS" | "iOS" | "Android" | "Linux" | "Unknown OS";
 import { type ClassValue } from 'clsx';
 import type { Snippet } from 'svelte';
+import { OpenAPIV2, type OpenAPI, type OpenAPIV3, type OpenAPIV3_1 } from 'openapi-types';
+import type { IPosition } from 'monaco-editor';
 export declare function cn(...inputs: ClassValue[]): string;
+export type StateStore<T> = {
+    val: T;
+};
+export type ReadFieldsRecursivelyOptions = {
+    excludeField?: string[];
+};
+export declare function readFieldsRecursively(obj: any, options?: ReadFieldsRecursivelyOptions): void;
+export declare function reorder<T>(items: T[], oldIndex: number, newIndex: number): T[];
+export declare function scroll_into_view_if_needed_polyfill(elem: Element, centerIfNeeded?: boolean): IntersectionObserver;
+export declare const editorPositionMap: Record<string, IPosition>;