ballerina-core 1.0.228 → 1.0.229

package/bin/src/coroutines/template.d.ts

@@ -3,24 +3,15 @@ import { BasicFun } from "../fun/state";
 import { Coroutine } from "./state";
 import { Template, TemplateProps } from "../template/state";
 export type CoroutineComponentOptions<context, state> = {
-  interval?: number;
-  key?: BasicFun<TemplateProps<context & state, state, Unit>, string>;
-  restartWhenFinished?: boolean;
-  runFilter?: BasicFun<TemplateProps<context & state, state, Unit>, boolean>;
+    interval?: number;
+    key?: BasicFun<TemplateProps<context & state, state, Unit>, string>;
+    restartWhenFinished?: boolean;
+    runFilter?: BasicFun<TemplateProps<context & state, state, Unit>, boolean>;
 };
 type CoroutineReadonlyContext<context, state> = {
-  initialCoroutine: Coroutine<context, state, Unit>;
-  options?: CoroutineComponentOptions<context, state>;
+    initialCoroutine: Coroutine<context, state, Unit>;
+    options?: CoroutineComponentOptions<context, state>;
 };
-export declare const CoroutineTemplate: <
-  context,
-  state,
-  foreignMutations,
->() => Template<
-  context & CoroutineReadonlyContext<context, state> & state,
-  state,
-  foreignMutations,
-  Unit
->;
+export declare const CoroutineTemplate: <context, state, foreignMutations>() => Template<context & CoroutineReadonlyContext<context, state> & state, state, foreignMutations, Unit>;
 export {};
-//# sourceMappingURL=template.d.ts.map
+//# sourceMappingURL=template.d.ts.map

package/bin/src/coroutines/template.js

@@ -6,105 +6,67 @@ import { Coroutine } from "./state";
 import { Template } from "../template/state";
 const Co = Coroutine;
 class CoroutineComponent extends React.Component {
-  constructor(props) {
-    super(props);
-    this.running = false;
-    this.animationFrameId = undefined;
-    this.state = { currentCoroutine: props.initialCoroutine };
-  }
-  componentDidMount() {
-    var _a;
-    let lastTimestamp = Date.now();
-    this.running = true;
-    const tick = () => {
-      if (!this.running) {
+    constructor(props) {
+        super(props);
+        this.running = false;
+        this.animationFrameId = undefined;
+        this.state = { currentCoroutine: props.initialCoroutine };
+    }
+    componentDidMount() {
+        var _a;
+        let lastTimestamp = Date.now();
+        this.running = true;
+        const tick = () => {
+            if (!this.running) {
+                clearInterval(this.animationFrameId);
+                return;
+            }
+            const currTimestamp = Date.now();
+            const step = Co.Tick(this.props.context, this.state.currentCoroutine, currTimestamp - lastTimestamp);
+            lastTimestamp = currTimestamp;
+            if (!this.running)
+                return;
+            if (step.kind == "done") {
+                this.setState((s) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, s), { currentCoroutine: !!((_a = this.props.options) === null || _a === void 0 ? void 0 : _a.restartWhenFinished)
+                            ? this.props.initialCoroutine
+                            : Co.Nothing() }));
+                }, () => step.state && this.running
+                    ? this.props.setState(step.state)
+                    : undefined);
+            }
+            else {
+                this.setState((s) => (Object.assign(Object.assign({}, s), { currentCoroutine: step.next })), () => step.state && this.running
+                    ? this.props.setState(Updater(step.state))
+                    : undefined);
+            }
+            // if (this.running)
+            //   this.animationFrameId = setTimeout(
+            //     tick,
+            //     this.props.options?.interval || 250
+            //   );
+        };
+        this.animationFrameId = setInterval(tick, ((_a = this.props.options) === null || _a === void 0 ? void 0 : _a.interval) || 250);
+    }
+    componentWillUnmount() {
+        this.running = false;
         clearInterval(this.animationFrameId);
-        return;
-      }
-      const currTimestamp = Date.now();
-      const step = Co.Tick(
-        this.props.context,
-        this.state.currentCoroutine,
-        currTimestamp - lastTimestamp,
-      );
-      lastTimestamp = currTimestamp;
-      if (!this.running) return;
-      if (step.kind == "done") {
-        this.setState(
-          (s) => {
-            var _a;
-            return Object.assign(Object.assign({}, s), {
-              currentCoroutine: !!((_a = this.props.options) === null ||
-              _a === void 0
-                ? void 0
-                : _a.restartWhenFinished)
-                ? this.props.initialCoroutine
-                : Co.Nothing(),
-            });
-          },
-          () =>
-            step.state && this.running
-              ? this.props.setState(step.state)
-              : undefined,
-        );
-      } else {
-        this.setState(
-          (s) =>
-            Object.assign(Object.assign({}, s), {
-              currentCoroutine: step.next,
-            }),
-          () =>
-            step.state && this.running
-              ? this.props.setState(Updater(step.state))
-              : undefined,
-        );
-      }
-      // if (this.running)
-      //   this.animationFrameId = setTimeout(
-      //     tick,
-      //     this.props.options?.interval || 250
-      //   );
-    };
-    this.animationFrameId = setInterval(
-      tick,
-      ((_a = this.props.options) === null || _a === void 0
-        ? void 0
-        : _a.interval) || 250,
-    );
-  }
-  componentWillUnmount() {
-    this.running = false;
-    clearInterval(this.animationFrameId);
-  }
-  shouldComponentUpdate() {
-    return false;
-  }
-  render() {
-    return _jsx(_Fragment, {});
-  }
+    }
+    shouldComponentUpdate() {
+        return false;
+    }
+    render() {
+        return _jsx(_Fragment, {});
+    }
 }
-export const CoroutineTemplate = () =>
-  Template.Default((props) => {
+export const CoroutineTemplate = () => Template.Default((props) => {
     var _a, _b;
-    return _jsx(
-      CoroutineComponent,
-      {
+    return (_jsx(CoroutineComponent, { context: props.context, initialCoroutine: props.context.initialCoroutine, setState: props.setState, options: props.context.options }, (_b = (_a = props.context.options) === null || _a === void 0 ? void 0 : _a.key) === null || _b === void 0 ? void 0 : _b.call(_a, {
         context: props.context,
-        initialCoroutine: props.context.initialCoroutine,
         setState: props.setState,
-        options: props.context.options,
-      },
-      (_b =
-        (_a = props.context.options) === null || _a === void 0
-          ? void 0
-          : _a.key) === null || _b === void 0
-        ? void 0
-        : _b.call(_a, {
-            context: props.context,
-            setState: props.setState,
-            foreignMutations: unit,
-            view: unit,
-          }),
-    );
-  });
-//# sourceMappingURL=template.js.map
+        foreignMutations: unit,
+        view: unit,
+    })));
+});
+//# sourceMappingURL=template.js.map

package/bin/src/debounced/coroutines/debounce.d.ts

@@ -2,18 +2,9 @@ import { ApiResultStatus } from "../../apiResultStatus/state";
 import { Coroutine } from "../../coroutines/state";
 import { Unit } from "../../fun/domains/unit/state";
 import { Debounced, DebouncedStatus, DirtyStatus } from "../state";
-export declare const Debounce: <value, context = Unit>(
-  k: Coroutine<value & context, value, ApiResultStatus>,
-  debounceDurationInMs: number,
-  waitBeforeRetryOnTransientFailure?: number,
-) => Coroutine<
-  context &
-    value & {
-      lastUpdated: number;
-      dirty: DirtyStatus;
-      status: import("../../../main").Sum<DebouncedStatus, "debug off">;
-    },
-  Debounced<value>,
-  Unit
->;
-//# sourceMappingURL=debounce.d.ts.map
+export declare const Debounce: <value, context = Unit>(k: Coroutine<value & context, value, ApiResultStatus>, debounceDurationInMs: number, waitBeforeRetryOnTransientFailure?: number) => Coroutine<context & value & {
+    lastUpdated: number;
+    dirty: DirtyStatus;
+    status: import("../../../main").Sum<DebouncedStatus, "debug off">;
+}, Debounced<value>, Unit>;
+//# sourceMappingURL=debounce.d.ts.map

package/bin/src/debounced/coroutines/debounce.js

@@ -1,124 +1,98 @@
 import { CoTypedFactory } from "../../coroutines/builder";
 import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state";
 import { Debounced } from "../state";
-export const Debounce = (
-  k,
-  debounceDurationInMs,
-  waitBeforeRetryOnTransientFailure = debounceDurationInMs * 2,
-) => {
-  const Co = CoTypedFactory();
-  const updaters = Debounced.Updaters;
-  return Co.Seq([
-    Co.SetState(updaters.Core.status(replaceWith("waiting for dirty"))),
-    Co.While(
-      ([current]) =>
-        current.dirty != "dirty" ||
-        Date.now() - current.lastUpdated <= debounceDurationInMs,
-      Co.Wait(debounceDurationInMs / 5),
-    ),
-    Co.SetState(updaters.Core.dirty(replaceWith("dirty but being processed"))),
-    Co.GetState().then((current) => {
-      if (current.status.kind == "l") {
-        return Co.SetState(
-          updaters.Core.status(
-            replaceWith("just detected dirty, starting processing"),
-          ),
-        );
-      } else return Co.Do(() => {});
-    }),
-    Co.Any([
-      // shortcircuit the validation if it takes longer than the whole cycle in the presence of an underwater update of the field
-      Co.Seq([
-        Co.While(
-          ([current]) =>
-            current.dirty != "dirty" ||
-            Date.now() - current.lastUpdated <= debounceDurationInMs,
-          Co.Wait(debounceDurationInMs / 5),
-        ),
+export const Debounce = (k, debounceDurationInMs, waitBeforeRetryOnTransientFailure = debounceDurationInMs * 2) => {
+    const Co = CoTypedFactory();
+    const updaters = Debounced.Updaters;
+    return Co.Seq([
+        Co.SetState(updaters.Core.status(replaceWith("waiting for dirty"))),
+        Co.While(([current]) => current.dirty != "dirty" ||
+            Date.now() - current.lastUpdated <= debounceDurationInMs, Co.Wait(debounceDurationInMs / 5)),
+        Co.SetState(updaters.Core.dirty(replaceWith("dirty but being processed"))),
         Co.GetState().then((current) => {
-          if (current.status.kind == "l") {
-            return Co.SetState(
-              updaters.Core.status(replaceWith("processing shortcircuited")),
-            );
-          } else return Co.Do(() => {});
+            if (current.status.kind == "l") {
+                return Co.SetState(updaters.Core.status(replaceWith("just detected dirty, starting processing")));
+            }
+            else
+                return Co.Do(() => { });
         }),
-        Co.Wait(debounceDurationInMs / 2),
-      ]),
-      k
-        .embed((_) => _, updaters.Core.value)
-        .then((apiResult) => {
-          return Co.Seq([
-            Co.GetState().then((current) => {
-              if (current.status.kind == "l") {
-                return Co.SetState(
-                  updaters.Core.status(replaceWith("processing finished")),
-                );
-              } else return Co.Do(() => {});
-            }),
-            // Co.Wait(250)
-          ]).then(() => {
-            return Co.GetState().then((current) => {
-              // alert(apiResult)
-              if (apiResult == "success" || apiResult == "permanent failure") {
-                // maybe a new change has already reset dirty, in that case we need to start all over again
-                if (current.dirty == "dirty but being processed") {
-                  return Co.Seq([
-                    Co.GetState().then((current) => {
-                      if (current.status.kind == "l") {
-                        return Co.SetState(
-                          updaters.Core.status(
-                            replaceWith(
-                              "state was still dirty but being processed, resetting to not dirty",
-                            ),
-                          ),
-                        );
-                      } else return Co.Do(() => {});
-                    }),
-                    // use UpdateState to make sure that we look up the state at the last possible moment to account for delays
-                    Co.UpdateState((state) =>
-                      state.dirty == "dirty but being processed"
-                        ? updaters.Core.dirty(replaceWith("not dirty"))
-                        : updaters.Core.dirty(replaceWith("dirty")),
-                    ),
-                  ]);
-                } else {
-                  return Co.Seq([
+        Co.Any([
+            // shortcircuit the validation if it takes longer than the whole cycle in the presence of an underwater update of the field
+            Co.Seq([
+                Co.While(([current]) => current.dirty != "dirty" ||
+                    Date.now() - current.lastUpdated <= debounceDurationInMs, Co.Wait(debounceDurationInMs / 5)),
+                Co.GetState().then((current) => {
+                    if (current.status.kind == "l") {
+                        return Co.SetState(updaters.Core.status(replaceWith("processing shortcircuited")));
+                    }
+                    else
+                        return Co.Do(() => { });
+                }),
+                Co.Wait(debounceDurationInMs / 2),
+            ]),
+            k
+                .embed((_) => _, updaters.Core.value)
+                .then((apiResult) => {
+                return Co.Seq([
                     Co.GetState().then((current) => {
-                      if (current.status.kind == "l") {
-                        return Co.SetState(
-                          updaters.Core.status(
-                            replaceWith(
-                              "state was changed underwater back to dirty, leaving the dirty flag alone",
-                            ),
-                          ),
-                        );
-                      } else return Co.Do(() => {});
+                        if (current.status.kind == "l") {
+                            return Co.SetState(updaters.Core.status(replaceWith("processing finished")));
+                        }
+                        else
+                            return Co.Do(() => { });
                     }),
-                    Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
                     // Co.Wait(250)
-                  ]);
-                }
-              } else {
-                return Co.Seq([
-                  Co.GetState().then((current) => {
-                    if (current.status.kind == "l") {
-                      return Co.SetState(
-                        updaters.Core.status(
-                          replaceWith(
-                            "inner call failed with transient failure",
-                          ),
-                        ),
-                      );
-                    } else return Co.Do(() => {});
-                  }),
-                  Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
-                  Co.Wait(waitBeforeRetryOnTransientFailure),
-                ]);
-              }
-            });
-          });
-        }),
-    ]),
-  ]);
+                ]).then(() => {
+                    return Co.GetState().then((current) => {
+                        // alert(apiResult)
+                        if (apiResult == "success" || apiResult == "permanent failure") {
+                            // maybe a new change has already reset dirty, in that case we need to start all over again
+                            if (current.dirty == "dirty but being processed") {
+                                return Co.Seq([
+                                    Co.GetState().then((current) => {
+                                        if (current.status.kind == "l") {
+                                            return Co.SetState(updaters.Core.status(replaceWith("state was still dirty but being processed, resetting to not dirty")));
+                                        }
+                                        else
+                                            return Co.Do(() => { });
+                                    }),
+                                    // use UpdateState to make sure that we look up the state at the last possible moment to account for delays
+                                    Co.UpdateState((state) => state.dirty == "dirty but being processed"
+                                        ? updaters.Core.dirty(replaceWith("not dirty"))
+                                        : updaters.Core.dirty(replaceWith("dirty"))),
+                                ]);
+                            }
+                            else {
+                                return Co.Seq([
+                                    Co.GetState().then((current) => {
+                                        if (current.status.kind == "l") {
+                                            return Co.SetState(updaters.Core.status(replaceWith("state was changed underwater back to dirty, leaving the dirty flag alone")));
+                                        }
+                                        else
+                                            return Co.Do(() => { });
+                                    }),
+                                    Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
+                                    // Co.Wait(250)
+                                ]);
+                            }
+                        }
+                        else {
+                            return Co.Seq([
+                                Co.GetState().then((current) => {
+                                    if (current.status.kind == "l") {
+                                        return Co.SetState(updaters.Core.status(replaceWith("inner call failed with transient failure")));
+                                    }
+                                    else
+                                        return Co.Do(() => { });
+                                }),
+                                Co.SetState(updaters.Core.dirty(replaceWith("dirty"))),
+                                Co.Wait(waitBeforeRetryOnTransientFailure),
+                            ]);
+                        }
+                    });
+                });
+            }),
+        ]),
+    ]);
 };
-//# sourceMappingURL=debounce.js.map
+//# sourceMappingURL=debounce.js.map

package/bin/src/debounced/state.d.ts

@@ -1,35 +1,28 @@
 import { Sum } from "../../main";
 import { BasicUpdater, Updater } from "../fun/domains/updater/state";
 export type DirtyStatus = "dirty" | "not dirty" | "dirty but being processed";
-export type DebouncedStatus =
-  | "waiting for dirty"
-  | "just detected dirty, starting processing"
-  | "processing finished"
-  | "state was still dirty but being processed, resetting to not dirty"
-  | "processing shortcircuited"
-  | "state was changed underwater back to dirty, leaving the dirty flag alone"
-  | "inner call failed with transient failure";
+export type DebouncedStatus = "waiting for dirty" | "just detected dirty, starting processing" | "processing finished" | "state was still dirty but being processed, resetting to not dirty" | "processing shortcircuited" | "state was changed underwater back to dirty, leaving the dirty flag alone" | "inner call failed with transient failure";
 export type Debounced<Value> = Value & {
-  lastUpdated: number;
-  dirty: DirtyStatus;
-  status: Sum<DebouncedStatus, "debug off">;
+    lastUpdated: number;
+    dirty: DirtyStatus;
+    status: Sum<DebouncedStatus, "debug off">;
 };
 export declare const Debounced: {
-  Default: <v>(initialValue: v, debug?: boolean) => Debounced<v>;
-  Updaters: {
-    Core: {
-      status: <v>(_: BasicUpdater<DebouncedStatus>) => Updater<Debounced<v>>;
-      dirty: <v>(_: BasicUpdater<DirtyStatus>) => Updater<Debounced<v>>;
-      lastUpdated: <v>(_: BasicUpdater<number>) => Updater<Debounced<v>>;
-      valueWithoutDebouncing: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
-      value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
+    Default: <v>(initialValue: v, debug?: boolean) => Debounced<v>;
+    Updaters: {
+        Core: {
+            status: <v>(_: BasicUpdater<DebouncedStatus>) => Updater<Debounced<v>>;
+            dirty: <v>(_: BasicUpdater<DirtyStatus>) => Updater<Debounced<v>>;
+            lastUpdated: <v>(_: BasicUpdater<number>) => Updater<Debounced<v>>;
+            valueWithoutDebouncing: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
+            value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
+        };
+        Template: {
+            value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
+        };
     };
-    Template: {
-      value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
+    Operations: {
+        shouldCoroutineRun: <v>(_: Debounced<v>) => boolean;
     };
-  };
-  Operations: {
-    shouldCoroutineRun: <v>(_: Debounced<v>) => boolean;
-  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/debounced/state.js

@@ -1,68 +1,31 @@
 import { Sum } from "../../main";
 import { Updater } from "../fun/domains/updater/state";
 export const Debounced = {
-  Default: (initialValue, debug) =>
-    Object.assign(Object.assign({}, initialValue), {
-      lastUpdated: 0,
-      dirty: "not dirty",
-      status: debug
-        ? Sum.Default.left("waiting for dirty")
-        : Sum.Default.right("debug off"),
-    }),
-  Updaters: {
-    Core: {
-      status: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), {
-            status:
-              current.status.kind == "l"
-                ? Sum.Default.left(_(current.status.value))
-                : Sum.Default.right("debug off"),
-          }),
-        ),
-      dirty: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), {
-            dirty: _(current.dirty),
-          }),
-        ),
-      lastUpdated: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), {
-            lastUpdated: _(current.lastUpdated),
-          }),
-        ),
-      valueWithoutDebouncing: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, current), _(current)),
-        ),
-      value: (_) =>
-        Updater((current) =>
-          Object.assign(Object.assign({}, _(current)), {
-            dirty: current.dirty,
-            lastUpdated: current.lastUpdated,
-            status: current.status,
-          }),
-        ),
+    Default: (initialValue, debug) => (Object.assign(Object.assign({}, initialValue), { lastUpdated: 0, dirty: "not dirty", status: debug
+            ? Sum.Default.left("waiting for dirty")
+            : Sum.Default.right("debug off") })),
+    Updaters: {
+        Core: {
+            status: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { status: current.status.kind == "l"
+                    ? Sum.Default.left(_(current.status.value))
+                    : Sum.Default.right("debug off") }))),
+            dirty: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { dirty: _(current.dirty) }))),
+            lastUpdated: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { lastUpdated: _(current.lastUpdated) }))),
+            valueWithoutDebouncing: (_) => Updater((current) => (Object.assign(Object.assign({}, current), _(current)))),
+            value: (_) => Updater((current) => (Object.assign(Object.assign({}, _(current)), { dirty: current.dirty, lastUpdated: current.lastUpdated, status: current.status }))),
+        },
+        Template: {
+            value: (_) => 
+            // Debounced.Updaters.Core.value(_).then(
+            // 	Debounced.Updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
+            // ).then(
+            // 	Debounced.Updaters.Core.lastUpdated(replaceWith(Date.now()))
+            // )
+            Updater((current) => (Object.assign(Object.assign({}, _(current)), { dirty: "dirty", lastUpdated: Date.now(), status: current.status }))),
+        },
     },
-    Template: {
-      value: (_) =>
-        // Debounced.Updaters.Core.value(_).then(
-        // 	Debounced.Updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
-        // ).then(
-        // 	Debounced.Updaters.Core.lastUpdated(replaceWith(Date.now()))
-        // )
-        Updater((current) =>
-          Object.assign(Object.assign({}, _(current)), {
-            dirty: "dirty",
-            lastUpdated: Date.now(),
-            status: current.status,
-          }),
-        ),
+    Operations: {
+        shouldCoroutineRun: (_) => _.dirty != "not dirty",
     },
-  },
-  Operations: {
-    shouldCoroutineRun: (_) => _.dirty != "not dirty",
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/diagnostics/domains/message-box/state.d.ts

@@ -1,2 +1,2 @@
 export declare const messageBox: <a>(message: string, value: () => a) => a;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/diagnostics/domains/message-box/state.js

@@ -1,5 +1,5 @@
 export const messageBox = (message, value) => {
-  alert(message);
-  return value();
+    alert(message);
+    return value();
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/foreignMutations/state.d.ts

@@ -1,7 +1,7 @@
 import { BasicUpdater } from "../fun/domains/updater/state";
 import { BasicFun } from "../fun/state";
 export type ForeignMutationsInput<context, state> = {
-  context: context & state;
-  setState: BasicFun<BasicUpdater<state>, void>;
+    context: context & state;
+    setState: BasicFun<BasicUpdater<state>, void>;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/foreignMutations/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/attachments/views/attachments-view.d.ts

@@ -1,8 +1,8 @@
 import { OrderedMap } from "immutable";
 import { Guid, SimpleCallback } from "../../../../../main";
 export declare const AttachmentsList: (props: {
-  attachments: OrderedMap<Guid, File>;
-  add: SimpleCallback<[Guid, File]>;
-  remove: SimpleCallback<Guid>;
+    attachments: OrderedMap<Guid, File>;
+    add: SimpleCallback<[Guid, File]>;
+    remove: SimpleCallback<Guid>;
 }) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=attachments-view.d.ts.map
+//# sourceMappingURL=attachments-view.d.ts.map