ballerina-core 1.0.199 → 1.0.201

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

@@ -3,15 +3,24 @@ 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,67 +6,105 @@ 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) {
-                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;
+  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);
-    }
-    shouldComponentUpdate() {
-        return false;
-    }
-    render() {
-        return _jsx(_Fragment, {});
-    }
+        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, {});
+  }
 }
-export const CoroutineTemplate = () => Template.Default((props) => {
+export const CoroutineTemplate = () =>
+  Template.Default((props) => {
     var _a, _b;
-    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, {
+    return _jsx(
+      CoroutineComponent,
+      {
         context: props.context,
+        initialCoroutine: props.context.initialCoroutine,
         setState: props.setState,
-        foreignMutations: unit,
-        view: unit,
-    })));
-});
-//# sourceMappingURL=template.js.map
+        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

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

@@ -2,9 +2,18 @@ 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,98 +1,124 @@
 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"))),
+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),
+        ),
         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(() => { });
+          if (current.status.kind == "l") {
+            return Co.SetState(
+              updaters.Core.status(replaceWith("processing shortcircuited")),
+            );
+          } 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)),
-                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.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.GetState().then((current) => {
-                        if (current.status.kind == "l") {
-                            return Co.SetState(updaters.Core.status(replaceWith("processing finished")));
-                        }
-                        else
-                            return Co.Do(() => { });
+                      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)
-                ]).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),
-                            ]);
-                        }
-                    });
-                });
-            }),
-        ]),
-    ]);
+                  ]);
+                }
+              } 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,28 +1,35 @@
 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>>;
-        };
-        Template: {
-            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>>;
     };
-    Operations: {
-        shouldCoroutineRun: <v>(_: Debounced<v>) => boolean;
+    Template: {
+      value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
     };
+  };
+  Operations: {
+    shouldCoroutineRun: <v>(_: Debounced<v>) => boolean;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/debounced/state.js

@@ -1,31 +1,68 @@
 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 }))),
-        },
-        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 }))),
-        },
+  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,
+          }),
+        ),
     },
-    Operations: {
-        shouldCoroutineRun: (_) => _.dirty != "not dirty",
+    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",
+  },
 };
-//# 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