@kosdev-code/kos-ddk-models 2.0.0

package/index.mjs

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