windmill-components 1.623.1 → 1.642.0

package/dist/sharedUtils/components/apps/editor/component/default-codes.d.ts

@@ -0,0 +1,3 @@
+import type { AppComponent } from '.';
+export declare function defaultCode(component: string, language: string): string | undefined;
+export declare const DEFAULT_CODES: Partial<Record<AppComponent['type'], Partial<Record<'deno' | 'python3' | 'go' | 'bash' | 'pgsql' | 'mysql' | 'postgresql' | 'snowflake' | 'mssql' | 'bigquery' | 'oracledb', string>>>>;

package/dist/sharedUtils/components/apps/editor/component/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './default-codes';
+export * from './sets';

package/dist/sharedUtils/components/apps/editor/component/sets.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentSet } from '../../types';
+export declare const COMPONENT_SETS: readonly [ComponentSet, ComponentSet, ComponentSet, ComponentSet, ComponentSet, ComponentSet, ComponentSet];
+export declare const DEPRECATED_COMPONENTS: {
+    tablecomponent: string;
+    chartjscomponent: string;
+    multiselectcomponent: string;
+};

package/dist/sharedUtils/components/apps/editor/componentsPanel/componentDefaultProps.d.ts

@@ -0,0 +1,3 @@
+import type { Aligned } from '../../types';
+declare const defaultAlignement: Aligned;
+export { defaultAlignement };

package/dist/sharedUtils/components/apps/gridUtils.d.ts

@@ -0,0 +1,14 @@
+import type { GridItem } from './types';
+type ColumnConfiguration = [number, number][];
+declare const Breakpoints: {
+    sm: number;
+    lg: number;
+};
+export declare const moveMode: import("svelte/store").Writable<"move" | "insert">;
+declare const WIDE_GRID_COLUMNS: 12;
+declare const NARROW_GRID_COLUMNS: 3;
+declare const columnConfiguration: ColumnConfiguration;
+declare const gridColumns: number[];
+declare function toggleFixed(component: GridItem): GridItem;
+declare function isFixed(component: GridItem): boolean;
+export { gridColumns, WIDE_GRID_COLUMNS, NARROW_GRID_COLUMNS, columnConfiguration, Breakpoints, toggleFixed, isFixed };

package/dist/sharedUtils/components/apps/inputType.d.ts

@@ -0,0 +1,178 @@
+import type { ReadFileAs } from '../common/fileInput/model';
+import type { DecisionTreeNode, TypedComponent } from './editor/component';
+import type { InlineScript } from './sharedTypes';
+export type { InlineScript } from './sharedTypes';
+export type InputType = 'integer' | 'text' | 'textarea' | 'template' | 'number' | 'boolean' | 'select' | 'icon-select' | 'color' | 'date' | 'time' | 'datetime' | 'object' | 'array' | 'any' | 'labeledresource' | 'labeledselect' | 'tab-select' | 'schema' | 'ag-grid' | 'table-column' | 'plotly' | 'chartjs' | 'DecisionTreeNode' | 'ag-chart' | 'resource' | 'db-explorer' | 'db-table' | 's3' | 'number-tuple' | 'postgres' | 'mysql' | 'ms_sql_server' | 'snowflake' | 'snowflake_oauth' | 'bigquery' | 'oracledb' | 'ducklake' | 'app-path';
+export type InputConnection = {
+    componentType?: TypedComponent['type'];
+    componentId: string;
+    path: string;
+};
+export type InputConnectionEval = {
+    componentId: string;
+    id: string;
+};
+export type ConnectedInput = {
+    type: 'connected';
+    connection: InputConnection | undefined;
+    allowUserResources?: boolean;
+};
+export type UserInput<U> = {
+    type: 'user';
+    value: U | undefined;
+    allowUserResources?: boolean;
+};
+export type UploadInput = {
+    type: 'upload';
+    value: string;
+};
+export type UploadS3Input = {
+    type: 'uploadS3';
+    value: any;
+};
+export type FileUploadData = {
+    name: string;
+    size: number;
+    progress: number;
+    cancelled?: boolean;
+    errorMessage?: string;
+    path?: string;
+    file?: File;
+};
+export type EvalInput = {
+    type: 'eval';
+    expr: string;
+};
+export type EvalInputV2 = {
+    type: 'evalv2';
+    expr: string;
+    connections: InputConnectionEval[];
+    onDemandOnly?: boolean;
+    allowUserResources?: boolean;
+};
+export type RowInput = {
+    type: 'row';
+    column: string;
+};
+export type StaticInput<U> = {
+    value: U | undefined;
+    type: 'static';
+};
+export type TemplateInput = {
+    eval: string;
+    type: 'template';
+};
+export type TemplateV2Input = {
+    eval: string;
+    type: 'templatev2';
+    connections: InputConnectionEval[];
+};
+export type RunnableByPath = {
+    name: string;
+    path: string;
+    schema: any;
+    runType: 'script' | 'flow' | 'hubscript';
+    type: 'runnableByPath' | 'path';
+};
+export declare function isRunnableByPath(runnable: Runnable): runnable is RunnableByPath;
+export declare function isRunnableByName(runnable: Runnable): runnable is RunnableByName;
+export type RunnableByName = {
+    name: string;
+    inlineScript: InlineScript | undefined;
+    type: 'runnableByName' | 'inline';
+};
+export type Runnable = RunnableByPath | RunnableByName | undefined;
+export type RunnableWithFields = Runnable & {
+    fields?: Record<string, StaticAppInput | UserAppInput>;
+};
+export type ResultInput = {
+    runnable: Runnable;
+    transformer?: InlineScript & {
+        language: 'frontend';
+    };
+    fields: Record<string, StaticAppInput | ConnectedAppInput | RowAppInput | UserAppInput>;
+    type: 'runnable';
+    value?: any;
+    doNotRecomputeOnInputChanged?: boolean;
+    recomputeOnInputChanged?: boolean;
+    autoRefresh?: boolean;
+    hideRefreshButton?: boolean;
+};
+export type AppInputSpec<T extends InputType, U, V extends InputType = never> = (StaticInput<U> | ConnectedInput | UserInput<U> | RowInput | EvalInput | EvalInputV2 | UploadInput | UploadS3Input | ResultInput | TemplateInput | TemplateV2Input) & InputConfiguration<T, V>;
+type InputConfiguration<T extends InputType, V extends InputType> = {
+    fieldType: T;
+    subFieldType?: V;
+    format?: string | undefined;
+    loading?: boolean;
+    fileUpload?: {
+        /** Use `*` to accept anything. */
+        accept: string;
+        /**
+         * Controls if user is allowed to select multiple files.
+         * @default false
+         */
+        multiple?: boolean;
+        /**
+         * Controls if the uploaded file(s) will be converted or not.
+         * @default false
+         */
+        convertTo?: ReadFileAs;
+    };
+    fileUploadS3?: {
+        accept: string;
+        multiple?: boolean;
+    };
+    noStatic?: boolean;
+    onDemandOnly?: boolean;
+    hideRefreshButton?: boolean;
+};
+export type StaticOptions = {
+    selectOptions: readonly string[] | readonly {
+        value: string;
+        label: string;
+    }[];
+};
+export type AppInput = AppInputSpec<'text', string> | AppInputSpec<'textarea', string> | AppInputSpec<'template', string> | AppInputSpec<'number', number> | AppInputSpec<'boolean', boolean> | AppInputSpec<'date', string> | AppInputSpec<'time', string> | AppInputSpec<'datetime', string> | AppInputSpec<'any', any> | AppInputSpec<'object', Record<string | number, any>> | AppInputSpec<'object', string> | (AppInputSpec<'select', string, 'db-table'> & StaticOptions) | AppInputSpec<'icon-select', string> | AppInputSpec<'color', string> | AppInputSpec<'array', string[], 'text'> | AppInputSpec<'array', string[], 'textarea'> | AppInputSpec<'array', number[], 'number'> | AppInputSpec<'array', boolean[], 'boolean'> | AppInputSpec<'array', string[], 'date'> | AppInputSpec<'array', string[], 'time'> | AppInputSpec<'array', string[], 'datetime'> | AppInputSpec<'array', object[], 'object'> | (AppInputSpec<'array', string[], 'select'> & StaticOptions) | AppInputSpec<'array', object[], 'labeledresource'> | AppInputSpec<'array', (object | string)[], 'labeledselect'> | AppInputSpec<'labeledselect', object> | AppInputSpec<'labeledresource', object> | AppInputSpec<'array', object[], 'tab-select'> | AppInputSpec<'schema', object> | AppInputSpec<'array', object[], 'ag-grid'> | AppInputSpec<'array', object[], 'db-explorer'> | AppInputSpec<'array', object[], 'table-column'> | AppInputSpec<'array', object[], 'plotly'> | AppInputSpec<'array', object[], 'chartjs'> | AppInputSpec<'array', DecisionTreeNode, 'DecisionTreeNode'> | AppInputSpec<'array', object[], 'ag-chart'> | AppInputSpec<'resource', string> | AppInputSpec<'resource', string, 's3'> | AppInputSpec<'resource', string, 'postgres'> | AppInputSpec<'resource', string, 'mysql'> | AppInputSpec<'resource', string, 'ms_sql_server'> | AppInputSpec<'resource', string, 'snowflake'> | AppInputSpec<'resource', string, 'snowflake_oauth'> | AppInputSpec<'resource', string, 'bigquery'> | AppInputSpec<'resource', string, 'oracledb'> | AppInputSpec<'ducklake', string, 'ducklake'> | AppInputSpec<'array', object[], 'number-tuple'> | AppInputSpec<'app-path', string>;
+export type RowAppInput = Extract<AppInput, {
+    type: 'row';
+}>;
+export type StaticAppInput = Extract<AppInput, {
+    type: 'static';
+}>;
+export type ConnectedAppInput = Extract<AppInput, {
+    type: 'connected';
+}>;
+export type UserAppInput = Extract<AppInput, {
+    type: 'user';
+}>;
+export type ResultAppInput = Extract<AppInput, {
+    type: 'runnable';
+}>;
+export type EvalAppInput = Extract<AppInput, {
+    type: 'eval';
+}>;
+export type EvalV2AppInput = Extract<AppInput, {
+    type: 'evalv2';
+}>;
+export type StaticAppInputOnDemand = Extract<StaticAppInput, {
+    onDemandOnly: true;
+}>;
+export type TemplateV2AppInput = Extract<AppInput, {
+    type: 'templatev2';
+}>;
+export type UploadAppInput = Extract<AppInput, {
+    type: 'upload';
+}>;
+export type UploadS3AppInput = Extract<AppInput, {
+    type: 'uploadS3';
+}>;
+export type RichAppInput = AppInput | {
+    type: 'oneOf';
+    oneOf: string[];
+    configuration: Record<string, AppInput>;
+} | {
+    type: 'group';
+    title: string;
+    configuration: Record<string, AppInput>;
+};
+export type AppInputs = Record<string, AppInput>;

package/dist/sharedUtils/components/apps/rx.d.ts

@@ -0,0 +1,29 @@
+import type { InputConnectionEval } from './inputType';
+import { type Writable } from 'svelte/store';
+export interface Subscriber<T> {
+    id?: string;
+    next(v: T, force?: boolean): void;
+}
+export interface Observable<T> {
+    subscribe(x: Subscriber<T>, previousValue: T): () => void;
+}
+export interface Output<T> extends Observable<T> {
+    set(x: T, force?: boolean): void;
+    peak(): T | any | undefined;
+}
+export interface Input<T> extends Subscriber<T> {
+    peak(): T | any | undefined;
+}
+export type World = {
+    outputsById: Record<string, Record<string, Output<any>>>;
+    connect: <T>(connection: InputConnectionEval, next: (x: T, force?: boolean) => void, id: string, previousValue: any) => Input<T>;
+    stateId: Writable<number>;
+    newOutput: <T>(id: string, name: string, previousValue: T) => Output<T>;
+};
+export declare function buildWorld(context: Record<string, any>): Writable<World>;
+export declare function buildObservableWorld(): {
+    connect: <T>(connection: InputConnectionEval, next: (x: T) => void, id: string, previousValue: T) => Input<T>;
+    newOutput: <T>(id: string, name: string, state: Writable<number>, previousValue: T) => Output<T>;
+};
+export declare function cachedInput<T>(nextParam: (x: T, force?: boolean) => void, id?: string): Input<T>;
+export declare function settableOutput<T>(state: Writable<number>, previousValue: T): Output<T>;

package/dist/sharedUtils/components/apps/sharedTypes.d.ts

@@ -0,0 +1,21 @@
+import type { Schema } from '$lib/common';
+import type { Preview } from '$lib/gen';
+import type { AssetWithAltAccessType } from '../assets/lib';
+export type InlineScript = {
+    content: string;
+    language: Preview['language'] | 'frontend';
+    path?: string;
+    schema?: Schema;
+    lock?: string;
+    cache_ttl?: number;
+    refreshOn?: {
+        id: string;
+        key: string;
+    }[];
+    suggestedRefreshOn?: {
+        id: string;
+        key: string;
+    }[];
+    id?: number;
+    assets?: AssetWithAltAccessType[];
+};

package/dist/sharedUtils/components/apps/types.d.ts

@@ -0,0 +1,274 @@
+import type { Policy } from '$lib/gen';
+import type { History } from '$lib/history.svelte';
+import type { Writable } from 'svelte/store';
+import type { AppComponent, PresetComponentConfig, RecomputeOthersSource, components } from './editor/component/components';
+import type { AppInput, ConnectedAppInput, ConnectedInput, EvalAppInput, EvalV2AppInput, InlineScript, InputConnection, ResultAppInput, RowAppInput, Runnable, StaticAppInput, TemplateV2AppInput, UploadAppInput, UploadS3AppInput, UserAppInput } from './inputType';
+import type { World } from './rx';
+import type { FilledItem } from './svelte-grid/types';
+export type HorizontalAlignment = 'left' | 'center' | 'right';
+export type VerticalAlignment = 'top' | 'center' | 'bottom';
+export type Aligned = {
+    horizontalAlignment: HorizontalAlignment;
+    verticalAlignment: VerticalAlignment;
+};
+export interface GeneralAppInput {
+    tooltip?: string;
+    placeholder?: string;
+    customTitle?: string;
+}
+export type ComponentCssProperty = {
+    class?: string;
+    style?: string;
+    evalClass?: RichConfiguration;
+};
+export type ComponentCustomCSS<T extends keyof typeof components> = Partial<(typeof components)[T]['customCss']>;
+export type Configuration = StaticAppInput | ConnectedAppInput | UserAppInput | RowAppInput | EvalAppInput | EvalV2AppInput | UploadAppInput | UploadS3AppInput | ResultAppInput | TemplateV2AppInput;
+export type StaticConfiguration = GeneralAppInput & StaticAppInput;
+export type OneOfRichConfiguration<T> = {
+    type: 'oneOf';
+    selected: string;
+    tooltip?: string;
+    labels?: Record<string, string>;
+    configuration: Record<string, Record<string, T>>;
+};
+export type OneOfConfiguration = OneOfRichConfiguration<GeneralAppInput & (StaticAppInput | EvalAppInput | EvalV2AppInput)>;
+export type RichConfigurationT<T> = (T & {
+    type: AppInput['type'];
+}) | OneOfRichConfiguration<T>;
+export type RichConfiguration = RichConfigurationT<Configuration>;
+export type RichConfigurations = Record<string, RichConfiguration>;
+export type StaticRichConfigurations = Record<string, RichConfigurationT<GeneralAppInput & (StaticAppInput | EvalAppInput | EvalV2AppInput)>>;
+export interface BaseAppComponent extends Partial<Aligned> {
+    id: ComponentID;
+    componentInput: AppInput | undefined;
+    configuration: RichConfigurations;
+    customCss?: Record<string, ComponentCssProperty>;
+    numberOfSubgrids?: number;
+}
+export type ComponentSet = {
+    title: string;
+    components: Readonly<AppComponent['type'][]>;
+    presets?: Readonly<PresetComponentConfig['type'][]> | undefined;
+};
+type SectionID = string;
+export type AppSection = {
+    components: AppComponent[];
+    id: SectionID;
+};
+export type GridItem = FilledItem<AppComponent>;
+export type AppCssItemName = 'viewer' | 'grid' | AppComponent['type'];
+export type HiddenRunnable = {
+    name: string;
+    transformer?: InlineScript & {
+        language: 'frontend';
+    };
+    fields: Record<string, StaticAppInput | ConnectedAppInput | RowAppInput | UserAppInput>;
+    autoRefresh?: boolean;
+    doNotRecomputeOnInputChanged?: boolean;
+    recomputeOnInputChanged?: boolean;
+    noBackendValue?: any;
+    hidden?: boolean;
+} & Runnable & RecomputeOthersSource;
+export type AppTheme = {
+    type: 'path';
+    path: string;
+} | {
+    type: 'inlined';
+    css: string;
+};
+import type { DiffDrawerI } from '$lib/components/diff_drawer';
+export interface AppEditorProps {
+    app: App;
+    path: string;
+    policy: Policy;
+    summary: string;
+    fromHub?: boolean;
+    diffDrawer?: DiffDrawerI | undefined;
+    savedApp?: {
+        value: App;
+        draft?: any;
+        path: string;
+        summary: string;
+        policy: any;
+        draft_only?: boolean;
+        custom_path?: string;
+    } | undefined;
+    version?: number | undefined;
+    newApp?: boolean;
+    newPath?: string | undefined;
+    replaceStateFn?: (path: string) => void;
+    gotoFn?: (path: string, opt?: Record<string, any> | undefined) => void;
+    unsavedConfirmationModal?: import('svelte').Snippet<[any]>;
+    onSavedNewAppPath?: (path: string) => void;
+}
+export type App = {
+    grid: GridItem[];
+    darkMode?: boolean;
+    fullscreen: boolean;
+    norefreshbar?: boolean;
+    unusedInlineScripts: Array<{
+        name: string;
+        inlineScript: InlineScript;
+    }>;
+    hiddenInlineScripts: Array<HiddenRunnable>;
+    css?: Partial<Record<AppCssItemName, Record<string, ComponentCssProperty>>>;
+    subgrids?: Record<string, GridItem[]>;
+    theme: AppTheme | undefined;
+    lazyInitRequire?: string[] | undefined;
+    eagerRendering?: boolean | undefined;
+    hideLegacyTopBar?: boolean | undefined;
+    mobileViewOnSmallerScreens?: boolean | undefined;
+    version?: number;
+};
+export type ConnectingInput = {
+    opened: boolean;
+    input?: ConnectedInput;
+    sourceName?: string;
+    hoveredComponent: string | undefined;
+    onConnect?: ((connection: InputConnection) => void) | undefined;
+};
+export interface CancelablePromise<T> extends Promise<T> {
+    cancel: () => void;
+}
+export type ListContext = Writable<{
+    index: number;
+    value: any;
+    disabled: boolean;
+}>;
+export type ListInputs = {
+    set: (id: string, value: any) => void;
+    remove: (id: string) => void;
+};
+export type GroupContext = {
+    id: string;
+    context: Writable<Record<string, any>>;
+};
+export type JobById = {
+    job: string;
+    component: string;
+    result?: any;
+    error?: any;
+    transformer?: {
+        result?: any;
+        error?: string;
+    };
+    created_at?: number;
+    started_at?: number;
+    duration_ms?: number;
+};
+export type AppViewerContext = {
+    worldStore: Writable<World>;
+    app: Writable<App>;
+    summary: Writable<string>;
+    initialized: Writable<{
+        initializedComponents: string[];
+        initialized: boolean;
+        runnableInitialized: Record<string, any>;
+    }>;
+    selectedComponent: Writable<string[] | undefined>;
+    mode: Writable<EditorMode>;
+    connectingInput: Writable<ConnectingInput>;
+    breakpoint: Writable<EditorBreakpoint>;
+    bgRuns: Writable<string[]>;
+    runnableComponents: Writable<Record<string, {
+        autoRefresh: boolean;
+        refreshOnStart?: boolean;
+        cb: ((inlineScript?: InlineScript, setRunnableJob?: boolean) => CancelablePromise<void>)[];
+    }>>;
+    staticExporter: Writable<Record<string, () => any>>;
+    appPath: Writable<string>;
+    workspace: string;
+    onchange: (() => void) | undefined;
+    isEditor: boolean;
+    jobs: Writable<string[]>;
+    jobsById: Writable<Record<string, JobById>>;
+    noBackend: boolean;
+    errorByComponent: Writable<Record<string, {
+        id?: string;
+        error: string;
+    }>>;
+    openDebugRun: Writable<((jobID: string) => void) | undefined>;
+    focusedGrid: Writable<FocusedGrid | undefined>;
+    stateId: Writable<number>;
+    parentWidth: Writable<number>;
+    state: Writable<Record<string, any>>;
+    componentControl: Writable<Record<string, {
+        left?: () => boolean;
+        right?: (skipTableActions?: boolean | undefined) => string | boolean;
+        setTab?: (index: number) => void;
+        agGrid?: {
+            api: any;
+            columnApi: any;
+        };
+        setCode?: (value: string) => void;
+        onDelete?: () => void;
+        setValue?: (value: any) => void;
+        setSelectedIndex?: (index: number) => void;
+        openModal?: () => void;
+        closeModal?: () => void;
+        open?: () => void;
+        close?: () => void;
+        validate?: (key: string) => void;
+        invalidate?: (key: string, error: string) => void;
+        validateAll?: () => void;
+        clearFiles?: () => void;
+        sendMessage?: (message: string) => void;
+        showToast?: (message: string, error?: boolean) => void;
+        recompute?: () => void;
+        askNewResource?: () => void;
+        setGroupValue?: (key: string, value: any) => void;
+    }>>;
+    hoverStore: Writable<string | undefined>;
+    allIdsInPath: Writable<string[]>;
+    darkMode: Writable<boolean>;
+    cssEditorOpen: Writable<boolean>;
+    previewTheme: Writable<string | undefined>;
+    debuggingComponents: Writable<Record<string, number>>;
+    replaceStateFn?: ((url: string) => void) | undefined;
+    gotoFn?: ((url: string, opt?: Record<string, any> | undefined) => void) | undefined;
+    policy: Policy;
+    recomputeAllContext: Writable<{
+        onRefresh?: (excludeId?: string) => void;
+        componentNumber?: number | undefined;
+        interval?: number | undefined;
+        refreshing?: string[] | undefined;
+        setInter?: (interval: number) => void | undefined;
+        progress?: number | undefined;
+        loading?: boolean | undefined;
+    }>;
+    panzoomActive: Writable<boolean>;
+};
+export type AppEditorContext = {
+    yTop: Writable<number>;
+    runnableJobEditorPanel: Writable<{
+        focused: boolean;
+        jobs: Record<string, string>;
+        frontendJobs: Record<string, any>;
+        width: number;
+    }>;
+    evalPreview: Writable<Record<string, any>>;
+    componentActive: Writable<boolean>;
+    dndItem: Writable<Record<string, (x: number, y: number, topY: number) => void>>;
+    refreshComponents: Writable<(() => void) | undefined>;
+    history: History<App> | undefined;
+    pickVariableCallback: Writable<((path: string) => void) | undefined>;
+    selectedComponentInEditor: Writable<string | undefined>;
+    movingcomponents: Writable<string[] | undefined>;
+    jobsDrawerOpen: Writable<boolean>;
+    scale: Writable<number>;
+    stylePanel: () => any;
+};
+export type FocusedGrid = {
+    parentComponentId: string;
+    subGridIndex: number;
+};
+export type EditorMode = 'dnd' | 'preview';
+export type EditorBreakpoint = 'sm' | 'lg';
+export declare const IS_APP_PUBLIC_CONTEXT_KEY: "isAppPublicContext";
+type ComponentID = string;
+export type ContextPanelContext = {
+    search: Writable<string>;
+    manuallyOpened: Writable<Record<string, boolean>>;
+    hasResult: Writable<Record<string, boolean>>;
+};
+export {};

package/dist/sharedUtils/components/assets/lib.d.ts

@@ -0,0 +1,25 @@
+import type { AssetKind as _AssetKind, Asset as _Asset, ListAssetsResponse, AssetUsageAccessType, FlowModule, ScriptArgs } from '$lib/gen';
+export type Asset = _Asset;
+export type AssetKind = _AssetKind;
+export type AssetWithAccessType = Asset & {
+    access_type?: AssetUsageAccessType;
+};
+export type AssetWithAltAccessType = AssetWithAccessType & {
+    alt_access_type?: AssetUsageAccessType;
+};
+export declare function formatAsset(asset: Asset): string;
+export declare function formatShortAssetPath(asset: Asset): string;
+export declare function getAssetUsagePageUri(usage: ListAssetsResponse[number]['usages'][number]): string | undefined;
+export declare function assetEq(a: Asset | undefined, b: Asset | undefined): boolean;
+export declare function assetsEq(a: Asset[], b: Asset[]): boolean;
+export declare function parseAssetFromString(s: string): Asset | undefined;
+export declare function formatAssetKind(asset: {
+    kind: AssetKind;
+    metadata?: {
+        resource_type?: string;
+    };
+}): string;
+export declare function formatAssetAccessType(accessType: AssetUsageAccessType | undefined): "?" | "Read" | "Write" | "R/W";
+export declare function getAccessType(asset: AssetWithAltAccessType): AssetUsageAccessType | undefined;
+export declare function getFlowModuleAssets(flowModuleValue: FlowModule, additionalAssetsMap?: Record<string, AssetWithAccessType[]>): AssetWithAccessType[] | undefined;
+export declare function parseInputArgsAssets(args: ScriptArgs): AssetWithAccessType[];

package/dist/sharedUtils/components/common/alert/model.d.ts

@@ -0,0 +1,2 @@
+export type AlertType = 'success' | 'error' | 'warning' | 'info';
+export declare const classes: Record<AlertType, Record<string, string>>;

package/dist/sharedUtils/components/common/badge/model.d.ts

@@ -0,0 +1,8 @@
+type BaseColor = 'blue' | 'gray' | 'red' | 'green' | 'yellow' | 'indigo' | 'orange' | 'violet';
+export declare const ColorModifier = "dark-";
+export type BadgeColor = BaseColor | 'transparent' | `${typeof ColorModifier}${BaseColor}`;
+export interface BadgeIconProps {
+    position?: 'left' | 'right';
+    icon: any;
+}
+export {};

package/dist/sharedUtils/components/common/button/model.d.ts

@@ -0,0 +1,45 @@
+import type { IconType } from '$lib/utils';
+export declare const BUTTON_COLORS: readonly ["blue", "red", "dark", "light", "green", "gray", "none", "marine", "nord"];
+export declare namespace ButtonType {
+    /**
+     * @deprecated Use `UnifiedSize` instead
+     */
+    type Size = 'xs3' | 'xs2' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    type UnifiedSize = 'xs' | 'sm' | 'md' | 'lg';
+    type ExtendedSize = 'xs2' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /**
+     * @deprecated Use `Variant` instead
+     */
+    type Color = 'blue' | 'red' | 'dark' | 'light' | 'green' | 'gray' | 'none' | 'marine' | 'nord';
+    type Variant = 'contained' | 'border' | 'divider' | 'accent-secondary' | 'accent' | 'default' | 'subtle';
+    type Target = '_self' | '_blank';
+    type Element = HTMLButtonElement | HTMLAnchorElement;
+    interface Icon {
+        icon?: IconType | undefined;
+        classes?: string;
+        faIcon?: any | undefined;
+        props?: any;
+    }
+    const FontSizeClasses: Record<ButtonType.Size, string>;
+    const SpacingClasses: Record<ButtonType.Size, Record<'contained' | 'border' | 'divider', string>>;
+    interface ItemProps {
+        size: Size;
+        color: Color;
+    }
+    const ColorVariants: Record<ButtonType.Color, Record<'contained' | 'border' | 'divider', string>>;
+    const VariantStyles: Record<'accent-secondary' | 'accent' | 'default' | 'subtle', string>;
+    const DestructiveVariantStyles: Record<'accent-secondary' | 'accent' | 'default' | 'subtle', string>;
+    const VariantSpacingClasses: Record<ButtonType.Size, string>;
+    const IconOnlyVariantSpacingClasses: Record<ButtonType.Size, string>;
+    const UnifiedSizingClasses: Record<ButtonType.UnifiedSize, string>;
+    const UnifiedIconOnlySizingClasses: Record<ButtonType.UnifiedSize, string>;
+    const UnifiedMinHeightClasses: Record<ButtonType.UnifiedSize, string>;
+    const UnifiedHeightClasses: Record<ButtonType.UnifiedSize, string>;
+    const UnifiedIconSizes: Record<ButtonType.UnifiedSize, number>;
+    const UnifiedFontSizes: Record<ButtonType.UnifiedSize, string>;
+    const ExtendedSizingClasses: Record<ButtonType.ExtendedSize, string>;
+    const ExtendedIconOnlySizingClasses: Record<ButtonType.ExtendedSize, string>;
+    const ExtendedHeightClasses: Record<ButtonType.ExtendedSize, string>;
+    const ExtendedIconSizes: Record<ButtonType.ExtendedSize, number>;
+    const ExtendedFontSizeClasses: Record<ButtonType.ExtendedSize, string>;
+}

package/dist/sharedUtils/components/common/fileInput/model.d.ts

@@ -0,0 +1 @@
+export type ReadFileAs = 'buffer' | 'binary' | 'base64' | 'text';

package/dist/sharedUtils/components/common/index.d.ts

@@ -0,0 +1,24 @@
+export { default as ActionRow } from './actionRow/ActionRow.svelte';
+export { default as Alert } from './alert/Alert.svelte';
+export { default as Badge } from './badge/Badge.svelte';
+export { default as Button } from './button/Button.svelte';
+export { default as UndoRedo } from './button/UndoRedo.svelte';
+export { default as ClearableInput } from './clearableInput/ClearableInput.svelte';
+export { default as Drawer } from './drawer/Drawer.svelte';
+export { default as DrawerContent } from './drawer/DrawerContent.svelte';
+export { default as Kbd } from './kbd/Kbd.svelte';
+export { default as Menu } from './menu/Menu.svelte';
+export { default as MenuItem } from './menu/MenuItem.svelte';
+export { default as SecondsInput } from './seconds/SecondsInput.svelte';
+export { default as Skeleton } from './skeleton/Skeleton.svelte';
+export { default as Tab } from './tabs/Tab.svelte';
+export { default as TabContent } from './tabs/TabContent.svelte';
+export { default as Tabs } from './tabs/Tabs.svelte';
+export { default as Breadcrumb } from './breadcrumb/Breadcrumb.svelte';
+export { default as FileInput } from './fileInput/FileInput.svelte';
+export { default as Section } from '../Section.svelte';
+export { default as Url } from './Url.svelte';
+export * from './alert/model';
+export * from './badge/model';
+export * from './button/model';
+export * from './skeleton/model';