@windmill-labs/shared-utils 1.0.1 → 1.0.3

package/history.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type Writable } from 'svelte/store';
+export type History<T> = Writable<{
+    history: T[];
+    index: number;
+}>;
+export declare function initHistory<T>(initial: T): History<T>;
+export declare function undo<T>(history: History<T> | undefined, now: T): T;
+export declare function redo<T>(history: History<T> | undefined): T;
+export declare function push<T>(history: History<T> | undefined, value: T, noSetIndex?: boolean): void;

package/hub.d.ts

@@ -0,0 +1,48 @@
+import type { Schema } from './common';
+import { type Flow, type Script } from './gen';
+export declare const DEFAULT_HUB_BASE_URL = "https://hub.windmill.dev";
+export declare const PRIVATE_HUB_MIN_VERSION = 10000000;
+export declare function scriptToHubUrl(content: string, summary: string, description: string, kind: Script['kind'], language: Script['language'], schema: Schema | any, lock: string | undefined, hubBaseUrl: string): URL;
+export declare const HubScript: {
+    readonly SIGNATURE_TEMPLATE: string;
+};
+export declare const HubFlow: {
+    readonly SIGNATURE_TEMPLATE: "67";
+};
+export declare function replaceScriptPlaceholderWithItsValues(id: string, content: string): string;
+export declare function loadHubFlows(): Promise<{
+    id: number;
+    flow_id: number;
+    summary: string;
+    apps: Array<(string)>;
+    approved: boolean;
+    votes: number;
+}[] | undefined>;
+export declare function loadHubApps(): Promise<{
+    id: number;
+    app_id: number;
+    summary: string;
+    apps: Array<(string)>;
+    approved: boolean;
+    votes: number;
+}[] | undefined>;
+export declare function flowToHubUrl(flow: Flow, hubBaseUrl: string): URL;
+export declare function appToHubUrl(staticApp: any, hubBaseUrl: string): URL;
+type HubPaths = {
+    gitSync: string;
+    gitSyncTest: string;
+    gitInitRepo: string;
+    slackErrorHandler: string;
+    slackRecoveryHandler: string;
+    slackSuccessHandler: string;
+    slackReport: string;
+    discordReport: string;
+    smtpReport: string;
+    teamsErrorHandler: string;
+    teamsRecoveryHandler: string;
+    teamsSuccessHandler: string;
+    emailErrorHandler: string;
+    cloneRepoToS3forGitRepoViewer: string;
+};
+export declare const hubPaths: HubPaths;
+export {};

package/lib.d.ts

@@ -0,0 +1,3 @@
+export { updatePolicy } from './components/apps/editor/appPolicy';
+export { genWmillTs } from './components/raw_apps/utils';
+export declare function capitalize(word: string): string;

package/lib.es.js

@@ -1232,7 +1232,7 @@ function computeS3ImageViewerPolicy(c) {
 function collectStaticFields(c) {
 	return Object.fromEntries(Object.entries(c ?? {}).filter(([c, L]) => L.type == "static").map(([c, L]) => [c, L.value]));
 }
-var import_build = /* @__PURE__ */ __toESM(require_build());
+var import_build = /* @__PURE__ */ __toESM(require_build(), 1);
 async function updatePolicy(c, L) {
 	let R = allItems(c.grid, c.subgrids), z = await Promise.all(R.flatMap((L) => {
 		let R = L.data, z = [{
@@ -1314,7 +1314,7 @@ async function processRunnable(c, L, R, z) {
 	let B = collectStaticFields(R), V = collectOneOfFields(R, z), H = Object.entries(R).map(([c, L]) => L.allowUserResources ? c : void 0).filter(Boolean);
 	if (L?.type == "runnableByName") {
 		let R = await hash(L.inlineScript?.content);
-		return console.log("hex", R, c), [`${c}:rawscript/${R}`, {
+		return console.debug("hex", R, c), [`${c}:rawscript/${R}`, {
 			static_inputs: B,
 			one_of_inputs: V,
 			allow_user_resources: H
@@ -1334,4 +1334,71 @@ async function hash(c) {
 		return L.update(c ?? ""), Array.from(await L.digest()).map((c) => c.toString(16).padStart(2, "0")).join("");
 	}
 }
-export { updatePolicy };
+function schemaToTsType(c) {
+	let L = c.properties, R = c.required;
+	return !c || !L ? "any" : `{ ${Object.keys(L).map((c) => {
+		let z = L[c], B = `${c}${R?.includes(c) ? "" : "?"}`, V = "any";
+		return z.type === "string" ? V = "string" : z.type === "number" || z.type === "integer" ? V = "number" : z.type === "boolean" ? V = "boolean" : z.type === "array" ? (V = z.items?.type ?? "any", V === "integer" && (V = "number"), V = `${V}[]`) : z.type === "object" && z.properties && (V = schemaToTsType(z)), `${B}: ${V}`;
+	}).join("; ")} }`;
+}
+function removeStaticFields(c, L) {
+	let R = Object.keys(L).filter((c) => L[c].type == "static");
+	return {
+		...c,
+		properties: { ...Object.fromEntries(Object.entries(c.properties ?? {}).filter(([c]) => !R.includes(c))) }
+	};
+}
+function hiddenRunnableToTsType(c) {
+	return c?.type == "runnableByName" ? c?.inlineScript?.schema ? schemaToTsType(removeStaticFields(c?.inlineScript?.schema, c?.fields ?? {})) : "{}" : c?.type == "runnableByPath" ? schemaToTsType(removeStaticFields(c?.schema, c?.fields ?? {})) : "{}";
+}
+function genWmillTs(c) {
+	return `// THIS FILE IS READ-ONLY
+// AND GENERATED AUTOMATICALLY FROM YOUR RUNNABLES
+	
+${Object.entries(c).map(([c, L]) => `export type RunBg${capitalize(c)} = ${hiddenRunnableToTsType(L)}\n`).join("\n")}
+
+export const runBg = {
+${Object.keys(c).map((c) => `  ${c}: null as unknown as (data: RunBg${capitalize(c)}) => Promise<any>`).join(",\n")}
+}
+	
+export const runBgAsync = {
+${Object.keys(c).map((c) => `  ${c}: null as unknown as (data: RunBg${capitalize(c)}) => Promise<string>`).join(",\n")}
+}
+	
+
+export type Job = {
+	type: 'QueuedJob' | 'CompletedJob'
+	id: string
+	created_at: number
+	started_at: number | undefined
+	duration_ms: number
+	success: boolean
+	args: any
+	result: any
+}
+
+/**
+* Execute a job and wait for it to complete and return the completed job
+* @param id
+*/
+// @ts-ignore
+export function waitJob(id: string): Promise<Job> {
+	// implementation passed when bundling/deploying
+	return null as unknown as Promise<Job>
+}
+
+/**
+* Get a job by id and return immediately with the current state of the job
+* @param id
+*/
+// @ts-ignore
+export function getJob(id: string): Promise<Job> {
+	// implementation passed when bundling/deploying
+	return null as unknown as Promise<Job>
+}
+`;
+}
+function capitalize(c) {
+	return c ? c.charAt(0).toUpperCase() + c.slice(1) : "";
+}
+export { capitalize, genWmillTs, updatePolicy };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@windmill-labs/shared-utils",
-	"version": "1.0.1",
+	"version": "1.0.3",
 	"type": "module",
 	"private": false,
 	"main": "./lib.es.js",

package/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Schema, SchemaProperty } from './common';
+export declare function schemaToTsType(schema: Schema | SchemaProperty): string;
+export declare function schemaToObject(schema: Schema, args: Record<string, any>): Object;

package/stores.d.ts

@@ -0,0 +1,96 @@
+import { type Readable } from 'svelte/store';
+import type { IntrospectionQuery } from 'graphql';
+import { type OperatorSettings, type TokenResponse, type UserWorkspaceList, type WorkspaceDefaultScripts } from './gen';
+import { type StateStore } from './utils';
+export interface UserExt {
+    email: string;
+    name?: string;
+    username: string;
+    is_admin: boolean;
+    is_super_admin: boolean;
+    operator: boolean;
+    created_at: string;
+    groups: string[];
+    pgroups: string[];
+    folders: string[];
+    folders_owners: string[];
+}
+export interface UserWorkspace {
+    id: string;
+    name: string;
+    username: string;
+    color?: string;
+    operator_settings?: OperatorSettings;
+    parent_workspace_id?: string | null;
+    disabled: boolean;
+}
+export declare function getWorkspaceFromStorage(): string | undefined;
+export declare function clearWorkspaceFromStorage(): void;
+export declare const tutorialsToDo: import("svelte/store").Writable<number[]>;
+export declare const globalEmailInvite: import("svelte/store").Writable<string>;
+export declare const awarenessStore: import("svelte/store").Writable<Record<string, string>>;
+export declare const enterpriseLicense: import("svelte/store").Writable<string | undefined>;
+export declare const whitelabelNameStore: Readable<string | undefined>;
+export declare const workerTags: import("svelte/store").Writable<string[] | undefined>;
+export declare const usageStore: import("svelte/store").Writable<number>;
+export declare const workspaceUsageStore: import("svelte/store").Writable<number>;
+export declare const initialArgsStore: import("svelte/store").Writable<any>;
+export declare const oauthStore: import("svelte/store").Writable<TokenResponse | undefined>;
+export declare const userStore: import("svelte/store").Writable<UserExt | undefined>;
+export declare const workspaceStore: import("svelte/store").Writable<string | undefined>;
+export declare const defaultScripts: import("svelte/store").Writable<WorkspaceDefaultScripts | undefined>;
+export declare const dbClockDrift: import("svelte/store").Writable<number | undefined>;
+export declare const isPremiumStore: import("svelte/store").Writable<boolean>;
+export declare const starStore: import("svelte/store").Writable<number>;
+export declare const usersWorkspaceStore: import("svelte/store").Writable<UserWorkspaceList | undefined>;
+export declare const superadmin: import("svelte/store").Writable<string | false | undefined>;
+export declare const devopsRole: import("svelte/store").Writable<string | false | undefined>;
+export declare const lspTokenStore: import("svelte/store").Writable<string | undefined>;
+export declare const hubBaseUrlStore: import("svelte/store").Writable<string>;
+export declare const userWorkspaces: Readable<Array<UserWorkspace>>;
+export declare const codeCompletionLoading: import("svelte/store").Writable<boolean>;
+export declare const metadataCompletionEnabled: import("svelte/store").Writable<boolean>;
+export declare const stepInputCompletionEnabled: import("svelte/store").Writable<boolean>;
+export declare const FORMAT_ON_SAVE_SETTING_NAME = "formatOnSave";
+export declare const VIM_MODE_SETTING_NAME = "vimMode";
+export declare const RELATIVE_LINE_NUMBERS_SETTING_NAME = "relativeLineNumbers";
+export declare const CODE_COMPLETION_SETTING_NAME = "codeCompletionSessionEnabled";
+export declare const COPILOT_SESSION_MODEL_SETTING_NAME = "copilotSessionModel";
+export declare const COPILOT_SESSION_PROVIDER_SETTING_NAME = "copilotSessionProvider";
+export declare const formatOnSave: import("svelte/store").Writable<boolean>;
+export declare const vimMode: import("svelte/store").Writable<boolean>;
+export declare const relativeLineNumbers: import("svelte/store").Writable<boolean>;
+export declare const codeCompletionSessionEnabled: import("svelte/store").Writable<boolean>;
+export declare const usedTriggerKinds: import("svelte/store").Writable<string[]>;
+type SQLBaseSchema = {
+    [schemaKey: string]: {
+        [tableKey: string]: {
+            [columnKey: string]: {
+                type: string;
+                default: string;
+                required: boolean;
+            };
+        };
+    };
+};
+export declare const SQLSchemaLanguages: readonly ["mysql", "bigquery", "postgresql", "snowflake", "mssql", "oracledb"];
+export interface SQLSchema {
+    lang: (typeof SQLSchemaLanguages)[number] | 'ducklake';
+    schema: SQLBaseSchema;
+    publicOnly: boolean | undefined;
+    stringified: string;
+}
+export interface GraphqlSchema {
+    lang: 'graphql';
+    schema: IntrospectionQuery;
+    stringified: string;
+}
+export type DBSchema = SQLSchema | GraphqlSchema;
+export type DBSchemas = Partial<Record<string, DBSchema>>;
+export declare const dbSchemas: import("svelte/store").Writable<Partial<Record<string, DBSchema>>>;
+export declare const instanceSettingsSelectedTab: import("svelte/store").Writable<string>;
+export declare const isCriticalAlertsUIOpen: import("svelte/store").Writable<boolean>;
+export declare const workspaceColor: Readable<string | null | undefined>;
+export declare const isCurrentlyInTutorial: StateStore<boolean>;
+export declare function getFlatTableNamesFromSchema(dbSchema: DBSchema | undefined): string[];
+export {};

package/svelte5Utils.svelte.d.ts

@@ -0,0 +1,49 @@
+import type { StateStore } from './utils';
+export declare function withProps<Component, Props>(component: Component, props: Props): {
+    component: Component;
+    props: Props;
+};
+export declare function createState<T>(initialValue: T): T;
+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;
+} | {
+    status: 'idle';
+    value?: undefined;
+    error?: undefined;
+}) & {
+    refresh: () => void;
+    clear: () => void;
+};
+export type UsePromiseOptions = {
+    loadInit?: boolean;
+    clearValueOnRefresh?: boolean;
+};
+export declare function usePromise<T>(createPromise: () => Promise<T>, { loadInit, clearValueOnRefresh }?: UsePromiseOptions): UsePromiseResult<T>;
+/**
+ * Generic change tracker class that monitors changes in state using deep equality comparison
+ * and provides a counter to trigger Svelte 5 reactivity. Similar to the pattern used in
+ * FlowGraphV2.svelte's onModulesChange2 function.
+ */
+export declare class ChangeTracker<T> {
+    #private;
+    counter: number;
+    constructor(initialValue?: T);
+    /**
+     * Check if the value has changed and update the counter to trigger reactivity
+     * @param value - The current value to check for changes
+     * @returns true if the value changed, false otherwise
+     */
+    track(value: T): boolean;
+}

package/toast.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps } from 'svelte';
+import type { Button } from './components/common';
+export type ToastAction = {
+    label: string;
+    callback: () => void;
+    buttonType?: ComponentProps<typeof Button>['variant'];
+};
+export declare function sendUserToast(message: string, error?: boolean, actions?: ToastAction[], errorMessage?: string | undefined, duration?: number): void;

package/utils.d.ts

@@ -0,0 +1,250 @@
+import { type UserExt } from './stores';
+import { sendUserToast } from './toast';
+import type { Job, RunnableKind, Script, ScriptLang, Retry } from './gen';
+import type { EnumType, SchemaProperty } from './common';
+import type { Schema } from './common';
+export { sendUserToast };
+import type { AnyMeltElement } from '@melt-ui/svelte';
+import type { TriggerKind } from './components/triggers';
+export type RunsSelectionMode = 'cancel' | 're-run';
+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 function isJobSelectable(selectionType: RunsSelectionMode): (j: Job) => boolean;
+export declare function escapeHtml(unsafe: string): string;
+export declare function validateUsername(username: string): string;
+export declare function parseQueryParams(url: string | undefined): Record<string, string>;
+export declare function displayDateOnly(dateString: string | Date | undefined): string;
+export declare function retrieveCommonWorkerPrefix(workerName: string): string;
+export declare function subtractDaysFromDateString(dateString: string | undefined, days: number): string | undefined;
+export declare function displayDate(dateString: string | Date | undefined, displaySecond?: boolean, displayDate?: boolean): string;
+export declare function displayTime(dateString: string | Date | undefined): string;
+export declare function displaySize(sizeInBytes: number | undefined): string | undefined;
+export declare function msToSec(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function removeTriggerKindIfUnused(length: number, triggerKind: TriggerKind, usedTriggerKinds: string[]): string[];
+export declare function msToReadableTime(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function msToReadableTimeShort(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function getToday(): Date;
+export declare function truncateHash(hash: string): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function addIfNotExists<T>(e: T, arr: Array<T> | undefined): Array<T>;
+export declare function validatePassword(password: string): boolean;
+interface ClickOutsideOptions {
+    capture?: boolean;
+    exclude?: (() => Promise<HTMLElement[]>) | HTMLElement[] | undefined;
+    stopPropagation?: boolean;
+    customEventName?: string;
+    eventToListenName?: 'click' | 'pointerdown';
+    onClickOutside?: (event: MouseEvent) => void;
+}
+export declare function clickOutside(node: Node, options?: ClickOutsideOptions | boolean): {
+    destroy(): void;
+    update(newOptions: ClickOutsideOptions | boolean): void;
+};
+export declare function pointerDownOutside(node: Node, options?: ClickOutsideOptions): {
+    destroy(): void;
+    update(newOptions: ClickOutsideOptions): void;
+};
+export interface DropdownItem {
+    displayName: string;
+    eventName?: string;
+    action?: ((event?: MouseEvent) => Promise<void>) | ((event?: MouseEvent) => void);
+    href?: string;
+    separatorTop?: boolean;
+    separatorBottom?: boolean;
+    type?: 'action' | 'delete';
+    disabled?: boolean;
+    icon?: any | undefined;
+}
+export declare const DELETE: "delete";
+export declare function emptySchema(): Schema;
+export declare function simpleSchema(): Schema;
+export declare function removeItemAll<T>(arr: T[], value: T): T[];
+export declare function emptyString(str: string | undefined | null): boolean;
+export declare function emptyStringTrimmed(str: string | undefined | null): boolean;
+export declare function defaultIfEmptyString(str: string | undefined, dflt: string): string;
+export declare function removeKeysWithEmptyValues(obj: any): any;
+export declare function allTrue(dict: {
+    [id: string]: boolean;
+}): boolean;
+export declare function elapsedSinceSecs(date: string): number;
+export declare function pathIsEmpty(path: string): boolean;
+export declare function encodeState(state: any): string;
+export declare function decodeState(query: string): any;
+export declare function itemsExists<T>(arr: T[] | undefined, item: T): boolean;
+export declare function groupBy<K, V>(items: V[], toGroup: (t: V) => K, toSort: (t: V) => string, dflts?: K[]): [K, V[]][];
+export declare function removeMarkdown(text: string): string;
+export declare function truncate(s: string, n: number, suffix?: string): string;
+export declare function truncateRev(s: string, n: number, prefix?: string): string;
+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' | 'dynamic' | 'json-schema' | 'ai-provider';
+export declare namespace DynamicInput {
+    type HelperScript = {
+        source: 'deployed';
+        path: string;
+        runnable_kind: RunnableKind;
+    } | {
+        source: 'inline';
+        code: string;
+        lang: ScriptLang;
+    };
+    const generatePythonFnTemplate: (functionName: string) => string;
+    const generateJsFnTemplate: (functionName: string) => string;
+    const generateDefaultTemplateFn: (functionName: string, lang: ScriptLang) => string;
+    const getGenerateTemplateFn: (lang: ScriptLang) => (functionName: string) => string;
+    const isDynInputFormat: (format?: string) => boolean;
+}
+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 { capitalize } from './sharedUtils';
+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): {
+    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;
+export declare function isValidHexColor(color: string): boolean;
+export declare function sortObject<T>(o: T & object): T;
+export declare function sortArray<T>(array: T[], compareFn?: (a: T, b: T) => number): T[];
+export declare function generateRandomString(len?: number): string;
+export declare function deepMergeWithPriority<T>(target: T, source: T): T;
+export declare function canWrite(path: string, extra_perms: Record<string, boolean>, user?: UserExt): boolean;
+export declare function isOwner(path: string, user: UserExt | undefined, workspace: string | undefined): boolean;
+export declare function isObviousOwner(path: string, user?: UserExt): boolean;
+export declare function extractCustomProperties(styleStr: string): string;
+export declare function computeSharableHash(args: any): string;
+export declare function toCamel(s: string): string;
+export declare function cleanExpr(expr: string | undefined): string;
+export declare function isCodeInjection(expr: string | undefined): boolean;
+export declare function urlParamsToObject(params: URLSearchParams): Record<string, string>;
+export declare function tryEvery({ tryCode, timeoutCode, interval, timeout }: {
+    tryCode: () => Promise<any>;
+    timeoutCode: () => void;
+    interval: number;
+    timeout: number;
+}): Promise<void>;
+export declare function roughSizeOfObject(object: object | string | any): number;
+export type Value = {
+    language?: Script['language'];
+    content?: string;
+    path?: string;
+    draft_only?: boolean;
+    value?: any;
+    draft?: Value;
+    [key: string]: any;
+};
+export declare function replaceFalseWithUndefined(obj: any): any;
+export declare function cleanValueProperties(obj: Value): any;
+export declare function orderedJsonStringify(obj: any, space?: string | number): string;
+export declare function orderedYamlStringify(obj: any): string;
+export declare function computeShow(argName: string, expr: string | undefined, args: any): any;
+export declare function urlize(input: string, formatter: 'html' | 'md'): string;
+export declare function storeLocalSetting(name: string, value: string | undefined): void;
+export declare function getLocalSetting(name: string): string | null | undefined;
+export declare function computeKind(enum_: EnumType, contentEncoding: 'base64' | 'binary' | undefined, pattern: string | undefined, format: string | undefined): 'base64' | 'none' | 'pattern' | 'enum' | 'resource' | 'format' | 'date-time';
+export declare function shouldDisplayPlaceholder(type: string | undefined, format: string | undefined, enum_: EnumType, contentEncoding: 'base64' | 'binary' | undefined, pattern: string | undefined, extra: Record<string, any> | undefined): boolean;
+export declare function getSchemaFromProperties(properties: {
+    [name: string]: SchemaProperty;
+}): 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" | "aiagent" | "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 = {
+    displayName: string;
+    action?: (e: MouseEvent) => void;
+    icon?: any;
+    iconColor?: string;
+    href?: string;
+    hrefTarget?: '_blank' | '_self' | '_parent' | '_top';
+    disabled?: boolean;
+    type?: 'action' | 'delete';
+    hide?: boolean | undefined;
+    extra?: Snippet;
+    id?: string;
+};
+export declare function isObjectTooBig(obj: any): boolean;
+export declare function localeConcatAnd(items: string[]): string;
+export declare function formatDate(dateString: string | undefined): string;
+export declare function formatDateShort(dateString: string | undefined): string;
+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 { Component, 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 function clone<T>(t: T): T;
+export declare const editorPositionMap: Record<string, IPosition>;
+export type S3Uri = `s3://${string}/${string}`;
+export type S3Object = S3Uri | {
+    s3: string;
+    storage?: string;
+};
+export declare function parseS3Object(s3Object: S3Object): {
+    s3: string;
+    storage?: string;
+};
+export declare function formatS3Object(s3Object: S3Object): S3Uri;
+export declare function isS3Uri(uri: string): uri is S3Uri;
+export declare function uniqueBy<T>(array: T[], key: (t: T) => any): T[];
+export declare function pruneNullishArray<T>(array: (T | null | undefined)[]): T[];
+export declare function assert(msg: string, condition: boolean, value?: any): void;
+export declare function createCache<Keys extends Record<string, any>, T, InitialKeys extends Keys = Keys>(compute: (keys: Keys) => T, params?: {
+    maxSize?: number;
+    initial?: InitialKeys;
+    invalidateMs?: number;
+}): (keys: Keys) => T;
+export declare function wait(ms: number): Promise<unknown>;
+export declare function validateRetryConfig(retry: Retry | undefined): string | null;
+export type CssColor = keyof (typeof tokensFile)['tokens']['light'];
+import tokensFile from './assets/tokens/tokens.json';
+export declare function getCssColor(color: CssColor, { alpha, format }: {
+    alpha?: number;
+    format?: 'css-var' | 'hex-dark' | 'hex-light';
+}): string;
+export type IconType = Component<{
+    size?: number;
+}> | typeof import('lucide-svelte').Dot;