@stubber/form-fields 1.4.6 → 1.5.0

package/dist/fields2/sub/file-field.svelte

@@ -0,0 +1,150 @@
+<script context="module">import {} from "../interfaces";
+export const file_field_param_spec = {
+  spec: {
+    fields: {
+      max_files: {
+        fieldtype: "number"
+      }
+    }
+  }
+};
+</script>
+
+<script>import { Button } from "@stubber/ui/button";
+import { isEmpty, isUndefined } from "lodash-es";
+import Dropzone from "svelte-file-dropzone";
+import FieldLabel from "../FieldLabel.svelte";
+import FieldMessage from "../FieldMessage.svelte";
+import { append_attachment, remove_attachment, uploadFiles } from "../fileserver";
+export let fieldStore;
+$: validation_result = $fieldStore.validation_result;
+$: validation_type = validation_result?.type;
+function parse_string_value(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value !== "" && !isNaN(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
+async function handle_files_select(e) {
+  const { acceptedFiles, fileRejections } = e.detail;
+  if (limit_remaining < acceptedFiles.length) {
+    alert("You have reached the maximum number of files allowed");
+    return;
+  }
+  selected_files = [
+    ...selected_files,
+    ...acceptedFiles.map((f) => ({
+      filename: f.name,
+      f_id: Math.random().toString(36).substring(7)
+    }))
+  ];
+  const upload_res = await uploadFiles(acceptedFiles, $fieldStore.formDependencies);
+  const { uploaded_files: newly_uploaded, failed_files: newly_failed } = upload_res || {
+    uploaded_files: [],
+    failed_files: []
+  };
+  const newly_uploaded_with_f_id = newly_uploaded.map((f) => ({
+    filename: f.filename,
+    fileuuid: f.fileuuid,
+    f_id: Math.random().toString(36).substring(7),
+    originalname: f.originalname,
+    contentType: f.contentType
+  }));
+  for (const f of newly_uploaded) {
+    append_attachment(f, $fieldStore.attachmentsStore);
+  }
+  uploaded_files = [...uploaded_files, ...newly_uploaded_with_f_id];
+  failed_files = [
+    ...failed_files,
+    ...newly_failed.map((f) => ({
+      filename: f.name,
+      f_id: Math.random().toString(36).substring(7)
+    }))
+  ];
+  selected_files = [];
+}
+let uploaded_files = [];
+let failed_files = [];
+let selected_files = [];
+$: update_fieldStore(uploaded_files);
+function update_fieldStore(uploaded_files2) {
+  if (isEmpty(uploaded_files2) && isUndefined($fieldStore.value)) return;
+  $fieldStore.value = uploaded_files2;
+}
+$: all_files = [
+  ...uploaded_files.map((f) => ({ ...f, is_uploaded: true, is_failed: false })),
+  ...failed_files.map((f) => ({ ...f, is_failed: true, is_uploaded: false })),
+  ...selected_files.map((f) => ({ ...f, is_uploaded: false, is_failed: false }))
+];
+let max_files = isNaN(Number($fieldStore.params?.max_files)) ? Infinity : Number($fieldStore.params?.max_files);
+$: limit_remaining = max_files - selected_files.length - uploaded_files.length;
+function remove_file(item) {
+  uploaded_files = uploaded_files?.filter((f) => f.f_id !== item.f_id);
+  failed_files = failed_files?.filter((f) => f.f_id !== item.f_id);
+  selected_files = selected_files?.filter((f) => f.f_id !== item.f_id);
+  if ("fileuuid" in item) {
+    remove_attachment(item.fileuuid, $fieldStore.attachmentsStore);
+  }
+}
+</script>
+
+<FieldLabel {fieldStore} />
+<div class="w-full flex flex-col {validation_type == 'error' ? 'border-b border-warning-500' : ''}">
+  <Dropzone on:drop={handle_files_select} disabled={limit_remaining <= 0}>
+    <div class="flex justify-center h-full flex-col text-center rounded-sm">
+      <div>
+        <p class=" text-surface-800">Drop files to upload</p>
+        <p class=" text-surface-800">
+          Or click <span
+            class="text-primary-500 hover:text-primary-400 hover:underline cursor-pointer"
+            >here</span
+          >
+          to browse
+        </p>
+        {#if limit_remaining <= 0}
+          <p class="text-field text-danger-600 text-sm italic">
+            You have reached the maximum number of files allowed
+          </p>
+        {/if}
+      </div>
+    </div>
+  </Dropzone>
+  <div class="w-full mt-2">
+    {#each all_files as item}
+      <div class="w-full flex flex-row">
+        {#if item.is_uploaded}
+          <div class="px-2">
+            <i class="fa fa-check text-success-500" />
+          </div>
+        {:else if item.is_failed}
+          <div class="px-2 space-x-2 flex items-center text-danger-400">
+            <i class="fa-regular fa-triangle-exclamation" />
+            <p class="hidden md:block text-fluid-md">Failed</p>
+          </div>
+        {:else}
+          <div class="px-2 space-x-2 flex items-center text-surface-500">
+            <p class="hidden md:block text-fluid-md" />
+            <i class="fa fa-pulse fa-spinner" />
+          </div>
+        {/if}
+        <div class="w-full shrink py-1 pl-2 truncate border border-surface-200 rounded-sm">
+          <p class="text-surface-800 text-fluid-md">
+            {item?.filename}
+          </p>
+        </div>
+        <Button
+          type="button"
+          variant="destructive"
+          size="icon"
+          class="shrink-0 ml-1 p-1 px-2 fa-solid fa-2xs fa-x  border-surface-0  "
+          on:click={() => {
+            remove_file(item);
+          }}
+        />
+      </div>
+    {/each}
+  </div>
+</div>
+<FieldMessage {fieldStore} />

package/dist/fields2/sub/file-field.svelte.d.ts

@@ -0,0 +1,27 @@
+import { SvelteComponent } from "svelte";
+import type { Writable } from "svelte/store";
+import { type IBaseField, type IBuiltField, type IInitialForm } from "../interfaces";
+export interface IFileFieldParams {
+    max_files?: number;
+}
+export interface IFileField extends IBaseField<IFileFieldParams> {
+    fieldtype: "file";
+}
+export declare const file_field_param_spec: IInitialForm;
+declare const __propDef: {
+    props: {
+        fieldStore: Writable<IBuiltField<IFileFieldParams>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type FileFieldProps = typeof __propDef.props;
+export type FileFieldEvents = typeof __propDef.events;
+export type FileFieldSlots = typeof __propDef.slots;
+export default class FileField extends SvelteComponent<FileFieldProps, FileFieldEvents, FileFieldSlots> {
+}
+export {};

package/dist/fields2/sub/grid-field.svelte

@@ -0,0 +1,54 @@
+<script context="module">export const grid_field_param_spec = {
+  spec: {
+    fields: {
+      columnDefs: {
+        fieldtype: "jsoneditor",
+        help: "Column Definitions as per https://www.ag-grid.com/javascript-data-grid/column-definitions/"
+      }
+    }
+  }
+};
+</script>
+
+<script>import { createGrid, GridApi } from "ag-grid-community";
+import "ag-grid-community/styles/ag-grid.css";
+import "ag-grid-community/styles/ag-theme-material.css";
+import { onMount } from "svelte";
+import FieldLabel from "../FieldLabel.svelte";
+import FieldMessage from "../FieldMessage.svelte";
+export let fieldStore;
+let gridDiv;
+let gridApi;
+const gridOptions = {
+  autoSizeStrategy: {
+    type: "fitGridWidth",
+    defaultMinWidth: 100
+  },
+  defaultColDef: {
+    suppressMovable: true
+  },
+  onGridReady: (params) => {
+    gridApi = params.api;
+  },
+  onCellValueChanged: () => {
+    let rowData = [];
+    gridApi.forEachNode((node) => rowData.push(node.data));
+    $fieldStore.value = rowData;
+  },
+  // Row Data: The data to be displayed.
+  rowData: [],
+  // Column Definitions: Defines & controls grid columns.
+  columnDefs: []
+};
+onMount(() => {
+  let columnDefs = $fieldStore.params?.columnDefs;
+  if (columnDefs) gridOptions.columnDefs = columnDefs;
+  let rowData = $fieldStore.value;
+  if (Array.isArray(rowData)) gridOptions.rowData = rowData;
+  createGrid(gridDiv, gridOptions);
+});
+</script>
+
+<FieldLabel {fieldStore} />
+<div bind:this={gridDiv} class="ag-theme-material w-full h-96" />
+<FieldMessage {fieldStore} />

package/dist/fields2/sub/grid-field.svelte.d.ts

@@ -0,0 +1,30 @@
+import { SvelteComponent } from "svelte";
+import type { Writable } from "svelte/store";
+import type { IBaseField, IBuiltField, IInitialForm } from "../interfaces";
+interface IGridParams {
+    columnDefs?: ColDef[];
+}
+export declare const grid_field_param_spec: IInitialForm;
+export interface IGridField extends IBaseField<IGridParams> {
+    fieldtype: "grid";
+}
+import { type ColDef } from "ag-grid-community";
+import "ag-grid-community/styles/ag-grid.css";
+import "ag-grid-community/styles/ag-theme-material.css";
+declare const __propDef: {
+    props: {
+        fieldStore: Writable<IBuiltField<IGridParams>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type GridFieldProps = typeof __propDef.props;
+export type GridFieldEvents = typeof __propDef.events;
+export type GridFieldSlots = typeof __propDef.slots;
+export default class GridField extends SvelteComponent<GridFieldProps, GridFieldEvents, GridFieldSlots> {
+}
+export {};

package/dist/fields2/sub/heading-field.svelte

@@ -0,0 +1,28 @@
+<script context="module">import {} from "../interfaces";
+export const heading_field_param_spec = {
+  spec: {
+    fields: {
+      heading_text: {
+        fieldtype: "text"
+      },
+      subheading_text: {
+        fieldtype: "text"
+      }
+    }
+  }
+};
+</script>
+
+<script>export let fieldStore;
+$: heading_text = $fieldStore?.params?.heading_text;
+$: subheading_text = $fieldStore?.params?.subheading_text;
+</script>
+
+<div class="flex flex-col w-full mb-2">
+  {#if heading_text}
+    <h1 class="text-xl text-black tracking-tight font-semibold mt-4">{heading_text}</h1>
+  {/if}
+  {#if subheading_text}
+    <h2 class="text-sm text-surface-500 whitespace-pre-wrap">{subheading_text}</h2>
+  {/if}
+</div>

package/dist/fields2/sub/heading-field.svelte.d.ts

@@ -0,0 +1,28 @@
+import { SvelteComponent } from "svelte";
+import type { Writable } from "svelte/store";
+import { type IBaseField, type IBuiltField, type IInitialForm } from "../interfaces";
+export interface IHeadingFieldParams {
+    heading_text?: string;
+    subheading_text?: string;
+}
+export interface IHeadingField extends IBaseField<IHeadingFieldParams> {
+    fieldtype: "heading";
+}
+export declare const heading_field_param_spec: IInitialForm;
+declare const __propDef: {
+    props: {
+        fieldStore: Writable<IBuiltField<IHeadingFieldParams>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type HeadingFieldProps = typeof __propDef.props;
+export type HeadingFieldEvents = typeof __propDef.events;
+export type HeadingFieldSlots = typeof __propDef.slots;
+export default class HeadingField extends SvelteComponent<HeadingFieldProps, HeadingFieldEvents, HeadingFieldSlots> {
+}
+export {};

package/dist/fields2/sub/hidden-field.svelte

@@ -0,0 +1,142 @@
+<script context="module">import {} from "../interfaces";
+import { debounce, isArray, isEqual, isObject } from "lodash-es";
+import jsonata from "jsonata";
+export const hidden_field_param_spec = {
+  spec: {
+    fields: {
+      type: {
+        fieldtype: "select",
+        details: {
+          datapath: "value"
+        },
+        without_value_details: true,
+        params: {
+          options: [
+            {
+              value: "string",
+              label: "Raw expression"
+            },
+            {
+              value: "jsonata",
+              label: "JSONata expression"
+            },
+            {
+              value: "apicall",
+              label: "API call"
+            }
+          ]
+        }
+      },
+      expression: {
+        conditions: ["form.data.value.type != 'apicall'"],
+        fieldtype: "text",
+        details: {
+          datapath: "value"
+        }
+      },
+      api_params: {
+        fieldtype: "section",
+        conditions: ["form.data.value.type = 'apicall'"],
+        details: {
+          datapath: "value"
+        },
+        fields: {
+          method: { fieldtype: "text" },
+          url: { fieldtype: "text" },
+          headers: {
+            fieldtype: "arraybuilder",
+            params: {
+              new_entry_field: {
+                fieldtype: "section",
+                fields: {
+                  key: { fieldtype: "text" },
+                  value: { fieldtype: "text" }
+                }
+              }
+            }
+          },
+          body: {
+            fieldtype: "jsoneditor"
+          }
+        }
+      }
+    }
+  }
+};
+</script>
+
+<script>export let fieldStore;
+let params = $fieldStore.params;
+let formStore = $fieldStore.formStore;
+$: recalculate_value($formStore);
+async function recalculate_value(form_data) {
+  if (typeof params?.value === "string") {
+    if (params?.value !== $fieldStore.value) {
+      $fieldStore.value = params.value;
+    }
+    return;
+  }
+  if (params?.value) {
+    switch (params?.value?.type) {
+      case "string":
+        if (params?.value?.expression !== $fieldStore.value) {
+          $fieldStore.value = params.value.expression;
+        }
+        return;
+      case "jsonata":
+        if (!params?.value?.expression) return;
+        try {
+          const expression = jsonata(params?.value?.expression);
+          const result = await expression.evaluate({
+            form: {
+              data: form_data
+            }
+          });
+          if (!isEqual(result, $fieldStore.value)) {
+            $fieldStore.value = result;
+          }
+        } catch (err) {
+          if ($fieldStore.value !== void 0) $fieldStore.value = void 0;
+          console.warn(err);
+        }
+        return;
+      case "apicall": {
+        let api_params = params.value?.api_params || {};
+        debounced_api_call(api_params);
+        return;
+      }
+    }
+  }
+}
+const debounced_api_call = debounce(call_api, 500);
+async function call_api(api_params) {
+  const { url, method, headers, body } = api_params;
+  if (method && url) {
+    try {
+      let fetchOptions = { headers: {} };
+      fetchOptions.method = method.toUpperCase();
+      if (isArray(headers)) {
+        for (let h of headers) {
+          let [key, value] = h.split(":");
+          fetchOptions.headers[key] = value;
+        }
+      }
+      if (body) fetchOptions.body = JSON.stringify(body);
+      let res = await fetch(url, fetchOptions);
+      let resJSON;
+      if (res.headers.get("content-type")?.includes("application/json")) {
+        resJSON = await res.json();
+      } else {
+        resJSON = await res.text();
+      }
+      if (!isEqual(resJSON, $fieldStore.value)) {
+        $fieldStore.value = resJSON;
+      }
+    } catch (err) {
+      console.warn(err);
+    }
+  }
+}
+</script>
+
+<input id={$fieldStore.id} name={$fieldStore.id} bind:value={$fieldStore.value} hidden />

package/dist/fields2/sub/hidden-field.svelte.d.ts

@@ -0,0 +1,37 @@
+import { SvelteComponent } from "svelte";
+import type { Writable } from "svelte/store";
+import { type IBaseField, type IBuiltField, type IInitialForm } from "../interfaces";
+interface IApiParams {
+    url?: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    headers?: string[];
+    body?: any;
+}
+export interface IHiddenFieldParams {
+    value: {
+        type: "string" | "jsonata" | "apicall";
+        expression?: string;
+        api_params?: IApiParams;
+    } | string | undefined;
+}
+export interface IHiddenField extends IBaseField<IHiddenFieldParams> {
+    fieldtype: "hidden";
+}
+export declare const hidden_field_param_spec: IInitialForm;
+declare const __propDef: {
+    props: {
+        fieldStore: Writable<IBuiltField<IHiddenFieldParams>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type HiddenFieldProps = typeof __propDef.props;
+export type HiddenFieldEvents = typeof __propDef.events;
+export type HiddenFieldSlots = typeof __propDef.slots;
+export default class HiddenField extends SvelteComponent<HiddenFieldProps, HiddenFieldEvents, HiddenFieldSlots> {
+}
+export {};

package/dist/fields2/sub/hidden-location-field.svelte

@@ -0,0 +1,23 @@
+<script context="module">import { isEqual } from "lodash-es";
+import {} from "../interfaces";
+</script>
+
+<script>import { onMount } from "svelte";
+export let fieldStore;
+onMount(() => {
+  navigator.geolocation.getCurrentPosition((o) => {
+    let { latitude, longitude } = o?.coords || {};
+    if (!latitude || !longitude) return;
+    let value = {
+      lat: latitude,
+      lng: longitude,
+      latlng: `${latitude},${longitude}`
+    };
+    if (!isEqual(value, $fieldStore.value)) {
+      $fieldStore.value = value;
+    }
+  });
+});
+</script>
+
+<input id={$fieldStore.id} name={$fieldStore.id} bind:value={$fieldStore.value} hidden />

package/dist/fields2/sub/hidden-location-field.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponent } from "svelte";
+import type { Writable } from "svelte/store";
+import { type IBaseField, type IBuiltField } from "../interfaces";
+export interface IHiddenLocationField extends IBaseField<{}> {
+    fieldtype: "hiddenlocation";
+}
+declare const __propDef: {
+    props: {
+        fieldStore: Writable<IBuiltField>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type HiddenLocationFieldProps = typeof __propDef.props;
+export type HiddenLocationFieldEvents = typeof __propDef.events;
+export type HiddenLocationFieldSlots = typeof __propDef.slots;
+export default class HiddenLocationField extends SvelteComponent<HiddenLocationFieldProps, HiddenLocationFieldEvents, HiddenLocationFieldSlots> {
+}
+export {};

package/dist/fields2/sub/html-field.svelte

@@ -0,0 +1,22 @@
+<script context="module">import {} from "../interfaces";
+export const html_field_param_spec = {
+  spec: {
+    fields: {
+      html: {
+        fieldtype: "text"
+      }
+    }
+  }
+};
+</script>
+
+<script>export let fieldStore;
+let params = $fieldStore.params;
+$: html = params?.html;
+</script>
+
+<div class="w-full">
+  {#if html}
+    {@html html}
+  {/if}
+</div>

package/dist/fields2/sub/html-field.svelte.d.ts

@@ -0,0 +1,27 @@
+import { SvelteComponent } from "svelte";
+import type { Writable } from "svelte/store";
+import { type IBaseField, type IBuiltField, type IInitialForm } from "../interfaces";
+export interface IHTMLFieldParams {
+    html?: string;
+}
+export interface IHTMLField extends IBaseField<IHTMLFieldParams> {
+    fieldtype: "html";
+}
+export declare const html_field_param_spec: IInitialForm;
+declare const __propDef: {
+    props: {
+        fieldStore: Writable<IBuiltField<IHTMLFieldParams>>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type HtmlFieldProps = typeof __propDef.props;
+export type HtmlFieldEvents = typeof __propDef.events;
+export type HtmlFieldSlots = typeof __propDef.slots;
+export default class HtmlField extends SvelteComponent<HtmlFieldProps, HtmlFieldEvents, HtmlFieldSlots> {
+}
+export {};

package/dist/fields2/sub/json-editor-bound.svelte

@@ -0,0 +1,17 @@
+<script>import { cloneDeep } from "lodash-es";
+import { JSONEditor } from "svelte-jsoneditor";
+export let value;
+$: content = value === void 0 ? { text: "", json: void 0 } : {
+  text: typeof value === "string" ? value : void 0,
+  json: typeof value === "string" ? void 0 : cloneDeep(value)
+};
+function handleChange(new_content) {
+  if ("json" in new_content) {
+    value = cloneDeep(new_content.json);
+  } else if ("text" in new_content) {
+    value = cloneDeep(new_content.text);
+  }
+}
+</script>
+
+<JSONEditor {content} onChange={handleChange} {...$$restProps} />

package/dist/fields2/sub/json-editor-bound.svelte.d.ts

@@ -0,0 +1,65 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        content?: import("svelte-jsoneditor").Content;
+        selection?: import("svelte-jsoneditor").JSONEditorSelection | undefined;
+        readOnly?: boolean;
+        indentation?: number | string;
+        tabSize?: number;
+        mode?: import("svelte-jsoneditor").Mode;
+        mainMenuBar?: boolean;
+        navigationBar?: boolean;
+        statusBar?: boolean;
+        askToFormat?: boolean;
+        escapeControlCharacters?: boolean;
+        escapeUnicodeCharacters?: boolean;
+        flattenColumns?: boolean;
+        parser?: import("svelte-jsoneditor").JSONParser;
+        validator?: import("svelte-jsoneditor").Validator | undefined;
+        validationParser?: import("svelte-jsoneditor").JSONParser;
+        pathParser?: import("svelte-jsoneditor").JSONPathParser;
+        queryLanguages?: import("svelte-jsoneditor").QueryLanguage[];
+        queryLanguageId?: string;
+        onChangeQueryLanguage?: import("svelte-jsoneditor").OnChangeQueryLanguage;
+        onChange?: import("svelte-jsoneditor").OnChange | undefined;
+        onSelect?: import("svelte-jsoneditor").OnSelect | undefined;
+        onRenderValue?: import("svelte-jsoneditor").OnRenderValue;
+        onClassName?: import("svelte-jsoneditor").OnClassName;
+        onRenderMenu?: import("svelte-jsoneditor").OnRenderMenu;
+        onRenderContextMenu?: import("svelte-jsoneditor").OnRenderContextMenu;
+        onChangeMode?: import("svelte-jsoneditor").OnChangeMode;
+        onError?: import("svelte-jsoneditor").OnError;
+        onFocus?: import("svelte-jsoneditor").OnFocus;
+        onBlur?: import("svelte-jsoneditor").OnBlur;
+        get?: () => import("svelte-jsoneditor").Content;
+        set?: (newContent: import("svelte-jsoneditor").Content) => Promise<void>;
+        update?: (updatedContent: import("svelte-jsoneditor").Content) => Promise<void>;
+        patch?: (operations: import("immutable-json-patch").JSONPatchDocument) => Promise<import("svelte-jsoneditor").JSONPatchResult>;
+        select?: (newSelection: import("svelte-jsoneditor").JSONEditorSelection | undefined) => Promise<void>;
+        expand?: (path: import("immutable-json-patch").JSONPath, callback?: import("svelte-jsoneditor").OnExpand) => Promise<void>;
+        collapse?: (path: import("immutable-json-patch").JSONPath, recursive?: boolean) => Promise<void>;
+        transform?: (options: import("svelte-jsoneditor").TransformModalOptions) => void;
+        validate?: () => import("svelte-jsoneditor").ContentErrors | undefined;
+        acceptAutoRepair?: () => Promise<import("svelte-jsoneditor").Content>;
+        scrollTo?: (path: import("immutable-json-patch").JSONPath) => Promise<void>;
+        findElement?: (path: import("immutable-json-patch").JSONPath) => Element | undefined;
+        focus?: () => Promise<void>;
+        refresh?: () => Promise<void>;
+        updateProps?: (props: import("svelte-jsoneditor").JSONEditorPropsOptional) => Promise<void>;
+        destroy?: () => Promise<void>;
+    } & {
+        value: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type JsonEditorBoundProps = typeof __propDef.props;
+export type JsonEditorBoundEvents = typeof __propDef.events;
+export type JsonEditorBoundSlots = typeof __propDef.slots;
+export default class JsonEditorBound extends SvelteComponent<JsonEditorBoundProps, JsonEditorBoundEvents, JsonEditorBoundSlots> {
+}
+export {};