windmill-components 1.408.1 → 1.430.2

package/package/components/FlowBuilder.svelte

@@ -1,10 +1,11 @@
 <script>import { FlowService, ScheduleService, DraftService, ScriptService } from '../gen';
 import { initHistory, push, redo, undo } from '../history';
 import { copilotInfo, enterpriseLicense, tutorialsToDo, userStore, workspaceStore } from '../stores';
-import { cleanValueProperties, encodeState, formatCron, orderedJsonStringify, sleep } from '../utils';
+import { cleanValueProperties, encodeState, formatCron, orderedJsonStringify, replaceFalseWithUndefined, sleep } from '../utils';
 import { sendUserToast } from '../toast';
 import { Drawer } from './common';
-import { setContext, tick } from 'svelte';
+import DeployOverrideConfirmationModal from './common/confirmationModal/DeployOverrideConfirmationModal.svelte';
+import { onMount, setContext, tick } from 'svelte';
 import { writable } from 'svelte/store';
 import CenteredPage from './CenteredPage.svelte';
 import { Badge, Button, UndoRedo } from './common';
@@ -14,7 +15,6 @@ import { dfs as dfsApply } from './flows/dfs';
 import { dfs, getPreviousIds } from './flows/previousResults';
 import FlowImportExportMenu from './flows/header/FlowImportExportMenu.svelte';
 import FlowPreviewButtons from './flows/header/FlowPreviewButtons.svelte';
-import { loadFlowSchedule } from './flows/scheduleUtils';
 import { cleanInputs, emptyFlowModuleState } from './flows/utils';
 import { Calendar, Pen, Save, DiffIcon, MoreVertical, HistoryIcon, FileJson, CornerDownLeft } from 'lucide-svelte';
 import { createEventDispatcher } from 'svelte';
@@ -36,6 +36,7 @@ import { twMerge } from 'tailwind-merge';
 import CustomPopover from './CustomPopover.svelte';
 import Summary from './Summary.svelte';
 import FlowYamlEditor from './flows/header/FlowYamlEditor.svelte';
+import {} from './triggers';
 export let initialPath = '';
 export let pathStoreInit = undefined;
 export let newFlow;
@@ -49,32 +50,76 @@ export let diffDrawer = undefined;
 export let customUi = {};
 export let disableAi = false;
 export let disabledFlowInputs = false;
+export let savedPrimarySchedule = undefined;
+export let version = undefined;
+export let setSavedraftCb = undefined;
+// Used by multiplayer deploy collision warning
+let deployedValue = undefined; // Value to diff against
+let deployedBy = undefined; // Author
+let confirmCallback = () => { }; // What happens when user clicks `override` in warning
+let open = false; // Is confirmation modal open
 $: setContext('customUi', customUi);
-const dispatch = createEventDispatcher();
-async function createSchedule(path) {
-    const { cron, timezone, args, enabled, summary } = $scheduleStore;
+let onLatest = true;
+async function compareVersions() {
+    if (version === undefined) {
+        return;
+    }
     try {
-        await ScheduleService.createSchedule({
-            workspace: $workspaceStore,
-            requestBody: {
-                path: path,
-                schedule: formatCron(cron),
-                timezone,
-                script_path: path,
-                is_flow: true,
-                args,
-                enabled,
-                summary
-            }
-        });
+        if (initialPath && initialPath != '') {
+            const flowVersion = await FlowService.getFlowLatestVersion({
+                workspace: $workspaceStore,
+                path: initialPath
+            });
+            onLatest = version === flowVersion?.id;
+        }
+        else {
+            onLatest = true;
+        }
     }
     catch (err) {
-        sendUserToast(`The primary schedule could not be created: ${err}`, true);
+        console.error('Error comparing versions', err);
+        onLatest = true;
+    }
+}
+const dispatch = createEventDispatcher();
+const primaryScheduleStore = writable(savedPrimarySchedule);
+const triggersCount = writable(savedPrimarySchedule
+    ? { schedule_count: 1, primary_schedule: { schedule: savedPrimarySchedule.cron } }
+    : undefined);
+const simplifiedPoll = writable(false);
+export function setPrimarySchedule(schedule) {
+    primaryScheduleStore.set(schedule);
+    loadTriggers();
+}
+async function createSchedule(path) {
+    if ($primaryScheduleStore) {
+        const { cron, timezone, args, enabled, summary } = $primaryScheduleStore;
+        try {
+            await ScheduleService.createSchedule({
+                workspace: $workspaceStore,
+                requestBody: {
+                    path: path,
+                    schedule: formatCron(cron),
+                    timezone,
+                    script_path: path,
+                    is_flow: true,
+                    args,
+                    enabled,
+                    summary
+                }
+            });
+        }
+        catch (err) {
+            sendUserToast(`The primary schedule could not be created: ${err}`, true);
+        }
+    }
+    else {
+        sendUserToast('The primary schedule could not be created: no schedule data', true);
     }
 }
 let loadingSave = false;
 let loadingDraft = false;
-async function saveDraft(forceSave = false) {
+export async function saveDraft(forceSave = false) {
     if (!newFlow && !savedFlow) {
         return;
     }
@@ -132,7 +177,8 @@ async function saveDraft(forceSave = false) {
                 typ: 'flow',
                 value: {
                     ...flow,
-                    path: $pathStore
+                    path: $pathStore,
+                    primary_schedule: $primaryScheduleStore
                 }
             }
         });
@@ -168,11 +214,53 @@ async function saveDraft(forceSave = false) {
     }
     loadingDraft = false;
 }
+onMount(() => {
+    setSavedraftCb?.(() => saveDraft());
+});
 export function computeUnlockedSteps(flow) {
     return Object.fromEntries(getAllModules(flow.value.modules, flow.value.failure_module)
         .filter((m) => m.value.type == 'script' && m.value.hash == null)
         .map((m) => [m.id, m.value.path]));
 }
+async function handleSaveFlow(deploymentMsg) {
+    await compareVersions();
+    if (onLatest || initialPath == '' || savedFlow?.draft_only) {
+        // Handle directly
+        await saveFlow(deploymentMsg);
+    }
+    else {
+        // We need it for diff
+        await syncWithDeployed();
+        if (deployedValue &&
+            $flowStore &&
+            orderedJsonStringify(deployedValue) ===
+                orderedJsonStringify(replaceFalseWithUndefined({ ...$flowStore, path: $pathStore }))) {
+            await saveFlow(deploymentMsg);
+        }
+        else {
+            // Handle through confirmation modal
+            confirmCallback = async () => {
+                await saveFlow(deploymentMsg);
+            };
+            // Open confirmation modal
+            open = true;
+        }
+    }
+}
+async function syncWithDeployed() {
+    const flow = await FlowService.getFlowByPath({
+        workspace: $workspaceStore,
+        path: initialPath,
+        withStarredInfo: true
+    });
+    deployedValue = replaceFalseWithUndefined({
+        ...flow,
+        edited_at: undefined,
+        edited_by: undefined,
+        workspace_id: undefined
+    });
+    deployedBy = flow.edited_by;
+}
 async function saveFlow(deploymentMsg) {
     loadingSave = true;
     try {
@@ -180,7 +268,6 @@ async function saveFlow(deploymentMsg) {
         // console.log('flow', computeUnlockedSteps(flow)) // del
         // loadingSave = false // del
         // return
-        const { cron, timezone, args, enabled, summary } = $scheduleStore;
         if (newFlow) {
             try {
                 localStorage.removeItem('flow');
@@ -204,7 +291,7 @@ async function saveFlow(deploymentMsg) {
                     deployment_message: deploymentMsg || undefined
                 }
             });
-            if (enabled) {
+            if ($primaryScheduleStore && $primaryScheduleStore.enabled) {
                 await createSchedule($pathStore);
             }
         }
@@ -224,30 +311,39 @@ async function saveFlow(deploymentMsg) {
                     workspace: $workspaceStore ?? '',
                     path: initialPath
                 });
-                if (JSON.stringify(schedule.args) != JSON.stringify(args) ||
-                    schedule.schedule != cron ||
-                    schedule.timezone != timezone ||
-                    schedule.summary != summary) {
-                    await ScheduleService.updateSchedule({
-                        workspace: $workspaceStore ?? '',
-                        path: initialPath,
-                        requestBody: {
-                            schedule: formatCron(cron),
-                            timezone,
-                            args,
-                            summary
-                        }
-                    });
+                if ($primaryScheduleStore) {
+                    const { cron, timezone, args, enabled, summary } = $primaryScheduleStore;
+                    if (JSON.stringify(schedule.args) != JSON.stringify(args) ||
+                        schedule.schedule != cron ||
+                        schedule.timezone != timezone ||
+                        schedule.summary != summary) {
+                        await ScheduleService.updateSchedule({
+                            workspace: $workspaceStore ?? '',
+                            path: initialPath,
+                            requestBody: {
+                                schedule: formatCron(cron),
+                                timezone,
+                                args,
+                                summary
+                            }
+                        });
+                    }
+                    if (enabled != schedule.enabled) {
+                        await ScheduleService.setScheduleEnabled({
+                            workspace: $workspaceStore ?? '',
+                            path: initialPath,
+                            requestBody: { enabled }
+                        });
+                    }
                 }
-                if (enabled != schedule.enabled) {
-                    await ScheduleService.setScheduleEnabled({
+                else if (scheduleExists && !$triggersCount?.primary_schedule) {
+                    await ScheduleService.deleteSchedule({
                         workspace: $workspaceStore ?? '',
-                        path: initialPath,
-                        requestBody: { enabled }
+                        path: $pathStore
                     });
                 }
             }
-            else if (enabled) {
+            else if ($primaryScheduleStore && $primaryScheduleStore.enabled) {
                 await createSchedule(initialPath);
             }
             await FlowService.updateFlow({
@@ -293,7 +389,8 @@ function saveSessionDraft() {
             localStorage.setItem(initialPath && initialPath != '' ? `flow-${initialPath}` : 'flow', encodeState({
                 flow: $flowStore,
                 path: $pathStore,
-                selectedId: $selectedIdStore
+                selectedId: $selectedIdStore,
+                primarySchedule: $primaryScheduleStore
             }));
         }
         catch (err) {
@@ -302,16 +399,10 @@ function saveSessionDraft() {
     }, 500);
 }
 const selectedIdStore = writable(selectedId ?? 'settings-metadata');
+const selectedTriggerStore = writable('webhooks');
 export function getSelectedId() {
     return $selectedIdStore;
 }
-const scheduleStore = writable({
-    summary: undefined,
-    args: {},
-    cron: '',
-    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    enabled: false
-});
 const previewArgsStore = writable(initialArgs);
 const scriptEditorDrawer = writable(undefined);
 const moving = writable(undefined);
@@ -322,10 +413,12 @@ const testStepStore = writable({});
 function select(selectedId) {
     selectedIdStore.set(selectedId);
 }
+function selectTrigger(selectedTrigger) {
+    selectedTriggerStore.set(selectedTrigger);
+}
 let insertButtonOpen = writable(false);
 setContext('FlowEditorContext', {
     selectedId: selectedIdStore,
-    schedule: scheduleStore,
     previewArgs: previewArgsStore,
     scriptEditorDrawer,
     moving,
@@ -340,23 +433,29 @@ setContext('FlowEditorContext', {
     customUi,
     insertButtonOpen
 });
-async function loadSchedule() {
-    loadFlowSchedule(initialPath, $workspaceStore)
-        .then((schedule) => {
-        scheduleStore.set(schedule);
-    })
-        .catch(() => {
-        scheduleStore.set({
-            summary: undefined,
-            cron: '0 */5 * * *',
-            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-            args: {},
-            enabled: false
-        });
+setContext('TriggerContext', {
+    selectedTrigger: selectedTriggerStore,
+    primarySchedule: primaryScheduleStore,
+    triggersCount,
+    simplifiedPoll
+});
+async function loadTriggers() {
+    $triggersCount = await FlowService.getTriggersCountOfFlow({
+        workspace: $workspaceStore,
+        path: initialPath
     });
+    if ($primaryScheduleStore && $triggersCount.primary_schedule == undefined) {
+        $triggersCount = {
+            ...($triggersCount ?? {}),
+            schedule_count: ($triggersCount.schedule_count ?? 0) + 1,
+            primary_schedule: {
+                schedule: $primaryScheduleStore.cron
+            }
+        };
+    }
 }
 $: selectedId && select(selectedId);
-$: initialPath && initialPath != '' && $workspaceStore && loadSchedule();
+$: initialPath && initialPath != '' && $workspaceStore && loadTriggers();
 function onKeyDown(event) {
     let classes = event.target?.['className'];
     if ((typeof classes === 'string' && classes.includes('inputarea')) ||
@@ -553,6 +652,7 @@ async function genFlow(idx, flowModules, stepOnly = false) {
     try {
         push(history, $flowStore);
         let module = stepOnly ? $copilotModulesStore[0] : $copilotModulesStore[idx];
+        const aiProvider = $copilotInfo.ai_provider;
         copilotLoading = true;
         copilotStatus = "Generating code for step '" + module.id + "'...";
         $copilotCurrentStepStore = module.id;
@@ -573,10 +673,13 @@ async function genFlow(idx, flowModules, stepOnly = false) {
             };
         }
         if (module.type === 'trigger') {
-            if (!$scheduleStore.cron) {
-                $scheduleStore.cron = '0 */15 * * *';
-            }
-            $scheduleStore.enabled = true;
+            $primaryScheduleStore = {
+                summary: 'Scheduled poll of flow',
+                args: {},
+                cron: '0 */15 * * *',
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                enabled: true
+            };
         }
         const flowModule = {
             id: module.id,
@@ -632,7 +735,6 @@ async function genFlow(idx, flowModules, stepOnly = false) {
         await tick();
         select(module.id);
         await tick();
-        await tick();
         focusCopilot();
         let isFirstInLoop = false;
         const parents = dfs(module.id, $flowStore).slice(1);
@@ -653,7 +755,7 @@ async function genFlow(idx, flowModules, stepOnly = false) {
             abortController = new AbortController();
             await stepCopilot(module, deltaStore, $workspaceStore, pastModule?.value.type === 'rawscript' || pastModule?.value.type === 'script'
                 ? pastModule
-                : undefined, isFirstInLoop, abortController);
+                : undefined, isFirstInLoop, abortController, aiProvider);
             unsubscribe();
         }
         copilotStatus = "Generating inputs for step '" + module.id + "'...";
@@ -664,10 +766,10 @@ async function genFlow(idx, flowModules, stepOnly = false) {
                     pastModule.value.type === 'rawscript' ||
                     pastModule.value.type === 'script')) {
                 const stepSchema = JSON.parse(JSON.stringify($flowStateStore[module.id].schema)); // deep copy
-                if (isHubStep && pastModule !== undefined && $copilotInfo.exists_openai_resource_path) {
+                if (isHubStep && pastModule !== undefined && $copilotInfo.exists_ai_resource) {
                     // ask AI to set step inputs
                     abortController = new AbortController();
-                    const { inputs, allExprs } = await glueCopilot(flowModule.value.input_transforms, $workspaceStore, pastModule, isFirstInLoop, abortController);
+                    const { inputs, allExprs } = await glueCopilot(flowModule.value.input_transforms, $workspaceStore, pastModule, isFirstInLoop, abortController, aiProvider);
                     // create flow inputs used by AI for autocompletion
                     copilotFlowInputs = {};
                     copilotFlowRequiredInputs = [];
@@ -712,9 +814,7 @@ async function genFlow(idx, flowModules, stepOnly = false) {
                     });
                 }
                 else {
-                    if (isHubStep &&
-                        pastModule !== undefined &&
-                        !$copilotInfo.exists_openai_resource_path) {
+                    if (isHubStep && pastModule !== undefined && !$copilotInfo.exists_ai_resource) {
                         sendUserToast('For better input generation, enable Windmill AI in the workspace settings', true);
                     }
                     // create possible flow inputs for autocompletion
@@ -892,6 +992,15 @@ let msgInput = undefined;
 
 <slot />
 
+<DeployOverrideConfirmationModal
+	bind:deployedBy
+	bind:confirmCallback
+	bind:open
+	{diffDrawer}
+	bind:deployedValue
+	currentValue={$flowStore}
+/>
+
 {#key renderCount}
 	{#if !$userStore?.operator}
 		<FlowCopilotDrawer {getHubCompletions} {genFlow} bind:flowCopilotMode />
@@ -960,7 +1069,7 @@ let msgInput = undefined;
 				</div>
 
 				<div class="gap-4 flex-row hidden md:flex w-full max-w-md">
-					{#if $scheduleStore.enabled}
+					{#if $primaryScheduleStore != undefined ? $primaryScheduleStore && $primaryScheduleStore?.enabled : $triggersCount?.primary_schedule}
 						<Button
 							btnClasses="hidden lg:inline-flex"
 							startIcon={{ icon: Calendar }}
@@ -968,10 +1077,15 @@ let msgInput = undefined;
 							color="light"
 							size="xs"
 							on:click={async () => {
-								select('settings-schedule')
+								select('triggers')
+								selectTrigger('schedules')
 							}}
 						>
-							{$scheduleStore.cron ?? ''}
+							{$primaryScheduleStore != undefined
+								? $primaryScheduleStore
+									? $primaryScheduleStore?.cron
+									: ''
+								: $triggersCount?.primary_schedule?.schedule}
 						</Button>
 					{/if}
 
@@ -1051,14 +1165,17 @@ let msgInput = undefined;
 							color="light"
 							variant="border"
 							size="xs"
-							on:click={() => {
+							on:click={async () => {
 								if (!savedFlow) {
 									return
 								}
+
+								await syncWithDeployed()
+
 								diffDrawer?.openDrawer()
 								diffDrawer?.setDiff({
 									mode: 'normal',
-									deployed: savedFlow,
+									deployed: deployedValue ?? savedFlow,
 									draft: savedFlow['draft'],
 									current: { ...$flowStore, path: $pathStore }
 								})
@@ -1100,7 +1217,9 @@ let msgInput = undefined;
 							loading={loadingSave}
 							size="xs"
 							startIcon={{ icon: Save }}
-							on:click={() => saveFlow()}
+							on:click={async () => {
+								await handleSaveFlow()
+							}}
 							dropdownItems={!newFlow ? dropdownItems : undefined}
 						>
 							Deploy
@@ -1111,16 +1230,16 @@ let msgInput = undefined;
 									type="text"
 									placeholder="Deployment message"
 									bind:value={deploymentMsg}
-									on:keydown={(e) => {
+									on:keydown={async (e) => {
 										if (e.key === 'Enter') {
-											saveFlow(deploymentMsg)
+											await handleSaveFlow(deploymentMsg)
 										}
 									}}
 									bind:this={msgInput}
 								/>
 								<Button
 									size="xs"
-									on:click={() => saveFlow(deploymentMsg)}
+									on:click={async () => await handleSaveFlow(deploymentMsg)}
 									endIcon={{ icon: CornerDownLeft }}
 									loading={loadingSave}
 								>
@@ -1142,6 +1261,7 @@ let msgInput = undefined;
 					on:reload={() => {
 						renderCount += 1
 					}}
+					{newFlow}
 				/>
 			{:else}
 				<CenteredPage>Loading...</CenteredPage>

package/package/components/FlowBuilder.svelte.d.ts

@@ -4,6 +4,7 @@ import { type Writable } from 'svelte/store';
 import type { FlowState } from './flows/flowState';
 import type DiffDrawer from './DiffDrawer.svelte';
 import type { FlowBuilderWhitelabelCustomUi } from './custom_ui';
+import { type ScheduleTrigger } from './triggers';
 declare const __propDef: {
     props: {
         initialPath?: string | undefined;
@@ -21,6 +22,11 @@ declare const __propDef: {
         customUi?: FlowBuilderWhitelabelCustomUi | undefined;
         disableAi?: boolean | undefined;
         disabledFlowInputs?: boolean | undefined;
+        savedPrimarySchedule?: ScheduleTrigger | undefined;
+        version?: number | undefined;
+        setSavedraftCb?: ((cb: () => void) => void) | undefined;
+        setPrimarySchedule?: ((schedule: ScheduleTrigger | undefined | false) => void) | undefined;
+        saveDraft?: ((forceSave?: boolean) => Promise<void>) | undefined;
         computeUnlockedSteps?: ((flow: Flow) => {
             [k: string]: string;
         }) | undefined;
@@ -47,6 +53,8 @@ export type FlowBuilderProps = typeof __propDef.props;
 export type FlowBuilderEvents = typeof __propDef.events;
 export type FlowBuilderSlots = typeof __propDef.slots;
 export default class FlowBuilder extends SvelteComponent<FlowBuilderProps, FlowBuilderEvents, FlowBuilderSlots> {
+    get setPrimarySchedule(): (schedule: false | ScheduleTrigger | undefined) => void;
+    get saveDraft(): (forceSave?: boolean) => Promise<void>;
     get computeUnlockedSteps(): (flow: Flow) => {
         [k: string]: string;
     };

package/package/components/FlowGraphViewer.svelte

@@ -3,12 +3,15 @@ import { twMerge } from 'tailwind-merge';
 import FlowGraphViewerStep from './FlowGraphViewerStep.svelte';
 import FlowGraphV2 from './graph/FlowGraphV2.svelte';
 import { dfs } from './flows/dfs';
+import { workspaceStore } from '../stores';
 export let flow;
 export let overflowAuto = false;
 export let noSide = false;
 export let download = false;
 export let noGraph = false;
+export let triggerNode = false;
 export let stepDetail = undefined;
+export let workspace = $workspaceStore;
 const dispatch = createEventDispatcher();
 </script>
 
@@ -19,20 +22,27 @@ const dispatch = createEventDispatcher();
 			class:overflow-auto={overflowAuto}
 		>
 			<FlowGraphV2
+				{triggerNode}
+				path={flow?.path}
 				{download}
 				minHeight={400}
+				{workspace}
 				modules={flow?.value?.modules}
 				failureModule={flow?.value?.failure_module}
 				preprocessorModule={flow?.value?.preprocessor_module}
 				on:select={(e) => {
-					if (e?.detail === 'failure') {
+					let nodeId = e?.detail
+					if (nodeId === 'triggers') {
+						dispatch('triggerDetail')
+						return
+					} else if (nodeId === 'failure') {
 						stepDetail = flow?.value?.failure_module
-					} else if (e?.detail === 'preprocessor') {
+					} else if (nodeId === 'preprocessor') {
 						stepDetail = flow?.value?.preprocessor_module
 					} else {
 						stepDetail = dfs(flow?.value?.modules ?? [], (m) => m).find((m) => m?.id === e?.detail)
 					}
-					stepDetail = stepDetail ?? e?.detail
+					stepDetail = stepDetail ?? nodeId
 					dispatch('select', stepDetail)
 				}}
 			/>

package/package/components/FlowGraphViewer.svelte.d.ts

@@ -7,14 +7,18 @@ declare const __propDef: {
             description?: string;
             value: FlowValue;
             schema?: any;
+            path?: string;
         };
         overflowAuto?: boolean | undefined;
         noSide?: boolean | undefined;
         download?: boolean | undefined;
         noGraph?: boolean | undefined;
+        triggerNode?: boolean | undefined;
         stepDetail?: FlowModule | string | undefined;
+        workspace?: string | undefined;
     };
     events: {
+        triggerDetail: CustomEvent<any>;
         select: CustomEvent<any>;
     } & {
         [evt: string]: CustomEvent<any>;

package/package/components/FlowGraphViewerStep.svelte

@@ -128,8 +128,10 @@ let codeViewer;
 						Error handler
 					{:else if stepDetail.id === 'preprocessor'}
 						Preprocessor
-					{:else}
-						Anonymous step
+					{:else if stepDetail.value.type == 'rawscript'}
+						Inline {stepDetail.value.language} script
+					{:else if stepDetail.value.type == 'script'}
+						Workspace script
 					{/if}
 				</span>
 			</div>

package/package/components/FlowPlugConnect.svelte

@@ -0,0 +1,17 @@
+<script>import { Plug } from 'lucide-svelte';
+import { Button } from './common';
+import AnimatedButton from './common/button/AnimatedButton.svelte';
+export let connecting;
+</script>
+
+<AnimatedButton animate={connecting} baseRadius="6px" animationDuration="2s" marginWidth="2px">
+	<Button
+		variant="border"
+		color="light"
+		size="xs2"
+		btnClasses={connecting ? 'text-blue-500' : 'text-primary'}
+		on:click
+	>
+		<Plug size={16} /> &rightarrow;
+	</Button>
+</AnimatedButton>

package/package/components/FlowPlugConnect.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        connecting: boolean;
+    };
+    events: {
+        click: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FlowPlugConnectProps = typeof __propDef.props;
+export type FlowPlugConnectEvents = typeof __propDef.events;
+export type FlowPlugConnectSlots = typeof __propDef.slots;
+export default class FlowPlugConnect extends SvelteComponent<FlowPlugConnectProps, FlowPlugConnectEvents, FlowPlugConnectSlots> {
+}
+export {};