windmill-components 1.87.0 → 1.89.1

package/package/components/flows/FlowProgressBar.svelte

@@ -0,0 +1,55 @@
+<script>import { FlowStatusModule, Job } from '../../gen';
+import { ProgressBar } from '../progressBar';
+export let job = undefined;
+export let duration = 200;
+let jobProgress = { steps: [], error: false };
+$: if (job)
+    updateJobProgress(job);
+function updateJobProgress(job) {
+    const modules = job?.flow_status?.modules;
+    if (!modules?.length) {
+        return;
+    }
+    jobProgress.steps = modules.map((module) => {
+        if (module.type === FlowStatusModule.type.FAILURE ||
+            (module.type === FlowStatusModule.type.SUCCESS && job['success'] === false)) {
+            jobProgress.error = true;
+        }
+        // Loop is still iterating
+        if (module.iterator) {
+            return {
+                type: 'loop',
+                isDone: isJobStepDone(module.type),
+                index: module.iterator.index || 0,
+                length: module.iterator.itered?.length || 0
+            };
+        }
+        // Loop is finished
+        else if (module['flow_jobs']) {
+            return {
+                type: 'loop',
+                isDone: isJobStepDone(module.type),
+                index: module['flow_jobs'].length,
+                length: module['flow_jobs'].length
+            };
+        }
+        // Not a loop
+        return {
+            type: 'general',
+            isDone: isJobStepDone(module.type)
+        };
+    });
+}
+function isJobStepDone(type) {
+    if (!type) {
+        return false;
+    }
+    return type === FlowStatusModule.type.SUCCESS || type === FlowStatusModule.type.FAILURE;
+}
+export function reset() {
+    jobProgress.error = false;
+    jobProgress.steps = [];
+}
+</script>
+
+<ProgressBar {...jobProgress} {duration} class={$$props.class} />

package/package/components/flows/FlowProgressBar.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import { Job } from '../../gen';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        job?: Job | undefined;
+        duration?: number | undefined;
+        reset?: (() => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FlowProgressBarProps = typeof __propDef.props;
+export type FlowProgressBarEvents = typeof __propDef.events;
+export type FlowProgressBarSlots = typeof __propDef.slots;
+export default class FlowProgressBar extends SvelteComponentTyped<FlowProgressBarProps, FlowProgressBarEvents, FlowProgressBarSlots> {
+    get reset(): () => void;
+}
+export {};

package/package/components/flows/common/FlowCard.svelte

@@ -0,0 +1,9 @@
+<script>import FlowCardHeader from './FlowCardHeader.svelte';
+export let title = undefined;
+export let flowModule = undefined;
+</script>
+
+<FlowCardHeader {title} bind:flowModule>
+	<slot name="header" />
+</FlowCardHeader>
+<slot />

package/package/components/flows/common/FlowCard.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import type { FlowModule } from '../../../gen';
+declare const __propDef: {
+    props: {
+        title?: string | undefined;
+        flowModule?: FlowModule | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        header: {};
+        default: {};
+    };
+};
+export type FlowCardProps = typeof __propDef.props;
+export type FlowCardEvents = typeof __propDef.events;
+export type FlowCardSlots = typeof __propDef.slots;
+export default class FlowCard extends SvelteComponentTyped<FlowCardProps, FlowCardEvents, FlowCardSlots> {
+}
+export {};

package/package/components/flows/common/FlowCardHeader.svelte

@@ -0,0 +1,69 @@
+<script>import Badge from '../../common/badge/Badge.svelte';
+import Button from '../../common/button/Button.svelte';
+import IconedPath from '../../IconedPath.svelte';
+import { RawScript, ScriptService } from '../../../gen';
+import { workspaceStore } from '../../../stores';
+export let flowModule = undefined;
+export let title = undefined;
+const languageColors = {
+    [RawScript.language.GO]: 'dark-indigo',
+    [RawScript.language.DENO]: 'dark-blue',
+    [RawScript.language.PYTHON3]: 'dark-green',
+    [RawScript.language.BASH]: 'dark-yellow'
+};
+let newHash = undefined;
+async function loadLatestHash(value) {
+    let script = await ScriptService.getScriptByPath({
+        workspace: $workspaceStore,
+        path: value.path
+    });
+    if (script.hash != value.hash) {
+        newHash = script.hash;
+    }
+}
+$: $workspaceStore &&
+    flowModule?.value.type === 'script' &&
+    flowModule.value.hash &&
+    loadLatestHash(flowModule.value);
+</script>
+
+<div
+	class="overflow-x-auto scrollbar-hidden flex items-center justify-between py-2 px-4 border-b border-gray-300 space-x-2  h-full max-h-12 flex-nowrap"
+>
+	{#if flowModule}
+		<span class="text-sm w-full mr-4">
+			<div class="flex items-center space-x-2">
+				{#if flowModule.value.type === 'identity'}
+					<span class="font-bold text-xs">Identity (input copied to output)</span>
+				{:else if flowModule?.value.type === 'rawscript'}
+					<Badge color={languageColors[flowModule?.value.language] ?? 'gray'} capitalize>
+						{flowModule?.value.language}
+					</Badge>
+					<input bind:value={flowModule.summary} placeholder={'Summary'} class="w-full grow" />
+				{:else if flowModule?.value.type === 'script' && 'path' in flowModule.value && flowModule.value.path}
+					<IconedPath path={flowModule.value.path} hash={flowModule.value.hash} class="grow" />
+					{#if newHash}
+						<Button
+							size="xs"
+							variant="border"
+							on:click={() => {
+								if (flowModule?.value.type == 'script') {
+									flowModule.value.hash = newHash
+									newHash = undefined
+								}
+							}}>Update to latest hash</Button
+						>
+					{/if}
+					<input bind:value={flowModule.summary} placeholder="Summary" class="w-full grow" />
+				{:else if flowModule?.value.type === 'flow'}
+					<Badge color="indigo" capitalize>flow</Badge>
+					<input bind:value={flowModule.summary} placeholder="Summary" class="w-full grow" />
+				{/if}
+			</div>
+		</span>
+	{/if}
+	{#if title}
+		<div class="text-sm font-bold text-gray-900">{title}</div>
+	{/if}
+	<slot />
+</div>

package/package/components/flows/common/FlowCardHeader.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+import { type FlowModule } from '../../../gen';
+declare const __propDef: {
+    props: {
+        flowModule?: FlowModule | undefined;
+        title?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type FlowCardHeaderProps = typeof __propDef.props;
+export type FlowCardHeaderEvents = typeof __propDef.events;
+export type FlowCardHeaderSlots = typeof __propDef.slots;
+export default class FlowCardHeader extends SvelteComponentTyped<FlowCardHeaderProps, FlowCardHeaderEvents, FlowCardHeaderSlots> {
+}
+export {};

package/package/components/flows/content/BranchPredicateEditor.svelte

@@ -0,0 +1,31 @@
+<script>import { getContext } from 'svelte';
+import PropPickerWrapper from '../propPicker/PropPickerWrapper.svelte';
+import SimpleEditor from '../../SimpleEditor.svelte';
+import { getStepPropPicker } from '../previousResults';
+export let branch;
+export let parentModule;
+export let previousModule;
+const { previewArgs, flowStateStore, flowStore } = getContext('FlowEditorContext');
+let editor = undefined;
+$: stepPropPicker = getStepPropPicker($flowStateStore, parentModule, previousModule, parentModule.id, $flowStore, $previewArgs, false);
+</script>
+
+<PropPickerWrapper
+	notSelectable
+	pickableProperties={stepPropPicker.pickableProperties}
+	on:select={({ detail }) => {
+		editor?.insertAtCursor(detail)
+		editor?.focus()
+	}}
+>
+	<div class="border border-gray-400">
+		<SimpleEditor
+			bind:this={editor}
+			lang="javascript"
+			bind:code={branch.expr}
+			class="small-editor border "
+			shouldBindKey={false}
+			extraLib={stepPropPicker.extraLib}
+		/>
+	</div>
+</PropPickerWrapper>

package/package/components/flows/content/BranchPredicateEditor.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponentTyped } from "svelte";
+import type { FlowModule } from '../../../gen';
+declare const __propDef: {
+    props: {
+        branch: {
+            summary?: string;
+            expr: string;
+            modules: Array<FlowModule>;
+        };
+        parentModule: FlowModule;
+        previousModule: FlowModule | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type BranchPredicateEditorProps = typeof __propDef.props;
+export type BranchPredicateEditorEvents = typeof __propDef.events;
+export type BranchPredicateEditorSlots = typeof __propDef.slots;
+export default class BranchPredicateEditor extends SvelteComponentTyped<BranchPredicateEditorProps, BranchPredicateEditorEvents, BranchPredicateEditorSlots> {
+}
+export {};

package/package/components/flows/content/CapturePayload.svelte

@@ -0,0 +1,113 @@
+<script>import { page } from '$app/stores';
+import { Button } from '../../common';
+import Drawer from '../../common/drawer/Drawer.svelte';
+import DrawerContent from '../../common/drawer/DrawerContent.svelte';
+import WindmillIcon from '../../icons/WindmillIcon.svelte';
+import ObjectViewer from '../../propertyPicker/ObjectViewer.svelte';
+import { CaptureService } from '../../../gen';
+import { workspaceStore } from '../../../stores';
+import { convert } from '@redocly/json-to-json-schema';
+import SchemaViewer from '../../SchemaViewer.svelte';
+import { getContext } from 'svelte';
+import { copyToClipboard, sendUserToast } from '../../../utils';
+import Icon from 'svelte-awesome';
+import { faClipboard } from '@fortawesome/free-solid-svg-icons';
+import SchemaForm from '../../SchemaForm.svelte';
+const { previewArgs, flowStore } = getContext('FlowEditorContext');
+let drawer;
+let interval = undefined;
+let captureInput = undefined;
+let jsonSchema = undefined;
+export function openDrawer() {
+    drawer.openDrawer();
+}
+async function startCapturePoint() {
+    await CaptureService.createCapture({
+        workspace: $workspaceStore,
+        path: $flowStore.path
+    });
+}
+async function getCaptureInput() {
+    const capture = await CaptureService.getCapture({
+        workspace: $workspaceStore,
+        path: $flowStore.path
+    });
+    captureInput = capture;
+    jsonSchema = { required: [], properties: {}, ...convert(capture) };
+}
+</script>
+
+<Drawer
+	bind:this={drawer}
+	size="900px"
+	on:open={() => {
+		startCapturePoint()
+		interval = setInterval(() => {
+			getCaptureInput()
+		}, 1000)
+	}}
+	on:close={() => interval && clearInterval(interval)}
+>
+	<DrawerContent title="Capture request" on:close={drawer.closeDrawer}>
+		Send a payload at: <div>
+			<a
+				class="text-2xl"
+				on:click={(e) => {
+					e.preventDefault()
+					copyToClipboard(
+						`${$page.url.protocol}//${$page.url.hostname}/api/w/${$workspaceStore}/capture_u/${$flowStore.path}`
+					)
+				}}
+				href="{$page.url.protocol}//{$page.url
+					.hostname}/api/w/{$workspaceStore}/capture_u/{$flowStore.path}"
+				>{$page.url.protocol}//{$page.url
+					.hostname}/api/w/{$workspaceStore}/capture_u/{$flowStore.path}
+				<Icon data={faClipboard} /></a
+			>
+		</div>
+		<p class="text-gray-600 mt-4 text-xs">CURL example</p>
+
+		<div class="text-xs box mb-4 b">
+			<pre class="overflow-auto"
+				>{`curl -X POST ${$page.url.protocol}//${$page.url.hostname}/api/w/${$workspaceStore}/capture_u/${$flowStore.path} \\
+   -H 'Content-Type: application/json' \\
+   -d '{"foo": 42}'`}</pre
+			>
+		</div>
+		<div class="items-center flex flex-row gap-x-2 text-xs text-gray-600">
+			Listening for new requests
+			<WindmillIcon class="animate-[pulse_5s_linear_infinite]" spin="fast" /></div
+		>
+		<div class="box p-2 my-2 mb-4">
+			<ObjectViewer topBrackets={true} json={captureInput} />
+		</div>
+		<svelte:fragment slot="actions">
+			<Button
+				size="sm"
+				variant="border"
+				on:click={() => {
+					$previewArgs = captureInput
+					sendUserToast('Copied as test args')
+				}}
+			>
+				Copy only as test args
+			</Button>
+			<Button
+				size="sm"
+				on:click={() => {
+					$previewArgs = captureInput
+					$flowStore.schema = jsonSchema
+					sendUserToast('Copied as flow inputs and test args')
+				}}
+			>
+				Copy as flow inputs and test args
+			</Button>
+		</svelte:fragment>
+		<h3 class="my-2 mt-8">Derived schema</h3>
+		<div class="box p-2">
+			<SchemaViewer schema={jsonSchema} />
+		</div>
+		<h3 class="mt-8">Test args</h3>
+		<SchemaForm class="pt-4" schema={$flowStore.schema} args={$previewArgs} />
+	</DrawerContent>
+</Drawer>

package/package/components/flows/content/CapturePayload.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        openDrawer?: (() => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type CapturePayloadProps = typeof __propDef.props;
+export type CapturePayloadEvents = typeof __propDef.events;
+export type CapturePayloadSlots = typeof __propDef.slots;
+export default class CapturePayload extends SvelteComponentTyped<CapturePayloadProps, CapturePayloadEvents, CapturePayloadSlots> {
+    get openDrawer(): () => void;
+}
+export {};

package/package/components/flows/content/DynamicInputHelpBox.svelte

@@ -0,0 +1,46 @@
+<script>import { faChevronDown, faChevronUp } from '@fortawesome/free-solid-svg-icons';
+import Icon from 'svelte-awesome';
+import { slide } from 'svelte/transition';
+$: opened = false;
+</script>
+
+<div class="text-xs flex flex-row-reverse">
+	<!-- svelte-ignore a11y-click-events-have-key-events -->
+	<span
+		class="underline mr-4"
+		on:click={() => {
+			opened = !opened
+		}}
+	>
+		Help
+		<Icon class="ml-2" data={opened ? faChevronUp : faChevronDown} scale={0.7} />
+	</span>
+</div>
+
+{#if opened}
+	<div
+		transition:slide|local
+		class="bg-gray-100 border-l-4 border-gray-600 text-gray-700 p-4 m-4"
+		role="alert"
+		id="dynamic-input-help-box"
+	>
+		the last line must always be the final expression.
+		<p>
+			If it is multiline, the statement before the final expression <b
+				>MUST END WITH ; and a newline</b
+			>
+		</p>
+		<ul class="ml-4">
+			<li><b>{'results.<id>'}</b>: the result of step at id 'id'</li>
+			<li><b>flow_input</b>: the object containing the flow input arguments</li>
+			<li><b>params</b>: the object containing the current step static values</li>
+			<li>
+				<b>variable(path)</b>: the function returning the variable (including secrets) at given path
+				as a string
+			</li>
+			<li>
+				<b>resource(path)</b>: the function returning the resource at a given path as an object
+			</li>
+		</ul>
+	</div>
+{/if}

package/package/components/flows/content/DynamicInputHelpBox.svelte.d.ts

@@ -0,0 +1,14 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type DynamicInputHelpBoxProps = typeof __propDef.props;
+export type DynamicInputHelpBoxEvents = typeof __propDef.events;
+export type DynamicInputHelpBoxSlots = typeof __propDef.slots;
+export default class DynamicInputHelpBox extends SvelteComponentTyped<DynamicInputHelpBoxProps, DynamicInputHelpBoxEvents, DynamicInputHelpBoxSlots> {
+}
+export {};

package/package/components/flows/content/FlowBranchAllWrapper.svelte

@@ -0,0 +1,21 @@
+<script>import Toggle from '../../Toggle.svelte';
+import FlowCard from '../common/FlowCard.svelte';
+export let branch;
+</script>
+
+<div class="h-full flex flex-col">
+	<FlowCard title="Branch">
+		<div slot="header" class="grow">
+			<input bind:value={branch.summary} placeholder={'Summary'} />
+		</div>
+		<div class="p-4">
+			<div class="mt-2 mb-2 text-sm font-bold">Skip failures</div>
+			<Toggle
+				bind:checked={branch.skip_failure}
+				options={{
+					right: 'Skip failures'
+				}}
+			/>
+		</div>
+	</FlowCard>
+</div>

package/package/components/flows/content/FlowBranchAllWrapper.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import type { FlowModule } from '../../../gen';
+declare const __propDef: {
+    props: {
+        branch: {
+            summary?: string;
+            skip_failure?: boolean;
+            modules: Array<FlowModule>;
+        };
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FlowBranchAllWrapperProps = typeof __propDef.props;
+export type FlowBranchAllWrapperEvents = typeof __propDef.events;
+export type FlowBranchAllWrapperSlots = typeof __propDef.slots;
+export default class FlowBranchAllWrapper extends SvelteComponentTyped<FlowBranchAllWrapperProps, FlowBranchAllWrapperEvents, FlowBranchAllWrapperSlots> {
+}
+export {};

package/package/components/flows/content/FlowBranchOneWrapper.svelte

@@ -0,0 +1,18 @@
+<script>import FlowCard from '../common/FlowCard.svelte';
+import BranchPredicateEditor from './BranchPredicateEditor.svelte';
+export let branch;
+export let parentModule;
+export let previousModule;
+</script>
+
+<div class="h-full flex flex-col">
+	<FlowCard title="Branch">
+		<div slot="header" class="grow">
+			<input bind:value={branch.summary} placeholder={'Summary'} />
+		</div>
+		<div class="overflow-hidden flex-grow">
+			<h3 class="p-2">Predicate expression</h3>
+			<BranchPredicateEditor {branch} {parentModule} {previousModule} />
+		</div>
+	</FlowCard>
+</div>

package/package/components/flows/content/FlowBranchOneWrapper.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponentTyped } from "svelte";
+import type { FlowModule } from '../../../gen';
+declare const __propDef: {
+    props: {
+        branch: {
+            summary?: string;
+            expr: string;
+            modules: Array<FlowModule>;
+        };
+        parentModule: FlowModule;
+        previousModule: FlowModule | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FlowBranchOneWrapperProps = typeof __propDef.props;
+export type FlowBranchOneWrapperEvents = typeof __propDef.events;
+export type FlowBranchOneWrapperSlots = typeof __propDef.slots;
+export default class FlowBranchOneWrapper extends SvelteComponentTyped<FlowBranchOneWrapperProps, FlowBranchOneWrapperEvents, FlowBranchOneWrapperSlots> {
+}
+export {};

package/package/components/flows/content/FlowBranchesAllWrapper.svelte

@@ -0,0 +1,89 @@
+<script>import { Alert, Badge, Tab } from '../../common';
+import TabContent from '../../common/tabs/TabContent.svelte';
+import Tabs from '../../common/tabs/Tabs.svelte';
+import Toggle from '../../Toggle.svelte';
+import { Pane, Splitpanes } from 'svelte-splitpanes';
+import SplitPanesWrapper from '../../splitPanes/SplitPanesWrapper.svelte';
+import FlowCard from '../common/FlowCard.svelte';
+import FlowModuleEarlyStop from './FlowModuleEarlyStop.svelte';
+import FlowModuleSleep from './FlowModuleSleep.svelte';
+import FlowModuleSuspend from './FlowModuleSuspend.svelte';
+export let flowModule;
+export let previousModule;
+let value = flowModule.value;
+$: value = flowModule.value;
+let selected = 'early-stop';
+</script>
+
+<div class="h-full flex flex-col w-full">
+	<FlowCard title={value.type == 'branchall' ? 'Run all branches' : 'Run one branch'}>
+		<SplitPanesWrapper>
+			<Splitpanes horizontal>
+				<Pane size={flowModule ? 60 : 100}>
+					<Alert notRounded type="info" title="All branches will be run" class="m-2">
+						The result of this step is the list of the result of each branch.
+					</Alert>
+
+					<div class="p-4 mt-4 w-full">
+						<h3 class="mb-4"
+							>{value.branches.length} branch{value.branches.length > 1 ? 'es' : ''}</h3
+						>
+						<div class="flex flex-col gap-y-4 py-2 w-full">
+							{#each value.branches as branch, i}
+								<div class="flex flex-row gap-x-4 w-full items-center">
+									<div class="grow flex gap-2">
+										<Badge large={true} color="blue">Branch {i + 1}</Badge>
+										<input type="text" bind:value={branch.summary} placeholder="Summary" />
+									</div>
+									<div class="w-min-sm">
+										<Toggle
+											bind:checked={branch.skip_failure}
+											options={{
+												right: 'Skip failure'
+											}}
+										/>
+									</div>
+								</div>
+							{/each}
+						</div>
+						<div class="mt-6 mb-2 text-sm font-bold">Run in parallel</div>
+						<Toggle
+							bind:checked={value.parallel}
+							options={{
+								right: 'All branches run in parallel'
+							}}
+						/>
+					</div>
+				</Pane>
+				{#if flowModule}
+					<Pane size={40}>
+						<Tabs bind:selected>
+							<Tab value="early-stop">Early Stop/Break</Tab>
+							<Tab value="suspend">Suspend</Tab>
+							<Tab value="sleep">Sleep</Tab>
+							<svelte:fragment slot="content">
+								<div class="overflow-hidden bg-white">
+									<TabContent value="early-stop" class="flex flex-col flex-1 h-full">
+										<div class="p-4 overflow-y-auto">
+											<FlowModuleEarlyStop bind:flowModule />
+										</div>
+									</TabContent>
+									<TabContent value="suspend" class="flex flex-col flex-1 h-full">
+										<div class="p-4 overflow-y-auto">
+											<FlowModuleSuspend bind:flowModule />
+										</div>
+									</TabContent>
+									<TabContent value="sleep" class="flex flex-col flex-1 h-full">
+										<div class="p-4 overflow-y-auto">
+											<FlowModuleSleep previousModuleId={previousModule?.id} bind:flowModule />
+										</div>
+									</TabContent>
+								</div>
+							</svelte:fragment>
+						</Tabs>
+					</Pane>
+				{/if}
+			</Splitpanes>
+		</SplitPanesWrapper>
+	</FlowCard>
+</div>

package/package/components/flows/content/FlowBranchesAllWrapper.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+import type { FlowModule } from '../../../gen';
+declare const __propDef: {
+    props: {
+        flowModule: FlowModule;
+        previousModule: FlowModule | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FlowBranchesAllWrapperProps = typeof __propDef.props;
+export type FlowBranchesAllWrapperEvents = typeof __propDef.events;
+export type FlowBranchesAllWrapperSlots = typeof __propDef.slots;
+export default class FlowBranchesAllWrapper extends SvelteComponentTyped<FlowBranchesAllWrapperProps, FlowBranchesAllWrapperEvents, FlowBranchesAllWrapperSlots> {
+}
+export {};