@kosdev-code/kos-ddk-models 0.1.0-dev.5053

package/index.mjs

@@ -0,0 +1,2832 @@
+var Ur = Object.defineProperty;
+var Vr = (e, t, r) => t in e ? Ur(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var s = (e, t, r) => (Vr(e, typeof t != "symbol" ? t + "" : t, r), r);
+import { resolveServiceUrl as h, ServiceFactory as f, KosLog as g, kosTopicHandler as De, kosModel as l, kosAction as _, Kos as c, isKosModel as u, createPropKey as Hr, kosStateProp as Wr, KosModelRegistrationFactory as ke, kosDependency as m, KosModelContainer as st, resolveContainerDeltas as mt, kosChild as Ie, Device as Nr, kosConfigProperty as d, kosFuture as v, kosModelEffect as Mt, MultipleFutureHandler as zr, FutureEndState as b, TroubleServices as Re, Troubles as yt, SingletonKosModelRegistrationFactory as Fe, FetchError as Ae, FutureManager as T, FutureHandler as he, getKosCompanionModel as at, StorageDeviceContainer as Br, kosFutureAware as Kr, kosLoggerAware as Yr, KosDataContainer as qr, TroubleContainer as nt, troubleByTypeReducer as Gr, registerExtensionPoint as Qr, ExtensionManager as xe, kosConfigBean as Xr, ObservableData as Jr, kosAutoEffect as Zr } from "@kosdev-code/kos-ui-sdk";
+import { AGITATION_REQUIRED_TROUBLE as St, CartridgeAgitatorEvents as Ct, FreestyleHolder as eo } from "@kosdev-code/kos-freestyle-sdk";
+import { Assembly as je, HolderContainer as to, IngredientContainer as ro } from "@kosdev-code/kos-dispense-sdk";
+const bt = "PurgeTrouble", oo = "PrimeTrouble", { URL: lt } = h("AUTH_SERVICE"), { getOne: io, postModel: so } = f.build({
+  basePath: `${lt}/api/auth`
+}), wt = g.createLogger({ name: "auth-service", group: "Services" }), Et = async () => (wt.debug("sending GET for auth"), await io({
+  urlOverride: `${lt}/api/app/kosdev.ddk/auth/role`
+})), Lt = async (e) => (wt.debug("sending POST for auth"), await so({
+  urlOverride: `${lt}/api/app/kosdev.ddk/auth/pincode/${e}`,
+  model: {}
+})), Ss = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getCurrentRole: Et,
+  sendPinCode: Lt
+}, Symbol.toStringTag, { value: "Module" }));
+var ao = Object.defineProperty, no = Object.getOwnPropertyDescriptor, Dt = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? no(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && ao(t, r, o), o;
+};
+const B = "auth-model", vt = (e) => e.toLowerCase();
+let $e = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "currentRole");
+    this.id = e, this.logger = r.logger, this.currentRole = "crew";
+  }
+  async authorize(e) {
+    if (!e)
+      return !1;
+    const t = await Lt(e);
+    return (t == null ? void 0 : t.status) === 200 ? t.data : !1;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing auth ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading auth ${this.id}`);
+    const e = await Et();
+    (e == null ? void 0 : e.status) === 200 && (this.logger.debug(`response ${e.data}`), _(() => {
+      this.currentRole = vt(e.data);
+    }));
+  }
+  handleRoleChange(e) {
+    this.currentRole = vt(e);
+  }
+  forceRole(e) {
+    this.currentRole = e;
+  }
+};
+Dt([
+  De({
+    topic: "/app/kosdev.ddk/auth/role",
+    websocket: !0
+  })
+], $e.prototype, "handleRoleChange", 1);
+$e = Dt([
+  l(B)
+], $e);
+const ct = {
+  registration: {
+    [B]: {
+      class: $e,
+      singleton: !1
+    }
+  },
+  type: B,
+  predicate: u(B),
+  factory: c.Factory.create(B)
+};
+var lo = Object.defineProperty, co = Object.getOwnPropertyDescriptor, kt = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? co(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && lo(t, r, o), o;
+};
+const It = "door-model", uo = Hr("doorPath");
+let Te = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "doorPath");
+    s(this, "open");
+    this.id = e, this.logger = r.logger, this.doorPath = t.doorPath;
+  }
+  get currentState() {
+    return this.open.value === void 0 ? "UNKNOWN" : this.open.value ? "OPEN" : "CLOSED";
+  }
+  get isOpen() {
+    return this.open.value === void 0 ? !0 : this.open.value;
+  }
+};
+kt([
+  Wr({ path: uo, attribute: "state" })
+], Te.prototype, "open", 2);
+Te = kt([
+  l(It)
+], Te);
+const po = new ke({
+  class: Te,
+  type: It
+}), { URL: ut } = h("SETUP-STEP_SERVICE"), { getAll: go, postModel: ho } = f.build({
+  basePath: `${ut}/api/setup-step`
+}), Rt = g.createLogger({
+  name: "setup-step-service",
+  group: "Services"
+}), Ft = async () => (Rt.debug("sending GET for setup-step"), await go({
+  urlOverride: `${ut}/api/app/kosdev.ddk/setup/steps`
+})), At = async (e) => (Rt.debug("sending POST for setup-step"), await ho({
+  urlOverride: `${ut}/api/app/kosdev.ddk/setup/complete/${e}`,
+  model: {}
+})), Cs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getSetupSteps: Ft,
+  markStepComplete: At
+}, Symbol.toStringTag, { value: "Module" }));
+var fo = Object.getOwnPropertyDescriptor, mo = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? fo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = a(o) || o);
+  return o;
+};
+const K = "setup-step-model";
+let Qe = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "idx");
+    s(this, "name");
+    s(this, "complete");
+    s(this, "preStep");
+    s(this, "exclusive");
+    s(this, "logger");
+    this.id = e, this.idx = t.idx, this.logger = r.logger, this.name = t.name, this.complete = t.complete, this.preStep = t.preStep, this.exclusive = t.exclusive;
+  }
+  updateModel(e) {
+    this.name = e.name, this.idx = e.idx, this.complete = e.complete, this.preStep = e.preStep, this.exclusive = e.exclusive;
+  }
+  get titleKey() {
+    return `setup.${this.name}.title`;
+  }
+  get bodyKey() {
+    return `setup.${this.name}.body`;
+  }
+  async completeStep() {
+    const e = await At(this.name);
+    (e == null ? void 0 : e.status) === 200 && _(() => {
+      this.complete = !0;
+    });
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing setup-step ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading setup-step ${this.id}`);
+  }
+};
+Qe = mo([
+  l(K)
+], Qe);
+const xt = {
+  registration: {
+    [K]: {
+      class: Qe,
+      singleton: !1
+    }
+  },
+  type: K,
+  predicate: u(K),
+  factory: c.Factory.create(K)
+};
+var yo = Object.defineProperty, bo = Object.getOwnPropertyDescriptor, Ue = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? bo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && yo(t, r, o), o;
+};
+const Y = "setup-step-container-model";
+function _t(e) {
+  return (t) => {
+    const r = xt.factory(t.id)(t);
+    r.updateModel(t), e.addModel(r);
+  };
+}
+function $t(e) {
+  return (t) => {
+    e.removeModel(t);
+  };
+}
+let R = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "_currentStep");
+    s(this, "logger");
+    s(this, "models");
+    s(this, "authModel");
+    this.id = e, this.logger = r.logger, this._currentStep = void 0, this.models = new st({
+      parentId: e,
+      sortKey: "idx"
+    });
+  }
+  get currentStep() {
+    return this._currentStep;
+  }
+  setCurrentStep(e) {
+    const t = this.models.getModel(e);
+    t && (this._currentStep = t);
+  }
+  nextStep() {
+    if (!this._currentStep)
+      this._currentStep = this.firstIncompleteStep;
+    else {
+      const e = this._currentStep.idx, t = this.models.data.find((r) => r.idx > e);
+      t && (this._currentStep = t);
+    }
+  }
+  get hasIncompletePreSteps() {
+    return this.models.data.some((e) => e.preStep && !e.complete);
+  }
+  get setupRequired() {
+    return this.models.data.some((e) => !e.complete);
+  }
+  get firstIncompleteStep() {
+    return this.models.data.find((e) => !e.complete);
+  }
+  get isLastStep() {
+    var e;
+    return this.models.data[this.models.data.length - 1].id === ((e = this._currentStep) == null ? void 0 : e.id);
+  }
+  get data() {
+    return this.models.data;
+  }
+  getModel(e) {
+    return this.models.getModel(e);
+  }
+  addModel(e) {
+    this.models.addModel(e);
+  }
+  removeModel(e) {
+    this.models.removeModel(e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing setup-step-container container ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading setup-step-container container ${this.id}`);
+    const e = await Ft();
+    if (e != null && e.data) {
+      const t = e.data.map(
+        (r, i) => ({
+          ...r,
+          idx: i,
+          id: `setup-${r.name}`
+        })
+      );
+      mt({
+        container: this.models,
+        onAddItem: _t(this),
+        onRemoveItem: $t(this)
+      })(t);
+    }
+    this.nextStep();
+  }
+  handleStepChanges(e) {
+    const t = e.map((r, i) => ({
+      ...r,
+      idx: i,
+      id: `setup-${r.name}`
+    }));
+    mt({
+      container: this.models,
+      onAddItem: _t(this),
+      onRemoveItem: $t(this)
+    })(t);
+  }
+};
+Ue([
+  Ie
+], R.prototype, "models", 2);
+Ue([
+  m({ modelType: ct.type })
+], R.prototype, "authModel", 2);
+Ue([
+  De({
+    topic: "/app/kosdev.ddk/setup/steps",
+    websocket: !0
+  })
+], R.prototype, "handleStepChanges", 1);
+R = Ue([
+  l(Y)
+], R);
+const jt = {
+  registration: {
+    [Y]: {
+      class: R,
+      singleton: !0
+    },
+    ...xt.registration
+  },
+  type: Y,
+  predicate: u(Y),
+  factory: c.Singleton.create(Y)
+}, { URL: k } = h("AUTH_SERVICE"), { getOne: Ut, getAll: ve } = f.build({
+  basePath: `${k}/api/app/kosdev.ddk/ncui/`
+}), de = g.createLogger({ name: "auth-service", group: "Services" }), vo = async () => {
+  de.debug("sending GET for cuis");
+  const e = await ve({
+    urlOverride: `${k}/api/app/kosdev.ddk/cui`
+  });
+  if ((e == null ? void 0 : e.status) !== 200)
+    throw new Error("Failed to retrieve cuis");
+  return e.data;
+}, _o = async () => {
+  de.debug("sending GET for navigation");
+  try {
+    const e = await ve({
+      urlOverride: `${k}/api/kos/descriptor/app:kosdev.ddk:ncuiDescriptor/kondra.ncui.navigations`
+    });
+    if ((e == null ? void 0 : e.status) !== 200) {
+      de.info("no extensions found, using base data");
+      const t = await ve({
+        urlOverride: `${k}/api/kos/descriptor/system:app/kondra.ncui.navigations`
+      });
+      return (t == null ? void 0 : t.data) ?? [];
+    }
+    return (e == null ? void 0 : e.data) ?? [];
+  } catch {
+    const t = await ve({
+      urlOverride: `${k}/api/kos/descriptor/system:app/kondra.ncui.navigations`
+    });
+    return (t == null ? void 0 : t.data) ?? [];
+  }
+}, $o = async () => (de.debug("navigating to CUI"), await Ut({
+  urlOverride: `${k}/api/app/kosdev.ddk/cui/open`
+})), To = async () => (de.debug("navigating to NCUI"), await Ut({
+  urlOverride: `${k}/api/app/kosdev.ddk/ncui/open`
+}));
+var Po = Object.defineProperty, Oo = Object.getOwnPropertyDescriptor, L = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Oo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Po(t, r, o), o;
+};
+const q = "application-model", Vt = (e, t = "") => e.reduce((r, i) => {
+  const o = t ? `${t}.${i.name}` : i.name;
+  if (r[o] = { ...i, root: !t }, i.children) {
+    const n = Vt(i.children, o);
+    Object.keys(n).forEach((a) => {
+      r[a] = n[a];
+    });
+  }
+  return r;
+}, {});
+let M = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "device");
+    s(this, "authModel");
+    s(this, "setupStepContainer");
+    s(this, "door");
+    s(this, "ncuiLanguage");
+    s(this, "activeCui");
+    s(this, "fallbackCui");
+    s(this, "_cuis", []);
+    s(this, "_navigationItems", []);
+    // @kosConfigProperty({
+    //   path: 'somewhere.enable.dial.animation',
+    //   attribute: 'enableDialAnimation',
+    // })
+    // enableDialAnimation!: KosConfigProperty<boolean>;
+    // @kosConfigProperty({
+    //   path: 'somewhere.enable.modal.animation',
+    //   attribute: 'enableModalAnimation',
+    // })
+    // enableModalAnimation!: KosConfigProperty<boolean>;
+    // @kosConfigProperty({
+    //   path: 'somewhere.enable.sidebar.animation',
+    //   attribute: 'enableSidebarAnimation',
+    // })
+    // enableSidebarAnimation!: KosConfigProperty<boolean>;
+    s(this, "languages");
+    s(this, "logger");
+    this.id = e, this.languages = [], this._cuis = [], this.logger = r.logger, this.door = po.instance("app:kosdev.ddk:service:door:door").options({
+      doorPath: "app:kosdev.ddk:service:door:door"
+    }).build();
+  }
+  get setupRequired() {
+    return this.authModel.currentRole === "crew" ? !1 : this.setupStepContainer.setupRequired;
+  }
+  get currentRole() {
+    return this.authModel.currentRole;
+  }
+  get cuis() {
+    return this._cuis.reduce((e, t) => (e[t.appId] = t, e), {});
+  }
+  get navigationItems() {
+    return Vt(this._navigationItems);
+  }
+  get hasCuiDefined() {
+    return !!this.activeCui.value || !!this.fallbackCui.value;
+  }
+  get doorIsOpen() {
+    return this.door.isOpen;
+  }
+  async enter() {
+    this.logger.info("navigating to NCUI"), await To();
+  }
+  async exit() {
+    this.logger.info("navigating to CUI"), await $o();
+  }
+  // -------------------LIFECYCLE----------------------------
+  async load() {
+    var r, i;
+    this.logger.debug(`loading application ${this.id}`);
+    const e = await _o();
+    this._navigationItems = e;
+    const t = await vo();
+    this._cuis = t, (r = this.setupStepContainer) != null && r.hasIncompletePreSteps && ((i = this.authModel) == null || i.forceRole("technician")), this.languages = [
+      {
+        name: "English",
+        locale: "en"
+      }
+    ];
+  }
+};
+L([
+  m({ modelType: Nr.type })
+], M.prototype, "device", 2);
+L([
+  m({ modelType: ct.type })
+], M.prototype, "authModel", 2);
+L([
+  m({ modelType: jt.type })
+], M.prototype, "setupStepContainer", 2);
+L([
+  Ie
+], M.prototype, "door", 2);
+L([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.ncuiLanguage"
+    //updated attribute for language config property
+  })
+], M.prototype, "ncuiLanguage", 2);
+L([
+  d({
+    path: "app:kosdev.ddk:service:cui",
+    attribute: "activeCui"
+  })
+], M.prototype, "activeCui", 2);
+L([
+  d({
+    path: "app:kosdev.ddk:service:cui",
+    attribute: "fallbackCui"
+  })
+], M.prototype, "fallbackCui", 2);
+M = L([
+  l(q)
+], M);
+const dt = {
+  registration: {
+    [q]: {
+      class: M,
+      singleton: !0
+    }
+  },
+  type: q,
+  predicate: u(q),
+  factory: c.Singleton.create(
+    q
+  )
+}, be = {
+  none: 999,
+  crew: 0,
+  technician: 1,
+  manager: 2
+}, Ht = (e) => (t) => {
+  if (t.type === St)
+    return !1;
+  const r = (t == null ? void 0 : t.role) || "technician";
+  if (e && r) {
+    const i = be[e.toLowerCase()] ?? be.crew, o = be[r.toLowerCase()] ?? be.crew;
+    return i >= o;
+  }
+  return !1;
+};
+var Mo = Object.defineProperty, So = Object.getOwnPropertyDescriptor, V = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? So(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Mo(t, r, o), o;
+};
+const Wt = "agitation-control-model", Xe = "resolve", Co = "agitate";
+let w = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "futureHandler");
+    s(this, "logger");
+    s(this, "troubleContainer");
+    s(this, "_agitationFutureId");
+    s(this, "_canExit", !0);
+    s(this, "_exiting", !1);
+    s(this, "_isFailed", !1);
+    s(this, "disposer");
+    s(this, "application");
+    s(this, "inProgress", []);
+    this.id = e, this.logger = r.logger, this.troubleContainer = t.companionParent, this.futureHandler = new zr(this, Xe);
+  }
+  set isFailed(e) {
+    this._isFailed = e;
+  }
+  get isFailed() {
+    return this._isFailed;
+  }
+  get isDoorClosed() {
+    return !this.application.doorIsOpen;
+  }
+  get isAgitating() {
+    return !!this._agitationFutureId;
+  }
+  set exiting(e) {
+    this._exiting = e;
+  }
+  get exiting() {
+    return this._exiting;
+  }
+  get canExit() {
+    return this.queuedTroubles.length === 0 && this._canExit;
+  }
+  clearAll() {
+    this.queuedTroubles.forEach((e) => {
+      e.clearDefer();
+    });
+  }
+  get readyToResolve() {
+    const e = this.queuedTroubles.length, t = this.queuedTroubles.filter((i) => i.shouldDefer), r = e > 0 && t.length === 0;
+    return this.isDoorClosed && r && this.exiting;
+  }
+  onFutureUpdate(e) {
+    e.endState === b.Success ? (this.logger.debug(
+      `Resolve deferred troubles future ${e.id} completed successfully`
+    ), this.queuedTroubles.forEach((t) => {
+      t.clearDefer();
+    }), _(() => {
+      this._canExit = !0, this._isFailed = !1;
+    })) : (e.endState === b.Fail || e.endState === b.Canceled || e.endState === b.Aborted) && (this.logger.error(`Resolve deferred troubles future ${e.id} failed`), this.clearAll(), _(() => {
+      this._canExit = !1, this._isFailed = !0;
+    }));
+  }
+  async resolveDeferredTroubles(e) {
+    const t = this.queuedTroubles.filter((i) => !i.shouldDefer).map((i) => i.rawId).filter((i) => !this.inProgress.includes(i));
+    return this.inProgress.push(...t), t.length === 0 ? void 0 : await Re.bulkResolveTroubles(
+      t,
+      void 0,
+      e
+    );
+  }
+  get hasQueuedTroubles() {
+    return this.queuedTroubles.length > 0;
+  }
+  get queuedTroubles() {
+    return this.troubleContainer.troubles.getIndexByKey(
+      yt.INDEX_TROUBLES_BY_DEFERRED,
+      yt.TROUBLES_DEFERRED
+    );
+  }
+  get visibleTroubles() {
+    const e = this.application.currentRole;
+    return this.troubleContainer.troubles.data.filter(Ht(e)).filter((t) => t.type !== St);
+  }
+  // -------------------LIFECYCLE----------------------------
+  get future() {
+    return this.futureHandler.future;
+  }
+  get resolveFuture() {
+    return this.futureHandler.getFuture(Xe);
+  }
+  get agitateFuture() {
+    return this.futureHandler.getFuture(Co);
+  }
+  handleAgitationStarted(e) {
+    this.logger.info(`Agitation started for ${e.path}`), this._agitationFutureId = String(e.futureId);
+  }
+  handleAgitationEnded(e) {
+    this.logger.info(`Agitation ended for ${e.path}`), this._agitationFutureId = void 0;
+  }
+  async init() {
+    this.logger.debug(`initializing agitation-control ${this.id}`);
+  }
+  unload() {
+    this.logger.debug(`unloading agitation-control ${this.id}`), this.disposer && this.disposer();
+  }
+  handleReadyToResolve() {
+    this.readyToResolve && (this.logger.info("AgitationControl - Resolving deferred troubles"), this.resolveDeferredTroubles()), this._agitationFutureId && this.logger.info("AgitationControl - Agitation started");
+  }
+  async load() {
+    this.logger.debug(`loading agitation-control ${this.id}`);
+  }
+};
+V([
+  m({ modelType: dt.type })
+], w.prototype, "application", 2);
+V([
+  v({ alias: Xe })
+], w.prototype, "resolveDeferredTroubles", 1);
+V([
+  De({ topic: Ct.TOPIC_AGITATION_STARTED })
+], w.prototype, "handleAgitationStarted", 1);
+V([
+  De({ topic: Ct.TOPIC_AGITATION_ENDED })
+], w.prototype, "handleAgitationEnded", 1);
+V([
+  Mt({
+    dependencies: (e) => [e.readyToResolve, e._agitationFutureId]
+  })
+], w.prototype, "handleReadyToResolve", 1);
+w = V([
+  l(Wt)
+], w);
+const ws = new Fe({
+  class: w,
+  type: Wt
+});
+var wo = Object.defineProperty, Eo = Object.getOwnPropertyDescriptor, fe = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Eo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && wo(t, r, o), o;
+};
+const G = "animation-model";
+let I = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "disableAll");
+    s(this, "enableDial");
+    s(this, "enableModal");
+    s(this, "enableSideBar");
+    this.id = e, this.logger = r.logger;
+  }
+};
+fe([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.disableAll"
+  })
+], I.prototype, "disableAll", 2);
+fe([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.enableDial"
+  })
+], I.prototype, "enableDial", 2);
+fe([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.enableModal"
+  })
+], I.prototype, "enableModal", 2);
+fe([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.enableSideBar"
+  })
+], I.prototype, "enableSideBar", 2);
+I = fe([
+  l(G)
+], I);
+const Lo = {
+  registration: {
+    [G]: {
+      class: I,
+      singleton: !0
+    }
+  },
+  type: G,
+  predicate: u(G),
+  factory: c.Singleton.create(G)
+}, { URL: Do } = h("ANIMATION_SERVICE"), { getAll: ko } = f.build({
+  basePath: `${Do}/api/animation`
+}), Io = g.createLogger({
+  name: "animation-service",
+  group: "Services"
+}), Ro = async () => (Io.debug("sending GET for animation"), await ko({})), Es = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getAnimations: Ro
+}, Symbol.toStringTag, { value: "Module" })), { URL: H } = h("FCM-PUMP_SERVICE"), { postModel: me } = f.build({
+  basePath: `${H}/api/fcm-pump`
+}), y = g.createLogger({
+  name: "fcm-pump-service",
+  group: "Services"
+}), Nt = async (e) => {
+  var t, r, i, o, n;
+  y.debug(
+    `performElectricalTest - sending POST request to /api/ext/freestyle/fcm/diagnostics/${e}/electricalTest`
+  );
+  try {
+    const a = await me({
+      model: {},
+      urlOverride: `${H}/api/ext/freestyle/fcm/diagnostics/${e}/electricalTest`
+    });
+    return y.debug("performElectricalTest - response:", a), ((a == null ? void 0 : a.status) === 200 || (a == null ? void 0 : a.status) === 499) && ((t = a.data) != null && t.error) ? [a.data.error || "unknownError", a.data] : [void 0, a == null ? void 0 : a.data];
+  } catch (a) {
+    if (y.error(
+      `performElectricalTest - sending POST request to /api/ext/freestyle/fcm/diagnostics/${e}/electricalTest`,
+      a
+    ), a instanceof Ae) {
+      const O = ((i = (r = a.payload) == null ? void 0 : r.data) == null ? void 0 : i.error) || ((o = a.payload) == null ? void 0 : o.error) || "unknownError";
+      return [O, ((n = a.payload) == null ? void 0 : n.data) || { error: O }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+}, zt = async (e, t) => {
+  y.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/preCalibrate`
+  );
+  try {
+    const r = await me({
+      model: {},
+      urlOverride: `${H}/api/ext/freestyle/fcm/calibration/${e}/preCalibrate`,
+      tracker: t
+    });
+    return y.debug("performPreCalibrate - response:", r), r != null && r.data && T.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    y.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/preCalibrate`,
+      r
+    );
+    const i = {
+      id: t || "",
+      endState: b.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return T.initiateFuture(i), i;
+  }
+}, Bt = async (e, t) => {
+  y.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/calibrate`
+  );
+  try {
+    const r = await me({
+      model: {},
+      urlOverride: `${H}/api/ext/freestyle/fcm/calibration/${e}/calibrate`,
+      tracker: t
+    });
+    return y.debug("performPreCalibrate - response:", r), r != null && r.data && T.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    y.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/calibrate`,
+      r
+    );
+    const i = {
+      id: t || "",
+      endState: b.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return T.initiateFuture(i), i;
+  }
+}, Kt = async (e, t, r) => {
+  y.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/verify/${t}`
+  );
+  try {
+    const i = await me({
+      model: {},
+      urlOverride: `${H}/api/ext/freestyle/fcm/calibration/${e}/verify/${t}`,
+      tracker: r
+    });
+    return y.debug("performVerify - response:", i), i != null && i.data && T.initiateFuture(i.data), i == null ? void 0 : i.data;
+  } catch (i) {
+    y.error(
+      `performVerify - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/verify/${t}`,
+      i
+    );
+    const o = {
+      id: r || "",
+      endState: b.Fail,
+      tracker: r,
+      reason: "Failed to resolve trouble"
+    };
+    return T.initiateFuture(o), o;
+  }
+}, Fo = (e) => e ? e.data === "success" || !e.data ? "success" : e.data : "error", Yt = async (e, t, r) => {
+  y.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/complete/${t}/${r}`
+  );
+  try {
+    const i = await me({
+      model: {},
+      urlOverride: `${H}/api/ext/freestyle/fcm/calibration/${e}/complete/${t}/${r}`
+    });
+    return y.debug("performPreCalibrate - response:", i), Fo(i == null ? void 0 : i.data);
+  } catch (i) {
+    y.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/complete/${t}/${r}`,
+      i
+    );
+    return;
+  }
+}, Ls = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  performCalibrate: Bt,
+  performComplete: Yt,
+  performElectricalTest: Nt,
+  performPreCalibrate: zt,
+  performVerify: Kt
+}, Symbol.toStringTag, { value: "Module" }));
+var Ao = Object.defineProperty, xo = Object.getOwnPropertyDescriptor, Ve = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? xo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Ao(t, r, o), o;
+};
+const qt = "fcm-pump-model", jo = g.createLogger({ name: "fcm-pump-model" });
+let F = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "pumpModel");
+    s(this, "futureHandler");
+    this.id = e, this.logger = r.logger, this.pumpModel = t.companionParent, this.futureHandler = new he(this);
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  get name() {
+    return this.pumpModel.name;
+  }
+  get canPour() {
+    return this.pumpModel.canPour;
+  }
+  get isPouring() {
+    return this.pumpModel.isPouring;
+  }
+  async cancelPour() {
+    return this.pumpModel.cancelPour();
+  }
+  performIntent(e) {
+    return this.pumpModel.performIntent(e);
+  }
+  async performElectricalTest() {
+    const [e, t] = await Nt(this.pumpModel.path);
+    return e && jo.error(`Failed to perform electrical test on pump ${this.id}`, e), t;
+  }
+  getChildren() {
+    return [...this.futureHandler.allFutures];
+  }
+  async performPreCalibrate(e) {
+    return zt(this.pumpModel.path, e);
+  }
+  async performCalibrate(e) {
+    return Bt(this.pumpModel.path, e);
+  }
+  async performVerify(e, t) {
+    return Kt(this.pumpModel.path, e, t);
+  }
+  async performComplete(e, t) {
+    return Yt(this.pumpModel.path, e, t);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing fcm-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading fcm-pump ${this.id}`);
+  }
+};
+Ve([
+  v()
+], F.prototype, "performPreCalibrate", 1);
+Ve([
+  v()
+], F.prototype, "performCalibrate", 1);
+Ve([
+  v()
+], F.prototype, "performVerify", 1);
+F = Ve([
+  l(qt)
+], F);
+const Gt = new ke({
+  class: F,
+  type: qt
+});
+var Uo = Object.defineProperty, Vo = Object.getOwnPropertyDescriptor, Qt = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Vo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Uo(t, r, o), o;
+};
+const Q = "carb-water-model";
+let Pe = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "assemblyModel");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger;
+  }
+  getPump() {
+    const t = this.assemblyModel.getHoldersByGroup("carb")[0].pumps.data[0];
+    return at(t, Gt.type);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing carb-water ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading carb-water ${this.id}`);
+  }
+};
+Qt([
+  m({ modelType: je.type })
+], Pe.prototype, "assemblyModel", 2);
+Pe = Qt([
+  l(Q)
+], Pe);
+const Ho = {
+  registration: {
+    [Q]: {
+      class: Pe,
+      singleton: !1
+    }
+  },
+  type: Q,
+  predicate: u(Q),
+  factory: c.Factory.create(Q)
+}, { URL: W } = h("COPY-LOGS_SERVICE"), { getAll: Wo, getOne: No, postModel: Xt, deleteModel: zo } = f.build({
+  basePath: `${W}/api/copy-logs`
+}), Oe = g.createLogger({
+  name: "copy-logs-service",
+  group: "Services"
+}), Jt = async (e, t) => {
+  const r = await zo({
+    tracker: t,
+    id: e,
+    urlOverride: `${W}/api/app/kosdev.ddk/copyLogs/${e}`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r.data;
+}, Zt = async (e, t) => {
+  const r = await Xt({
+    model: {},
+    tracker: t,
+    urlOverride: `${W}/api/app/kosdev.ddk/copyLogs/eraseAndCopy/${e}`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r.data;
+}, er = async (e, t) => {
+  const r = await Xt({
+    model: {},
+    tracker: t,
+    urlOverride: `${W}/api/app/kosdev.ddk/copyLogs/${e}`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r.data;
+}, tr = async () => {
+  Oe.debug("sending GET for copy-logs");
+  try {
+    const e = await Wo({
+      urlOverride: `${W}/api/app/kosdev.ddk/copyLogs/volumes/size`
+    });
+    return [void 0, e == null ? void 0 : e.data];
+  } catch (e) {
+    if (e instanceof Ae)
+      return Oe.error(`Error fetching log file size: ${e.payload.error}`), [e.payload.error, void 0];
+  }
+  return ["unknownError", void 0];
+}, rr = async () => {
+  Oe.debug("sending GET for log file size");
+  try {
+    const e = await No({
+      urlOverride: `${W}/api/app/kosdev.ddk/copyLogs/files/size`
+    });
+    return [void 0, e == null ? void 0 : e.data];
+  } catch (e) {
+    if (e instanceof Ae)
+      return Oe.error(`Error fetching log file size: ${e.payload.error}`), [e.payload.error, void 0];
+  }
+  return ["unknownError", void 0];
+}, Ds = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  copyLogFromVolume: er,
+  eraseAndCopyLogsToVolume: Zt,
+  eraseVolume: Jt,
+  getLogFileSize: rr,
+  getVolumes: tr
+}, Symbol.toStringTag, { value: "Module" }));
+var or = Object.defineProperty, Bo = Object.getOwnPropertyDescriptor, Ko = (e, t, r) => t in e ? or(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, N = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Bo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && or(t, r, o), o;
+}, Yo = (e, t, r) => (Ko(e, t + "", r), r);
+const qo = "copy-logs-model";
+let S = class {
+  constructor(e) {
+    s(this, "id");
+    s(this, "_volumes");
+    s(this, "storageDeviceContainer");
+    s(this, "_activeVolume");
+    s(this, "_logFileSize", 0);
+    s(this, "_actionState", "idle");
+    s(this, "copyProgress");
+    this.id = e, this._volumes = new qr(), this._activeVolume = void 0, this.copyProgress = {
+      bytesCopied: 0,
+      bytesToCopy: 0,
+      filesCopied: 0,
+      filesSkipped: 0
+    };
+  }
+  // -------------------LIFECYCLE----------------------------
+  get volumes() {
+    return this._volumes.data;
+  }
+  get activeVolume() {
+    return this._activeVolume;
+  }
+  get logFileSize() {
+    return this._logFileSize;
+  }
+  reset() {
+    this.clearActiveVolume(), this.futureHandler.removeFuture();
+  }
+  clearActiveVolume() {
+    this._activeVolume = void 0;
+  }
+  updateActiveVolume(e) {
+    this._activeVolume = e;
+  }
+  get inserted() {
+    return this.storageDeviceContainer.isStorageInserted;
+  }
+  updateLogFileSize(e) {
+    this._logFileSize = e;
+  }
+  get canCopyLogs() {
+    return this.inserted && this._activeVolume;
+  }
+  get actionState() {
+    return this._actionState;
+  }
+  get diskFull() {
+    var e;
+    return ((e = this.future) == null ? void 0 : e.status) === b.Success && this.copyProgress.filesSkipped > 0;
+  }
+  onFutureUpdate(e) {
+    this.logger.info(`Future update: ${e.status}`), e.status === b.Success && (this.logger.info(`Future success: ${e.status}`), this.diskFull && _(() => {
+      e.endState = b.Fail, e.reason = "errDiskFull";
+    })), e.status === b.Fail && this.logger.error(`Future failed: ${e.status}`), e.note === "copy" ? _(() => {
+      this._actionState = "copying", this.copyProgress = e.clientData || {
+        bytesCopied: 0,
+        bytesToCopy: 0,
+        filesCopied: 0,
+        filesSkipped: 0
+      };
+    }) : (this._actionState = "erasing", _(() => {
+      this.copyProgress = {
+        bytesCopied: 0,
+        bytesToCopy: 0,
+        filesCopied: 0,
+        filesSkipped: 0
+      };
+    }));
+  }
+  async eraseAndCopyVolume(e) {
+    var t;
+    if (!e)
+      throw new Error("No tracker provided");
+    if (_(() => {
+      this._actionState = "erasing";
+    }), !this._activeVolume)
+      throw this.logger.error("No active volume selected"), new Error("No active volume selected");
+    return this.logger.info(`Erasing volume ${(t = this._activeVolume) == null ? void 0 : t.name}`), Zt(this._activeVolume.id, e);
+  }
+  async eraseVolume(e) {
+    var t;
+    if (!e)
+      throw new Error("No tracker provided");
+    if (_(() => {
+      this._actionState = "erasing";
+    }), !this._activeVolume)
+      throw this.logger.error("No active volume selected"), new Error("No active volume selected");
+    return this.logger.info(`Erasing volume ${(t = this._activeVolume) == null ? void 0 : t.name}`), Jt(this._activeVolume.id, e);
+  }
+  async copyLogs(e) {
+    var t;
+    if (!e)
+      throw new Error("No tracker provided");
+    if (_(() => {
+      this._actionState = "copying";
+    }), !this._activeVolume)
+      throw this.logger.error("No active volume selected"), new Error("No active volume selected");
+    return this.logger.info(`Copying logs to ${(t = this._activeVolume) == null ? void 0 : t.name}`), er(this._activeVolume.id, e);
+  }
+  handleInsertion() {
+    this.inserted ? this.syncVolumes() : (this._volumes.clear(), this.clearActiveVolume());
+  }
+  async init() {
+    this.logger.debug(`initializing copy-logs ${this.id}`);
+  }
+  async syncVolumes() {
+    const [e, t] = await tr(), [r, i] = await rr();
+    if (r) {
+      this.logger.error(`Error fetching log file size: ${r}`);
+      return;
+    }
+    if (e) {
+      this.logger.error(`Error fetching volumes: ${e}`);
+      return;
+    }
+    t && (t.forEach((o) => {
+      const n = this.storageDeviceContainer.getModel(o.id);
+      if (n) {
+        const a = {
+          id: o.id,
+          name: n.label,
+          freeBytes: o.info.freeBytes,
+          totalBytes: o.info.totalBytes
+        };
+        this._volumes.addModel(a);
+      }
+    }), t.length === 1 ? this.updateActiveVolume(this._volumes.data[0]) : this.clearActiveVolume()), i && (this.logger.info(`Log file size: ${i}`), this.updateLogFileSize(parseInt(i, 10)));
+  }
+  async activate() {
+    this.logger.debug(`activating copy-logs ${this.id}`), await this.syncVolumes();
+  }
+  async load() {
+    this.logger.debug(`loading copy-logs ${this.id}`);
+  }
+};
+Yo(S, "Registration");
+N([
+  m({ modelType: Br.type })
+], S.prototype, "storageDeviceContainer", 2);
+N([
+  v()
+], S.prototype, "eraseAndCopyVolume", 1);
+N([
+  v()
+], S.prototype, "eraseVolume", 1);
+N([
+  v()
+], S.prototype, "copyLogs", 1);
+N([
+  Mt({
+    dependencies: (e) => [e.inserted]
+  })
+], S.prototype, "handleInsertion", 1);
+S = N([
+  l({ modelTypeId: qo, singleton: !0 }),
+  Kr(),
+  Yr()
+], S);
+const ks = S.Registration, ir = g.createLogger({
+  name: "dashboard-operations-service",
+  group: "Services"
+}), sr = async (e, t) => (ir.debug("resolveAll"), await Re.bulkResolveTroubles(
+  e,
+  void 0,
+  t
+)), ar = async (e, t) => (ir.debug("resolveTrouble"), await Re.resolveTrouble(
+  e,
+  void 0,
+  t
+)), Is = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  resolveAll: sr,
+  resolveTrouble: ar
+}, Symbol.toStringTag, { value: "Module" }));
+var Go = Object.defineProperty, Qo = Object.getOwnPropertyDescriptor, He = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Qo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Go(t, r, o), o;
+};
+const X = "dashboard-operations-model";
+function Tt(e) {
+  return !e.deferred;
+}
+function Pt(e) {
+  return e.deferred;
+}
+let A = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "troubles");
+    s(this, "futureHandler");
+    s(this, "logger");
+    this.id = e, this.futureHandler = new he(this), this.logger = r.logger;
+  }
+  get troublesByType() {
+    return this.troubles.troubles.data.reduce(
+      Gr,
+      {}
+    );
+  }
+  get queuedPurgeTroubles() {
+    return this.purgeTroubles.filter(Pt);
+  }
+  get queuedPrimeTroubles() {
+    return this.primeTroubles.filter(Pt);
+  }
+  get resolvablePrimeTroubles() {
+    return this.primeTroubles.filter(Tt);
+  }
+  get resolvablePurgeTroubles() {
+    return this.purgeTroubles.filter(Tt);
+  }
+  get hasResolvablePurgeTroubles() {
+    return this.resolvablePurgeTroubles.length > 0;
+  }
+  get hasResolvablePrimeTroubles() {
+    return this.resolvablePrimeTroubles.length > 0;
+  }
+  get hasPurgeTroubles() {
+    return this.purgeTroubles.length > 0;
+  }
+  get hasPrimeTroubles() {
+    return this.primeTroubles.length > 0;
+  }
+  get purgeTroubles() {
+    return this.troublesByType[bt] || [];
+  }
+  get primeTroubles() {
+    return this.troublesByType[oo] || [];
+  }
+  get future() {
+    return this.futureHandler.getFuture();
+  }
+  async resolveAllTroubles(e, t) {
+    if (!t)
+      throw new Error("No tracker provided");
+    const r = e === bt ? this.purgeTroubles : this.primeTroubles;
+    r.filter((a) => a.shouldDefer).forEach((a) => {
+      this.logger.info(`Deferring trouble ${a.rawId}`), a.defer();
+    });
+    const o = r.filter((a) => !a.shouldDefer).map((a) => a.rawId);
+    return o.length === 0 ? void 0 : await sr(o, t);
+  }
+  async resolveTrouble(e, t) {
+    if (!t)
+      throw new Error("No tracker provided");
+    return await ar(e, t);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing dashboard-operations ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading dashboard-operations ${this.id}`);
+  }
+};
+He([
+  m({ modelType: nt.type })
+], A.prototype, "troubles", 2);
+He([
+  v()
+], A.prototype, "resolveAllTroubles", 1);
+He([
+  v()
+], A.prototype, "resolveTrouble", 1);
+A = He([
+  l(X)
+], A);
+const pt = {
+  registration: {
+    [X]: {
+      class: A,
+      singleton: !0
+    }
+  },
+  type: X,
+  predicate: u(X),
+  factory: c.Singleton.create(X)
+};
+var Xo = Object.getOwnPropertyDescriptor, Jo = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Xo(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = a(o) || o);
+  return o;
+};
+const J = "dispenser-model";
+let Je = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger;
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing dispenser ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading dispenser ${this.id}`);
+  }
+};
+Je = Jo([
+  l(J)
+], Je);
+const Zo = {
+  registration: {
+    [J]: {
+      class: Je,
+      singleton: !0
+    }
+  },
+  type: J,
+  predicate: u(J),
+  factory: c.Singleton.create(J)
+}, { URL: ei } = h("DISPENSER_SERVICE"), { getAll: ti } = f.build({
+  basePath: `${ei}/api/dispenser`
+}), ri = g.createLogger({
+  name: "dispenser-service",
+  group: "Services"
+}), oi = async () => (ri.debug("sending GET for dispenser"), await ti({})), Rs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getDispensers: oi
+}, Symbol.toStringTag, { value: "Module" }));
+var ii = Object.defineProperty, si = Object.getOwnPropertyDescriptor, nr = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? si(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && ii(t, r, o), o;
+};
+const Z = "dispenser-info-model";
+let Me = class {
+  constructor(e, t, r) {
+    s(this, "logger");
+    s(this, "id");
+    s(this, "name");
+    this.id = e, this.logger = r.logger;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing dispenser-info ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading dispenser-info ${this.id}`);
+  }
+};
+nr([
+  d({
+    path: "kos:device",
+    attribute: "name"
+  })
+], Me.prototype, "name", 2);
+Me = nr([
+  l(Z)
+], Me);
+const ai = {
+  registration: {
+    [Z]: {
+      class: Me,
+      singleton: !1
+    }
+  },
+  type: Z,
+  predicate: u(Z),
+  factory: c.Factory.create(
+    Z
+  )
+}, { URL: ni } = h("DISPENSER-INFO_SERVICE"), { getAll: li } = f.build({
+  basePath: `${ni}/api/dispenser-info`
+}), ci = g.createLogger({
+  name: "dispenser-info-service",
+  group: "Services"
+}), ui = async () => (ci.debug("sending GET for dispenser-info"), await li({})), Fs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getDispenserInfos: ui
+}, Symbol.toStringTag, { value: "Module" }));
+var di = Object.getOwnPropertyDescriptor, pi = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? di(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = a(o) || o);
+  return o;
+};
+const ee = "enrollment-model";
+let Ze = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "enrolled");
+    this.id = e, this.logger = r.logger, this.enrolled = !1;
+  }
+  updateModel(e) {
+    console.log("updateModel:", e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing enrollment ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading enrollment ${this.id}`);
+  }
+};
+Ze = pi([
+  l(ee)
+], Ze);
+const gi = {
+  registration: {
+    [ee]: {
+      class: Ze,
+      singleton: !0
+    }
+  },
+  type: ee,
+  predicate: u(ee),
+  factory: c.Singleton.create(ee)
+}, { URL: hi } = h("ENROLLMENT_SERVICE"), { getAll: fi } = f.build({
+  basePath: `${hi}/api/enrollment`
+}), mi = g.createLogger({
+  name: "enrollment-service",
+  group: "Services"
+}), yi = async () => (mi.debug("sending GET for enrollment"), await fi({})), As = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getEnrollments: yi
+}, Symbol.toStringTag, { value: "Module" })), xs = (e) => e.toLowerCase().includes("micros"), js = (e) => !e.toLowerCase().includes("micros"), Us = (e) => (t) => {
+  const r = e == null ? void 0 : e.getHoldersByGroup(t);
+  return r ? r.map((i) => ({ id: i.id, name: i.ingredientName, path: i.path })) : null;
+}, Vs = ["water", "carb", "ns", "nss"], pe = "dashboardKeyFactory", Ye = [];
+Qr(pe, {
+  register: (e, t) => {
+    Ye.includes(t) || Ye.push(t);
+  },
+  execute: (e, t) => {
+    const r = Ye.sort((i, o) => i.rank - o.rank);
+    for (const i of r) {
+      const o = i.factory(t);
+      if (o)
+        return o;
+    }
+  }
+});
+const bi = (e) => {
+  xe[pe].register(
+    pe,
+    e
+  );
+}, vi = (e) => xe[pe].execute(
+  pe,
+  e
+);
+xe.registerDashboardKeyFactory = bi;
+xe.executeDashboardKeyFactory = vi;
+const et = 3600, lr = 60, Hs = (e) => {
+  const t = Math.floor(e / et), r = Math.floor(e % et / lr);
+  return { hours: t, minutes: r };
+}, Ws = (e, t) => e * et + t * lr, _i = (e) => {
+  const r = (/* @__PURE__ */ new Date()).valueOf() - e.valueOf(), i = Math.floor(r / (1e3 * 60)), o = Math.floor(i / 60), n = Math.floor(o / 24), a = i % 60, O = o % 24;
+  let D = "";
+  return n > 0 && (D += `${n} day${n > 1 ? "s" : ""} `), O > 0 && (D += `${O} hour${O > 1 ? "s" : ""} `), (a > 0 || n === 0 && O === 0) && (D += `${a} minute${a > 1 ? "s" : ""} `), D;
+};
+var $i = Object.defineProperty, Ti = Object.getOwnPropertyDescriptor, We = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Ti(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && $i(t, r, o), o;
+};
+const te = "ingredient-summary-model";
+let x = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "assemblyModel");
+    s(this, "dashboardOperationModel");
+    s(this, "appModel");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger, this.dashboardOperationModel = pt.factory({});
+  }
+  get highPriorityHolders() {
+    return this.assemblyModel.allHolders.filter(
+      (e) => e.troubles.length > 0 && e.troubles.find((t) => t.rank >= 400)
+    );
+  }
+  get actionRequiredHolders() {
+    const e = this.appModel.currentRole, t = Ht(e);
+    return this.assemblyModel.allHolders.filter((r) => {
+      const i = at(
+        r,
+        eo.type
+      );
+      if (i != null && i.isRemote)
+        return !1;
+      const o = r.troubles.filter(t);
+      return o.length > 0 && o.find((n) => n.resolvable);
+    });
+  }
+  get lowLevelHolders() {
+    return this.assemblyModel.allHolders.filter((e) => {
+      const t = e.fillPercent;
+      return e.hasFuelGuage && t < 20;
+    });
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing ingredient-summary ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading ingredient-summary ${this.id}`);
+  }
+};
+We([
+  m({ modelType: je.type })
+], x.prototype, "assemblyModel", 2);
+We([
+  m({ modelType: pt.type })
+], x.prototype, "dashboardOperationModel", 2);
+We([
+  m({ modelType: dt.type })
+], x.prototype, "appModel", 2);
+x = We([
+  l(te)
+], x);
+const Pi = {
+  registration: {
+    [te]: {
+      class: x,
+      singleton: !1
+    }
+  },
+  type: te,
+  predicate: u(te),
+  factory: c.Factory.create(
+    te
+  )
+};
+var Oi = Object.getOwnPropertyDescriptor, Mi = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Oi(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = a(o) || o);
+  return o;
+};
+const cr = "lfcv-pump-model";
+let tt = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "pumpModel");
+    this.id = e, this.logger = r.logger, this.pumpModel = t.companionParent;
+  }
+  get name() {
+    return this.pumpModel.name;
+  }
+  get canPour() {
+    return this.pumpModel.canPour;
+  }
+  get isPouring() {
+    return this.pumpModel.isPouring;
+  }
+  async cancelPour() {
+    return this.pumpModel.cancelPour();
+  }
+  performIntent(e) {
+    return this.pumpModel.performIntent(e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing lfcv-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading lfcv-pump ${this.id}`);
+  }
+};
+tt = Mi([
+  l(cr)
+], tt);
+const Ns = new ke({
+  class: tt,
+  type: cr
+}), { URL: Si } = h("LFCV-PUMP_SERVICE"), { getAll: Ci } = f.build({
+  basePath: `${Si}/api/lfcv-pump`
+}), wi = g.createLogger({
+  name: "lfcv-pump-service",
+  group: "Services"
+}), Ei = async () => (wi.debug("sending GET for lfcv-pump"), await Ci({})), zs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getLfcvPumps: Ei
+}, Symbol.toStringTag, { value: "Module" })), { URL: gt } = h("LOCKOUT_SERVICE"), { postModel: ur } = f.build({
+  basePath: `${gt}/api/app/kosdev.ddk/lockout`
+}), dr = g.createLogger({ name: "lockout-service", group: "Services" }), Li = async () => (dr.info("lock"), await ur({
+  model: {},
+  urlOverride: `${gt}/api/app/kosdev.ddk/lockout/lockNow`
+})), pr = async (e) => {
+  dr.info("unlock");
+  const t = await ur({
+    model: {},
+    urlOverride: `${gt}/api/app/kosdev.ddk/lockout/unlock/${e}`
+  });
+  return t == null ? void 0 : t.data;
+}, Bs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  lock: Li,
+  unlock: pr
+}, Symbol.toStringTag, { value: "Module" }));
+var Di = Object.defineProperty, ki = Object.getOwnPropertyDescriptor, z = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? ki(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Di(t, r, o), o;
+};
+const gr = "lockout-model", Ii = [
+  { day: "monday", lock: "dayWiseLockConfigMap.Mon.enabled", open: "dayWiseLockConfigMap.Mon.unlockTime", close: "dayWiseLockConfigMap.Mon.lockTime" },
+  { day: "tuesday", lock: "dayWiseLockConfigMap.Tue.enabled", open: "dayWiseLockConfigMap.Tue.unlockTime", close: "dayWiseLockConfigMap.Tue.lockTime" },
+  { day: "wednesday", lock: "dayWiseLockConfigMap.Wed.enabled", open: "dayWiseLockConfigMap.Wed.unlockTime", close: "dayWiseLockConfigMap.Wed.lockTime" },
+  { day: "thursday", lock: "dayWiseLockConfigMap.Thu.enabled", open: "dayWiseLockConfigMap.Thu.unlockTime", close: "dayWiseLockConfigMap.Thu.lockTime" },
+  { day: "friday", lock: "dayWiseLockConfigMap.Fri.enabled", open: "dayWiseLockConfigMap.Fri.unlockTime", close: "dayWiseLockConfigMap.Fri.lockTime" },
+  { day: "saturday", lock: "dayWiseLockConfigMap.Sat.enabled", open: "dayWiseLockConfigMap.Sat.unlockTime", close: "dayWiseLockConfigMap.Sat.lockTime" },
+  { day: "sunday", lock: "dayWiseLockConfigMap.Sun.enabled", open: "dayWiseLockConfigMap.Sun.unlockTime", close: "dayWiseLockConfigMap.Sun.lockTime" }
+];
+let E = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "dayEnabledList", [
+      "dayWiseLockConfigMap.Sun.enabled",
+      "dayWiseLockConfigMap.Mon.enabled",
+      "dayWiseLockConfigMap.Tue.enabled",
+      "dayWiseLockConfigMap.Wed.enabled",
+      "dayWiseLockConfigMap.Thu.enabled",
+      "dayWiseLockConfigMap.Fri.enabled",
+      "dayWiseLockConfigMap.Sat.enabled"
+    ]);
+    s(this, "dayOpenAtList", [
+      "dayWiseLockConfigMap.Sun.unlockTime",
+      "dayWiseLockConfigMap.Mon.unlockTime",
+      "dayWiseLockConfigMap.Tue.unlockTime",
+      "dayWiseLockConfigMap.Wed.unlockTime",
+      "dayWiseLockConfigMap.Thu.unlockTime",
+      "dayWiseLockConfigMap.Fri.unlockTime",
+      "dayWiseLockConfigMap.Sat.unlockTime"
+    ]);
+    s(this, "dayCloseAtList", [
+      "dayWiseLockConfigMap.Sun.lockTime",
+      "dayWiseLockConfigMap.Mon.lockTime",
+      "dayWiseLockConfigMap.Tue.lockTime",
+      "dayWiseLockConfigMap.Wed.lockTime",
+      "dayWiseLockConfigMap.Thu.lockTime",
+      "dayWiseLockConfigMap.Fri.lockTime",
+      "dayWiseLockConfigMap.Sat.lockTime"
+    ]);
+    s(this, "saveMap");
+    s(this, "pin");
+    s(this, "nextLockSkipped");
+    s(this, "nextLockTime");
+    s(this, "nextUnLockTime");
+    s(this, "cuiLockout");
+    this.id = e, this.logger = r.logger, this.saveMap = /* @__PURE__ */ new Map();
+  }
+  get enabled() {
+    const e = this.getProp(
+      "oneTimeLockConfig.lockTime"
+    ), t = e !== void 0 && e !== "", r = this.getProp("lockScheduleEnabled");
+    return t || r;
+  }
+  get schedule() {
+    return Ii;
+  }
+  getProp(e) {
+    return this.saveMap.get(e);
+  }
+  setProp(e, t) {
+    this.saveMap.set(e, t);
+  }
+  // Skip or resume the next lock...
+  toggleSkip() {
+    if (this.nextLockSkipped.value === "0") {
+      const t = this.nextLockTime.value;
+      t !== void 0 && this.nextLockSkipped.updateProperty(t);
+    } else
+      this.nextLockSkipped.updateProperty("0");
+  }
+  async unlock(e) {
+    return await pr(e);
+  }
+  async save() {
+    return this.saveMap.forEach((e, t) => {
+      e !== this.cuiLockout.props[t] && (this.cuiLockout.props[t] = e);
+    }), this.cuiLockout.updateConfigBean();
+  }
+  reset() {
+    this.cuiLockout.props.entries.forEach(
+      ([e, t]) => this.saveMap.set(e, t)
+    );
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing lockout ${this.id}`), this.cuiLockout.props.entries.forEach(
+      ([e, t]) => this.saveMap.set(e, t)
+    );
+  }
+  async load() {
+    this.logger.debug(`loading lockout ${this.id}`);
+  }
+};
+z([
+  d({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "pin"
+  })
+], E.prototype, "pin", 2);
+z([
+  d({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "nextLockSkipped"
+  })
+], E.prototype, "nextLockSkipped", 2);
+z([
+  d({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "nextLockTime"
+  })
+], E.prototype, "nextLockTime", 2);
+z([
+  d({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "nextUnLockTime"
+  })
+], E.prototype, "nextUnLockTime", 2);
+z([
+  Xr({ path: "app:kosdev.ddk:service:cuiLockout" })
+], E.prototype, "cuiLockout", 2);
+E = z([
+  l(gr)
+], E);
+const Ks = new Fe({
+  class: E,
+  type: gr
+}), Ri = async (e, t) => await Re.bulkResolveTroubles(
+  e,
+  void 0,
+  t
+);
+var Fi = Object.defineProperty, Ai = Object.getOwnPropertyDescriptor, Ne = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Ai(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Fi(t, r, o), o;
+};
+const re = "macro-assignment-model", Ot = "PurgeTrouble", xi = "PrimeTrouble";
+let j = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    /**
+     * futureHandler is used to handle async operations
+     */
+    s(this, "futureHandler");
+    s(this, "holders");
+    s(this, "ingredients");
+    this.id = e, this.futureHandler = new he(), this.logger = r.logger;
+  }
+  /**
+   * shortcut to the current running future
+   */
+  get future() {
+    return this.futureHandler.future;
+  }
+  /**
+   * Represents the subset of holder that are identified as holding macros.
+   *
+   * This is determined by the group property of the holder which is determined
+   * by the holders position in the dispenser assembly.
+   */
+  get macroHolders() {
+    return this.holders.holders.getIndexByKey("group", "macros").sort((e, t) => e.name < t.name ? -1 : e.name > t.name ? 1 : 0);
+  }
+  /**
+   * Returns true if there are any macro holders in the dispenser assembly
+   */
+  get hasMacroHolders() {
+    return this.macroHolders.length > 0;
+  }
+  /**
+   * Returns all of the purge troubles for the macro holders.
+   *
+   * Relying on the indexing of troubles by type to find the purge troubles.
+   */
+  get holderPurgeTroubles() {
+    return this.macroHolders.reduce((t, r) => {
+      const i = r.troublesByType[Ot] || [];
+      return t = [...t, ...i], t;
+    }, []);
+  }
+  get holderPrimeTroubles() {
+    return this.macroHolders.reduce((t, r) => {
+      const i = r.troublesByType[xi] || [];
+      return t = [...t, ...i], t;
+    }, []);
+  }
+  /**
+   * Returns true if there are any purge troubles for the macro holders.
+   */
+  get hasHolderPurgeTroubles() {
+    return this.holderPurgeTroubles.length > 0;
+  }
+  get hasHolderPrimeTroubles() {
+    return this.holderPrimeTroubles.length > 0;
+  }
+  /**
+   * Represents the subset of ingredients that are identified as macros
+   *
+   * This is determined by the `ingredientMacro` property of the ingredient
+   * which is derived from the `bib` and `sweetener` properties of the ingredient.
+   *
+   * The  `ingredientMacro` property is set by the `ingredientDataMapper` extension point.
+   *
+   * The macro ingredients are indexed by the `ingredientIndexExtension` extension point using
+   * the `ingredientMacro` property.
+   */
+  get macroIngredients() {
+    return this.ingredients.ingredients.getIndexByKey("macro", "macro");
+  }
+  /**
+   * Returns true if there are any macro ingredients in the dispenser brandset
+   */
+  get hasMacroIngredients() {
+    return this.macroIngredients.length > 0;
+  }
+  async resolveAll(e, t) {
+    if (!t)
+      throw new Error("No tracker provided");
+    const i = (e === Ot ? this.holderPurgeTroubles : this.holderPrimeTroubles).map((n) => n.rawId);
+    return await Ri(i, t);
+  }
+};
+Ne([
+  m({ modelType: to.type })
+], j.prototype, "holders", 2);
+Ne([
+  m({ modelType: ro.type })
+], j.prototype, "ingredients", 2);
+Ne([
+  v()
+], j.prototype, "resolveAll", 1);
+j = Ne([
+  l(re)
+], j);
+const ji = {
+  registration: {
+    [re]: {
+      class: j,
+      singleton: !0
+    }
+  },
+  type: re,
+  predicate: u(re),
+  factory: c.Singleton.create(
+    re
+  )
+};
+var Ui = Object.getOwnPropertyDescriptor, Vi = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Ui(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = a(o) || o);
+  return o;
+};
+const oe = "network-test-model";
+let rt = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "group");
+    s(this, "passed");
+    s(this, "inProgress");
+    s(this, "failureTime");
+    s(this, "timestamp");
+    s(this, "name");
+    s(this, "results");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger, this.group = t.group, this.passed = !1, this.inProgress = !1, this.name = t.name, this.results = [];
+  }
+  updateModel(e) {
+    this.group = e.group, this.name = e.name, this.passed = e.passed, this.failureTime = e.failureTime, this.inProgress = e.inProgress, this.timestamp = e.timestamp, this.results = e.results;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing network-test ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading network-test ${this.id}`);
+  }
+};
+rt = Vi([
+  l(oe)
+], rt);
+const hr = {
+  registration: {
+    [oe]: {
+      class: rt,
+      singleton: !1
+    }
+  },
+  type: oe,
+  predicate: u(oe),
+  factory: c.Factory.create(oe)
+}, { URL: ze } = h("NETWORK-TEST_SERVICE"), { getAll: Hi, getOne: fr } = f.build({
+  basePath: `${ze}/api/app/ncui/network/tests`
+}), Wi = g.createLogger({
+  name: "network-test-service",
+  group: "Services"
+}), mr = async () => {
+  Wi.debug("sending GET for network-test");
+  const e = await Hi({
+    urlOverride: `${ze}/api/app/kosdev.ddk/network/tests`
+  });
+  return e == null ? void 0 : e.data;
+}, yr = async () => {
+  const e = await fr({
+    urlOverride: `${ze}/api/app/kosdev.ddk/network/reports`
+  });
+  return e == null ? void 0 : e.data;
+}, br = async (e, t) => await fr({
+  urlOverride: `${ze}/api/app/kosdev.ddk/network/tests/run/group/${e}`,
+  tracker: t
+}), Ys = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getNetworkTests: mr,
+  getTestsReports: yr,
+  performGroupTest: br
+}, Symbol.toStringTag, { value: "Module" }));
+var Ni = Object.defineProperty, zi = Object.getOwnPropertyDescriptor, ht = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? zi(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Ni(t, r, o), o;
+};
+const ie = "network-test-container-model";
+let ge = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "lastTested");
+    s(this, "futureHandler");
+    s(this, "models");
+    this.id = e, this.logger = r.logger, this.futureHandler = new he(this), this.models = new st({
+      parentId: e,
+      indexMap: {
+        group: "group"
+      }
+    }), this.lastTested = /* @__PURE__ */ new Date("default");
+  }
+  get data() {
+    return this.models.data;
+  }
+  addModel(e) {
+    this.models.addModel(e);
+  }
+  removeModel(e) {
+    this.models.removeModel(e);
+  }
+  getModel(e) {
+    return this.models.getModel(e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(
+      `initializing network-test-container container ${this.id}`
+    );
+  }
+  getLastTested(e) {
+    const t = this.models.getIndexByKey("group", e).map((i) => i.timestamp && new Date(i.timestamp)), r = Math.max(
+      ...t.map((i) => i ? i.getTime() : 0)
+    );
+    return r ? _i(new Date(r)) : "";
+  }
+  async load() {
+    this.logger.debug(`loading network-test-container container ${this.id}`);
+    const e = await mr(), t = await yr();
+    e && e.forEach((r) => {
+      const i = hr.factory(r.id)(r);
+      this.addModel(i);
+    }), e && t && e.forEach((r) => {
+      const i = t == null ? void 0 : t[r.group], o = i == null ? void 0 : i[r.id], n = this.getModel(r.id);
+      if (n && o) {
+        const a = {
+          group: o.group,
+          name: o.name,
+          passed: o.passed,
+          failureTime: o.failureTime ? new Date(o.failureTime) : void 0,
+          inProgress: o.inProgress,
+          timestamp: new Date(o.timestamp),
+          results: o.results
+        };
+        n.updateModel(a);
+      }
+    });
+  }
+  async performTest(e, t) {
+    if (!t)
+      throw new Error("No tracker provided");
+    const r = await br(e, t);
+    return r == null ? void 0 : r.data;
+  }
+  onFutureUpdate(e) {
+    const { clientData: t } = e;
+    t && t.forEach((r) => {
+      const i = this.getModel(r.id);
+      if (_(() => {
+        this.lastTested = this.lastTested > new Date(r.timestamp) ? this.lastTested : new Date(r.timestamp);
+      }), i) {
+        const o = {
+          group: r.group,
+          name: r.name,
+          passed: r.passed,
+          failureTime: r.failureTime ? new Date(r.failureTime) : void 0,
+          inProgress: r.inProgress,
+          timestamp: new Date(r.timestamp),
+          results: r.results
+        };
+        _(() => {
+          i.updateModel(o);
+        });
+      }
+    });
+  }
+};
+ht([
+  Ie
+], ge.prototype, "models", 2);
+ht([
+  v()
+], ge.prototype, "performTest", 1);
+ge = ht([
+  l(ie)
+], ge);
+const Bi = {
+  registration: {
+    [ie]: {
+      class: ge,
+      singleton: !0
+    },
+    ...hr.registration
+  },
+  type: ie,
+  predicate: u(ie),
+  factory: c.Singleton.create(ie)
+};
+var Ki = Object.defineProperty, Yi = Object.getOwnPropertyDescriptor, vr = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Yi(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Ki(t, r, o), o;
+};
+const se = "nutritive-sweetener-model";
+let Se = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "assemblyModel");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger;
+  }
+  getHolder() {
+    return this.assemblyModel.getHoldersByGroup("ns")[0];
+  }
+  getPump() {
+    return this.getHolder().pumps.data[0];
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing nutritive-sweetener ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading nutritive-sweetener ${this.id}`);
+  }
+};
+vr([
+  m({ modelType: je.type })
+], Se.prototype, "assemblyModel", 2);
+Se = vr([
+  l(se)
+], Se);
+const qi = {
+  registration: {
+    [se]: {
+      class: Se,
+      singleton: !1
+    }
+  },
+  type: se,
+  predicate: u(se),
+  factory: c.Factory.create(se)
+};
+var Gi = Object.defineProperty, Qi = Object.getOwnPropertyDescriptor, _r = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? Qi(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && Gi(t, r, o), o;
+};
+const ae = "plain-water-model";
+let Ce = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "assemblyModel");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger;
+  }
+  getHolder() {
+    return this.assemblyModel.getHoldersByGroup("water")[0];
+  }
+  getPump() {
+    var i, o;
+    const e = this.getHolder(), t = (o = (i = e == null ? void 0 : e.pumps) == null ? void 0 : i.data) == null ? void 0 : o[0];
+    return at(t, Gt.type);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing plain-water ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading plain-water ${this.id}`);
+  }
+};
+_r([
+  m({ modelType: je.type })
+], Ce.prototype, "assemblyModel", 2);
+Ce = _r([
+  l(ae)
+], Ce);
+const Xi = {
+  registration: {
+    [ae]: {
+      class: Ce,
+      singleton: !1
+    }
+  },
+  type: ae,
+  predicate: u(ae),
+  factory: c.Factory.create(ae)
+}, { URL: $r } = h("REBOOT_SERVICE"), { postModel: Ji } = f.build({
+  basePath: `${$r}/api/reboot`
+}), Zi = g.createLogger({ name: "reboot-service", group: "Services" }), Tr = async () => (Zi.debug("sending POST call for Reboot Dispenser"), await Ji({
+  urlOverride: `${$r}/api/app/kosdev.ddk/ncui/reboot`,
+  model: {}
+})), qs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  rebootDispenser: Tr
+}, Symbol.toStringTag, { value: "Module" }));
+var es = Object.getOwnPropertyDescriptor, ts = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? es(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = a(o) || o);
+  return o;
+};
+const ne = "reboot-model";
+let ot = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger;
+  }
+  async completeReboot() {
+    await Tr();
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing reboot ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading reboot ${this.id}`);
+  }
+};
+ot = ts([
+  l(ne)
+], ot);
+const rs = {
+  registration: {
+    [ne]: {
+      class: ot,
+      singleton: !1
+    }
+  },
+  type: ne,
+  predicate: u(ne),
+  factory: c.Factory.create(ne)
+};
+var os = Object.defineProperty, is = Object.getOwnPropertyDescriptor, C = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? is(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && os(t, r, o), o;
+};
+const le = "settings-model";
+let P = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "ncuiLanguageData");
+    s(this, "resolveDelaysMs");
+    s(this, "dateFormat");
+    s(this, "timeFormat");
+    s(this, "hidePlainWaterBev");
+    s(this, "hideCarbWaterBev");
+    s(this, "ncuiLanguage");
+    s(this, "name");
+    s(this, "activateAndRebootTime");
+    this.id = e, this.logger = r.logger;
+  }
+  updateModel(e) {
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing settings ${this.id}`);
+  }
+  async getNcuiLanguageList() {
+    this.ncuiLanguageData = {
+      status: 200,
+      data: {
+        languages: [
+          {
+            name: "English",
+            locale: "en"
+          }
+        ]
+      }
+    };
+  }
+  async load() {
+    this.logger.debug(`loading settings ${this.id}`), this.ncuiLanguageData = {
+      status: 200,
+      data: {
+        languages: [
+          {
+            name: "English",
+            locale: "en"
+          }
+        ]
+      }
+    };
+  }
+};
+C([
+  d({
+    path: "system:app",
+    attribute: "resolveDelaysMs"
+    // optionsExpander: () => [],
+  })
+], P.prototype, "resolveDelaysMs", 2);
+C([
+  d({
+    path: "system:app",
+    attribute: "dateFormat"
+    // optionsExpander: () => [],
+  })
+], P.prototype, "dateFormat", 2);
+C([
+  d({
+    path: "system:app",
+    attribute: "timeFormat"
+    // optionsExpander: () => [],
+  })
+], P.prototype, "timeFormat", 2);
+C([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.hidePlainWaterBev"
+  })
+], P.prototype, "hidePlainWaterBev", 2);
+C([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.hideCarbWaterBev"
+  })
+], P.prototype, "hideCarbWaterBev", 2);
+C([
+  d({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.ncuiLanguage"
+  })
+], P.prototype, "ncuiLanguage", 2);
+C([
+  d({
+    path: "kos:device",
+    attribute: "name"
+  })
+], P.prototype, "name", 2);
+C([
+  d({
+    path: "kos:service:OTA",
+    attribute: "activateAndRebootTime"
+  })
+], P.prototype, "activateAndRebootTime", 2);
+P = C([
+  l(le)
+], P);
+const ss = {
+  registration: {
+    [le]: {
+      class: P,
+      singleton: !0
+    }
+  },
+  type: le,
+  predicate: u(le),
+  factory: c.Singleton.create(le)
+}, { URL: Pr } = h("SETTINGS_SERVICE"), { getAll: Or } = f.build({
+  basePath: `${Pr}/api/settings`
+}), as = g.createLogger({
+  name: "settings-service",
+  group: "Services"
+}), ns = async () => (as.debug("sending GET for settings"), await Or({})), ls = async () => await Or({
+  urlOverride: `${Pr}api/app/kosdev.ddk/ncui/languages`
+}), Gs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getNcuiLanguage: ls,
+  getSettings: ns
+}, Symbol.toStringTag, { value: "Module" }));
+var cs = Object.getOwnPropertyDescriptor, us = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? cs(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = a(o) || o);
+  return o;
+};
+const ce = "utilities-model";
+let it = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "name");
+    s(this, "options");
+    s(this, "roles");
+    s(this, "columnId");
+    s(this, "logger");
+    this.id = e, this.logger = r.logger, this.name = t.name, this.options = t.options, this.roles = t == null ? void 0 : t.roles, this.columnId = t.columnId;
+  }
+  updateModel(e) {
+    this.name = e.name, this.options = e.options, this.roles = e == null ? void 0 : e.roles;
+  }
+  get titleKey() {
+    return `utility.${this.id}.title`;
+  }
+  get bodyKey() {
+    return `utility.${this.id}.body`;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing utilities ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading utilities ${this.id}`);
+  }
+};
+it = us([
+  l(ce)
+], it);
+const Mr = {
+  registration: {
+    [ce]: {
+      class: it,
+      singleton: !1
+    }
+  },
+  type: ce,
+  predicate: u(ce),
+  factory: c.Factory.create(ce)
+}, { URL: _e } = h("UTILITIES_SERVICE"), { getAll: qe } = f.build({
+  basePath: `${_e}/api/utilities`
+}), Ge = g.createLogger({
+  name: "utilities-service",
+  group: "Services"
+}), Sr = async () => {
+  Ge.debug("sending GET for utilities");
+  try {
+    const e = await qe({
+      urlOverride: `${_e}/api/kos/descriptor/app:kosdev.ddk:ncuiDescriptor/kondra.ncui.utilities`
+    });
+    if ((e == null ? void 0 : e.status) !== 200) {
+      Ge.info("no extensions found, using base data");
+      const t = await qe({
+        urlOverride: `${_e}/api/kos/descriptor/system:app/kondra.ncui.utilities`
+      });
+      return (t == null ? void 0 : t.data) ?? [];
+    }
+    return (e == null ? void 0 : e.data) ?? [];
+  } catch (e) {
+    Ge.info(`error fetching utilities: ${e}. Using base data`);
+    const t = await qe({
+      urlOverride: `${_e}/api/kos/descriptor/system:app/kondra.ncui.utilities`
+    });
+    return (t == null ? void 0 : t.data) ?? [];
+  }
+}, Qs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getUtilities: Sr
+}, Symbol.toStringTag, { value: "Module" }));
+var ds = Object.defineProperty, ps = Object.getOwnPropertyDescriptor, Cr = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? ps(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && ds(t, r, o), o;
+};
+const ue = "utilities-container-model";
+let we = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "_models");
+    this.id = e, this.logger = r.logger, this._models = new st({
+      parentId: e,
+      sortKey: "id",
+      indexMap: {
+        byColumn: "columnId"
+      }
+    });
+  }
+  get data() {
+    return this._models.data;
+  }
+  get models() {
+    return this._models;
+  }
+  get columns() {
+    return this._models.getIndexKeys("byColumn").sort((e, t) => e.localeCompare(t));
+  }
+  addModel(e) {
+    this._models.addModel(e);
+  }
+  removeModel(e) {
+    this._models.removeModel(e);
+  }
+  getModel(e) {
+    return this._models.getModel(e);
+  }
+  getUtilitiesByColumn(e) {
+    return this._models.getIndexByKey("byColumn", e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async load() {
+    this.logger.debug(`loading utilities-container container ${this.id}`);
+    const e = await Sr();
+    e == null || e.forEach((t, r) => {
+      t.forEach((i) => {
+        const o = {
+          ...i,
+          columnId: String(r)
+        }, n = Mr.factory(i.name)(
+          o
+        );
+        this.addModel(n);
+      });
+    });
+  }
+};
+Cr([
+  Ie
+], we.prototype, "_models", 2);
+we = Cr([
+  l(ue)
+], we);
+const gs = {
+  registration: {
+    [ue]: {
+      class: we,
+      singleton: !0
+    },
+    ...Mr.registration
+  },
+  type: ue,
+  predicate: u(ue),
+  factory: c.Singleton.create(ue)
+}, Xs = {
+  ...Lo.registration,
+  ...dt.registration,
+  ...ct.registration,
+  ...Ho.registration,
+  ...pt.registration,
+  ...Zo.registration,
+  ...ai.registration,
+  ...gi.registration,
+  ...Pi.registration,
+  ...ji.registration,
+  ...Bi.registration,
+  ...qi.registration,
+  ...Xi.registration,
+  ...rs.registration,
+  ...ss.registration,
+  ...jt.registration,
+  ...gs.registration
+};
+var hs = Object.defineProperty, fs = Object.getOwnPropertyDescriptor, wr = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? fs(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && hs(t, r, o), o;
+};
+const Er = "trouble-action-model";
+let Ee = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "troubleContainer");
+    s(this, "disposer");
+    s(this, "state");
+    s(this, "troubleActionData");
+    this.id = e, this.logger = r.logger, this.state = Jr(), this.troubleActionData = t.definitions.reduce((i, o) => (i[o.troubleType] = o, i), {});
+  }
+  // -------------------LIFECYCLE----------------------------
+  get activeTrouble() {
+    const e = Object.keys(this.troubleActionData);
+    if (e.length > 0) {
+      const t = e[0], r = this.troubleContainer.troubles.getIndexByKey(
+        "byType",
+        t
+      );
+      return r.length > 0 ? r[0] : void 0;
+    }
+  }
+  get activeTroubleType() {
+    var e;
+    return (e = this.activeTrouble) == null ? void 0 : e.type;
+  }
+  async init() {
+    this.logger.debug(`initializing trouble-action ${this.id}`), this.disposer = Zr(() => {
+      const e = this.troubleContainer.troubles.data.reduce((t, r) => {
+        const i = r.type;
+        if (this.troubleActionData[i]) {
+          const o = this.troubleActionData[i].stateKey ?? i, n = this.troubleActionData[i].stateValue ?? i;
+          t[o] = n;
+        }
+        return t;
+      }, {});
+      this.state.setValues(e), Object.keys(this.troubleActionData).forEach((t) => {
+        if (this.troubleContainer.troubles.getIndexByKey("byType", t).length === 0) {
+          const r = this.troubleActionData[t].stateKey ?? t;
+          this.state[r] = void 0;
+        }
+      });
+    });
+  }
+  unload() {
+    var e;
+    (e = this.disposer) == null || e.call(this);
+  }
+  async load() {
+    this.logger.debug(`loading trouble-action ${this.id}`);
+  }
+};
+wr([
+  m({ modelType: nt.type })
+], Ee.prototype, "troubleContainer", 2);
+Ee = wr([
+  l(Er)
+], Ee);
+const Js = new Fe({
+  class: Ee,
+  type: Er
+}), { URL: Lr } = h("START_SERVICE"), { getOne: ms } = f.build({
+  basePath: `${Lr}/api/start`
+}), ys = g.createLogger({ name: "start-service", group: "Services" }), Dr = async () => (ys.debug("navigating to NCUI"), await ms({
+  urlOverride: `${Lr}/api/app/kosdev.ddk/ncui/open`
+})), Zs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  navigateToNCui: Dr
+}, Symbol.toStringTag, { value: "Module" }));
+var bs = Object.defineProperty, vs = Object.getOwnPropertyDescriptor, kr = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? vs(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && bs(t, r, o), o;
+};
+const Ir = "start-model";
+let Le = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "troubles");
+    this.id = e, this.logger = r.logger;
+  }
+  get firmwareFailed() {
+    return this.troubles.troubles.getIndexByKey(
+      "byType",
+      "FirmwareUpdateFailedTrouble"
+    ).length > 0;
+  }
+  get firmwareInProgress() {
+    return this.troubles.troubles.getIndexByKey(
+      "byType",
+      "FirmwareUpdateInProgressTrouble"
+    ).length > 0;
+  }
+  async navigate() {
+    await Dr();
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing start ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading start ${this.id}`);
+  }
+};
+kr([
+  m({ modelType: nt.type })
+], Le.prototype, "troubles", 2);
+Le = kr([
+  l(Ir)
+], Le);
+const ea = new Fe({
+  class: Le,
+  type: Ir
+}), { URL: ye } = h("SPM-PUMP_SERVICE"), { postModel: Be } = f.build({
+  basePath: `${ye}/api/spm-pump`
+}), $ = g.createLogger({
+  name: "spm-pump-service",
+  group: "Services"
+}), Rr = async (e, t) => {
+  $.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/preCalibrate`
+  );
+  try {
+    const r = await Be({
+      model: {},
+      urlOverride: `${ye}/api/ext/freestyle/microCalibration/pour/${e}/preCalibrate`,
+      tracker: t
+    });
+    return $.debug("performPreCalibrate - response:", r), r != null && r.data && T.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    $.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/preCalibrate`,
+      r
+    );
+    const i = {
+      id: t || "",
+      endState: b.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return T.initiateFuture(i), i;
+  }
+}, Fr = async (e, t) => {
+  $.debug(
+    `performCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/calibrate`
+  );
+  try {
+    const r = await Be({
+      model: {},
+      urlOverride: `${ye}/api/ext/freestyle/microCalibration/pour/${e}/calibrate`,
+      tracker: t
+    });
+    return $.debug("performCalibrate - response:", r), r != null && r.data && T.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    $.error(
+      `performCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/calibrate`,
+      r
+    );
+    const i = {
+      id: t || "",
+      endState: b.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return T.initiateFuture(i), i;
+  }
+}, Ar = async (e, t, r, i) => {
+  $.debug(
+    `performVerify - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/verify`
+  );
+  try {
+    const o = await Be({
+      model: {
+        ...r,
+        // commandedCalibrationVolume: 0,
+        measuredCalibrationVolume: t
+        // measuredVerificationVolume: 0,
+        // newCalibrationValue: 0,
+        // pouredCalibrationVolume: 0,
+      },
+      urlOverride: `${ye}/api/ext/freestyle/microCalibration/pour/${e}/verify`,
+      tracker: i
+    });
+    return $.debug("performVerify - response:", o), o != null && o.data && T.initiateFuture(o.data), o == null ? void 0 : o.data;
+  } catch (o) {
+    $.error(
+      `performVerify - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/verify`,
+      o
+    );
+    const n = {
+      id: i || "",
+      endState: b.Fail,
+      tracker: i,
+      reason: "Failed to resolve trouble"
+    };
+    return T.initiateFuture(n), n;
+  }
+}, xr = async (e, t, r, i) => {
+  var o, n, a, O, D;
+  $.debug(
+    `performComplete - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/complete`
+  );
+  try {
+    const p = await Be({
+      model: {
+        ...i,
+        // commandedCalibrationVolume: 0,
+        measuredCalibrationVolume: t,
+        measuredVerificationVolume: r
+        // newCalibrationValue: 0,
+        // pouredCalibrationVolume: 0,
+      },
+      urlOverride: `${ye}/api/ext/freestyle/microCalibration/pour/${e}/complete`
+    });
+    return $.debug("performComplete - response:", p), ((p == null ? void 0 : p.status) === 200 || (p == null ? void 0 : p.status) === 499) && ((o = p.data) != null && o.error) ? [p.data.error || "unknownError", p.data] : [void 0, p == null ? void 0 : p.data];
+  } catch (p) {
+    if ($.error(
+      `performComplete - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/complete`,
+      p
+    ), p instanceof Ae) {
+      const ft = ((a = (n = p.payload) == null ? void 0 : n.data) == null ? void 0 : a.error) || ((O = p.payload) == null ? void 0 : O.error) || "unknownError";
+      return [ft, ((D = p.payload) == null ? void 0 : D.data) || { error: ft }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+}, ta = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  performCalibrate: Fr,
+  performComplete: xr,
+  performPreCalibrate: Rr,
+  performVerify: Ar
+}, Symbol.toStringTag, { value: "Module" }));
+var _s = Object.defineProperty, $s = Object.getOwnPropertyDescriptor, Ke = (e, t, r, i) => {
+  for (var o = i > 1 ? void 0 : i ? $s(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (o = (i ? a(t, r, o) : a(o)) || o);
+  return i && o && _s(t, r, o), o;
+};
+const jr = "spm-pump-model";
+let U = class {
+  constructor(e, t, r) {
+    s(this, "id");
+    s(this, "logger");
+    s(this, "pump");
+    s(this, "futureHandler");
+    this.id = e, this.logger = r.logger, this.pump = t.companionParent, this.futureHandler = new he(this);
+  }
+  get name() {
+    return this.pump.name;
+  }
+  get canPour() {
+    return this.pump.canPour;
+  }
+  get isPouring() {
+    return this.pump.isPouring;
+  }
+  async cancelPour() {
+    return this.pump.cancelPour();
+  }
+  performIntent(e) {
+    return this.pump.performIntent(e);
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  async performPreCalibrate(e) {
+    return Rr(this.pump.path, e);
+  }
+  async performCalibrate(e) {
+    return Fr(this.pump.path, e);
+  }
+  async performVerify(e, t, r) {
+    return Ar(this.pump.path, e, t, r);
+  }
+  async performComplete(e, t, r) {
+    return xr(this.pump.path, e, t, r);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing spm-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading spm-pump ${this.id}`);
+  }
+};
+Ke([
+  v()
+], U.prototype, "performPreCalibrate", 1);
+Ke([
+  v()
+], U.prototype, "performCalibrate", 1);
+Ke([
+  v()
+], U.prototype, "performVerify", 1);
+U = Ke([
+  l(jr)
+], U);
+const ra = new ke({
+  class: U,
+  type: jr
+});
+export {
+  ws as AgitationControl,
+  Lo as Animation,
+  Es as AnimationServices,
+  dt as Application,
+  ct as Auth,
+  Ss as AuthServices,
+  Ho as CarbWater,
+  ks as CopyLogs,
+  Ds as CopyLogsServices,
+  Xs as DDKModels,
+  pt as DashboardOperations,
+  Is as DashboardOperationsServices,
+  Zo as Dispenser,
+  ai as DispenserInfo,
+  Fs as DispenserInfoServices,
+  Rs as DispenserServices,
+  po as Door,
+  pe as EXTENSION_POINT_DASHBOARD_KEY_FACTORY,
+  gi as Enrollment,
+  As as EnrollmentServices,
+  Gt as FcmPump,
+  Ls as FcmPumpServices,
+  Pi as IngredientSummary,
+  Ns as LfcvPump,
+  zs as LfcvPumpServices,
+  Ks as Lockout,
+  Bs as LockoutServices,
+  Vs as MACRO_KEYS,
+  ji as MacroAssignment,
+  hr as NetworkTest,
+  Bi as NetworkTestContainer,
+  Ys as NetworkTestServices,
+  qi as NutritiveSweetener,
+  Xi as PlainWater,
+  rs as Reboot,
+  qs as RebootServices,
+  ss as Settings,
+  Gs as SettingsServices,
+  xt as SetupStep,
+  jt as SetupStepContainer,
+  Cs as SetupStepServices,
+  ra as SpmPump,
+  ta as SpmPumpServices,
+  ea as Start,
+  Zs as StartServices,
+  oo as TROUBLE_TYPE_PRIME,
+  bt as TROUBLE_TYPE_PURGE,
+  Js as TroubleActionManager,
+  Mr as Utilities,
+  gs as UtilitiesContainer,
+  Qs as UtilitiesServices,
+  _i as calculateTimeDifference,
+  vi as executeDashboardKeyFactory,
+  js as isMacroGroup,
+  xs as isMicroGroup,
+  Us as macroHolderMap,
+  bi as registerDashboardKeyFactory,
+  Ws as toSeconds,
+  Hs as toTimeComponents,
+  Ht as troubleVisibilityFilter
+};