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

package/index.mjs

@@ -0,0 +1,3102 @@
+import { resolveServiceUrl, ServiceFactory, KosLog, kosTopicHandler, kosModel, kosAction, Kos, isKosModel, createPropKey, kosStateProp, kosConfigProperty, KosModelRegistrationFactory, kosDependency, KosModelContainer, resolveContainerDeltas, kosChild, Device, kosFuture, kosModelEffect, MultipleFutureHandler, FutureEndState, TroubleServices, Troubles, SingletonKosModelRegistrationFactory, getKosCompanionModel, FetchError, StorageDeviceContainer, kosFutureAware, kosLoggerAware, KosDataContainer, TroubleContainer, FutureHandler, troubleByTypeReducer, registerExtensionPoint, ExtensionManager, kosConfigBean, kosStateBean, ObservableData } from "@kosdev-code/kos-ui-sdk";
+import { AGITATION_REQUIRED_TROUBLE, CartridgeAgitatorEvents, FcmPump, FreestyleHolder } from "@kosdev-code/kos-freestyle-sdk";
+import { Assembly, HolderContainer, IngredientContainer } from "@kosdev-code/kos-dispense-sdk";
+const TROUBLE_TYPE_PURGE$1 = "PurgeTrouble";
+const TROUBLE_TYPE_PRIME$1 = "PrimeTrouble";
+const { URL: URL$d } = resolveServiceUrl("AUTH_SERVICE");
+const { getOne: getOne$4, postModel: postModel$4 } = ServiceFactory.build({
+  basePath: `${URL$d}/api/auth`
+});
+const log$e = KosLog.createLogger({ name: "auth-service", group: "Services" });
+const getCurrentRole = async () => {
+  log$e.debug("sending GET for auth");
+  const response = await getOne$4({
+    urlOverride: `${URL$d}/api/app/kosdev.ddk/auth/role`
+  });
+  return response;
+};
+const sendPinCode = async (pinCode) => {
+  log$e.debug("sending POST for auth");
+  const response = await postModel$4({
+    urlOverride: `${URL$d}/api/app/kosdev.ddk/auth/pincode/${pinCode}`,
+    model: {}
+  });
+  return response;
+};
+const index$d = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getCurrentRole,
+  sendPinCode
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$j = Object.defineProperty;
+var __getOwnPropDesc$p = Object.getOwnPropertyDescriptor;
+var __decorateClass$p = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$p(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$j(target, key, result);
+  return result;
+};
+const MODEL_TYPE$p = "auth-model";
+const convertAuthResponse = (response) => response.toLowerCase();
+let AuthModelImpl = class {
+  id;
+  logger;
+  currentRole;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.currentRole = "crew";
+  }
+  async authorize(pinCode) {
+    if (!pinCode) {
+      return false;
+    }
+    const response = await sendPinCode(pinCode);
+    if (response?.status === 200) {
+      return response.data;
+    } else {
+      return false;
+    }
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing auth ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading auth ${this.id}`);
+    const response = await getCurrentRole();
+    if (response?.status === 200) {
+      this.logger.debug(`response ${response.data}`);
+      kosAction(() => {
+        this.currentRole = convertAuthResponse(response.data);
+      });
+    }
+  }
+  handleRoleChange(role) {
+    this.currentRole = convertAuthResponse(role);
+  }
+  forceRole(role) {
+    this.currentRole = role;
+  }
+};
+__decorateClass$p([
+  kosTopicHandler({
+    topic: "/app/kosdev.ddk/auth/role",
+    websocket: true
+  })
+], AuthModelImpl.prototype, "handleRoleChange", 1);
+AuthModelImpl = __decorateClass$p([
+  kosModel(MODEL_TYPE$p)
+], AuthModelImpl);
+const Auth = {
+  registration: {
+    [MODEL_TYPE$p]: {
+      class: AuthModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$p,
+  predicate: isKosModel(MODEL_TYPE$p),
+  factory: Kos.Factory.create(MODEL_TYPE$p)
+};
+var __defProp$i = Object.defineProperty;
+var __getOwnPropDesc$o = Object.getOwnPropertyDescriptor;
+var __decorateClass$o = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$o(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$i(target, key, result);
+  return result;
+};
+const MODEL_TYPE$o = "door-model";
+const PROP_PATH = createPropKey("doorPath");
+let DoorModelImpl = class {
+  id;
+  logger;
+  doorPath;
+  open;
+  ignoreDoor;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.doorPath = options.doorPath;
+  }
+  get currentState() {
+    if (this.open.value === void 0) {
+      return "UNKNOWN";
+    }
+    return this.open.value ? "OPEN" : "CLOSED";
+  }
+  get isOpen() {
+    const value = this.open.value === void 0 ? true : this.open.value;
+    const ignore = this.ignoreDoor.value;
+    if (ignore) {
+      this.logger.debug(
+        `Door state is being ignored (treating as closed) due to ignoreDoor config property being true.`
+      );
+      return false;
+    }
+    return value;
+  }
+};
+__decorateClass$o([
+  kosStateProp({ path: PROP_PATH, attribute: "state" })
+], DoorModelImpl.prototype, "open", 2);
+__decorateClass$o([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.ignoreDoorStateOnExit"
+  })
+], DoorModelImpl.prototype, "ignoreDoor", 2);
+DoorModelImpl = __decorateClass$o([
+  kosModel(MODEL_TYPE$o)
+], DoorModelImpl);
+const Door = new KosModelRegistrationFactory({
+  class: DoorModelImpl,
+  type: MODEL_TYPE$o
+});
+const { URL: URL$c } = resolveServiceUrl("SETUP-STEP_SERVICE");
+const { getAll: getAll$9, postModel: postModel$3 } = ServiceFactory.build({
+  basePath: `${URL$c}/api/setup-step`
+});
+const log$d = KosLog.createLogger({
+  name: "setup-step-service",
+  group: "Services"
+});
+const getSetupSteps = async () => {
+  log$d.debug("sending GET for setup-step");
+  const response = await getAll$9({
+    urlOverride: `${URL$c}/api/app/kosdev.ddk/setup/steps`
+  });
+  return response;
+};
+const markStepComplete = async (stepId) => {
+  log$d.debug("sending POST for setup-step");
+  const response = await postModel$3({
+    urlOverride: `${URL$c}/api/app/kosdev.ddk/setup/complete/${stepId}`,
+    model: {}
+  });
+  return response;
+};
+const index$c = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getSetupSteps,
+  markStepComplete
+}, Symbol.toStringTag, { value: "Module" }));
+var __getOwnPropDesc$n = Object.getOwnPropertyDescriptor;
+var __decorateClass$n = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$n(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$n = "setup-step-model";
+let SetupStepModelImpl = class {
+  id;
+  idx;
+  name;
+  complete;
+  preStep;
+  exclusive;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.idx = options.idx;
+    this.logger = context.logger;
+    this.name = options.name;
+    this.complete = options.complete;
+    this.preStep = options.preStep;
+    this.exclusive = options.exclusive;
+  }
+  updateModel(options) {
+    this.name = options.name;
+    this.idx = options.idx;
+    this.complete = options.complete;
+    this.preStep = options.preStep;
+    this.exclusive = options.exclusive;
+  }
+  get titleKey() {
+    return `setup.${this.name}.title`;
+  }
+  get bodyKey() {
+    return `setup.${this.name}.body`;
+  }
+  async completeStep() {
+    const response = await markStepComplete(this.name);
+    if (response?.status === 200) {
+      kosAction(() => {
+        this.complete = true;
+      });
+    }
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing setup-step ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading setup-step ${this.id}`);
+  }
+};
+SetupStepModelImpl = __decorateClass$n([
+  kosModel(MODEL_TYPE$n)
+], SetupStepModelImpl);
+const SetupStep = {
+  registration: {
+    [MODEL_TYPE$n]: {
+      class: SetupStepModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$n,
+  predicate: isKosModel(MODEL_TYPE$n),
+  factory: Kos.Factory.create(MODEL_TYPE$n)
+};
+var __defProp$h = Object.defineProperty;
+var __getOwnPropDesc$m = Object.getOwnPropertyDescriptor;
+var __decorateClass$m = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$m(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$h(target, key, result);
+  return result;
+};
+const MODEL_TYPE$m = "setup-step-container-model";
+function addStep(container) {
+  return (step) => {
+    const model = SetupStep.factory(step.id)(step);
+    model.updateModel(step);
+    container.addModel(model);
+  };
+}
+function removeStep(container) {
+  return (id) => {
+    container.removeModel(id);
+  };
+}
+let SetupStepContainerModelImpl = class {
+  id;
+  _currentStep;
+  logger;
+  models;
+  authModel;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this._currentStep = void 0;
+    this.models = new KosModelContainer({
+      parentId: modelId,
+      sortKey: "idx"
+    });
+  }
+  get currentStep() {
+    return this._currentStep;
+  }
+  setCurrentStep(id) {
+    const step = this.models.getModel(id);
+    if (step) {
+      this._currentStep = step;
+    }
+  }
+  nextStep() {
+    if (!this._currentStep) {
+      this._currentStep = this.firstIncompleteStep;
+    } else {
+      const currentIdx = this._currentStep.idx;
+      const nextStep = this.models.data.find((step) => step.idx > currentIdx);
+      if (nextStep) {
+        this._currentStep = nextStep;
+      }
+    }
+  }
+  get hasIncompletePreSteps() {
+    return this.models.data.some((step) => step.preStep && !step.complete);
+  }
+  get setupRequired() {
+    return this.models.data.some((step) => !step.complete);
+  }
+  get firstIncompleteStep() {
+    return this.models.data.find((step) => !step.complete);
+  }
+  get isLastStep() {
+    return this.models.data[this.models.data.length - 1].id === this._currentStep?.id;
+  }
+  get data() {
+    return this.models.data;
+  }
+  getModel(id) {
+    return this.models.getModel(id);
+  }
+  addModel(model) {
+    this.models.addModel(model);
+  }
+  removeModel(id) {
+    this.models.removeModel(id);
+  }
+  // -------------------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 response = await getSetupSteps();
+    if (response?.data) {
+      const identifiableSteps = response.data.map(
+        (step, index2) => {
+          return {
+            ...step,
+            idx: index2,
+            id: `setup-${step.name}`
+          };
+        }
+      );
+      resolveContainerDeltas({
+        container: this.models,
+        onAddItem: addStep(this),
+        onRemoveItem: removeStep(this)
+      })(identifiableSteps);
+    }
+    this.nextStep();
+  }
+  handleStepChanges(steps) {
+    const identifiableSteps = steps.map((step, index2) => {
+      return {
+        ...step,
+        idx: index2,
+        id: `setup-${step.name}`
+      };
+    });
+    resolveContainerDeltas({
+      container: this.models,
+      onAddItem: addStep(this),
+      onRemoveItem: removeStep(this)
+    })(identifiableSteps);
+  }
+};
+__decorateClass$m([
+  kosChild
+], SetupStepContainerModelImpl.prototype, "models", 2);
+__decorateClass$m([
+  kosDependency({ modelType: Auth.type })
+], SetupStepContainerModelImpl.prototype, "authModel", 2);
+__decorateClass$m([
+  kosTopicHandler({
+    topic: "/app/kosdev.ddk/setup/steps",
+    websocket: true
+  })
+], SetupStepContainerModelImpl.prototype, "handleStepChanges", 1);
+SetupStepContainerModelImpl = __decorateClass$m([
+  kosModel(MODEL_TYPE$m)
+], SetupStepContainerModelImpl);
+const SetupStepContainer = {
+  registration: {
+    [MODEL_TYPE$m]: {
+      class: SetupStepContainerModelImpl,
+      singleton: true
+    },
+    ...SetupStep.registration
+  },
+  type: MODEL_TYPE$m,
+  predicate: isKosModel(MODEL_TYPE$m),
+  factory: Kos.Singleton.create(MODEL_TYPE$m)
+};
+const { URL: URL$b } = resolveServiceUrl("AUTH_SERVICE");
+const { getOne: getOne$3, getAll: getAll$8 } = ServiceFactory.build({
+  basePath: `${URL$b}/api/app/kosdev.ddk/ncui/`
+});
+const log$c = KosLog.createLogger({ name: "auth-service", group: "Services" });
+const getCuis = async () => {
+  log$c.debug("sending GET for cuis");
+  const response = await getAll$8({
+    urlOverride: `${URL$b}/api/app/kosdev.ddk/cui`
+  });
+  if (response?.status !== 200) {
+    throw new Error("Failed to retrieve cuis");
+  }
+  return response.data;
+};
+const getNavigation = async () => {
+  log$c.debug("sending GET for navigation");
+  try {
+    const extensionResponse = await getAll$8({
+      urlOverride: `${URL$b}/api/kos/descriptor/app:kosdev.ddk:ncuiDescriptor/kondra.ncui.navigations`
+    });
+    if (extensionResponse?.status !== 200) {
+      log$c.info(`no extensions found, using base data`);
+      const response = await getAll$8({
+        urlOverride: `${URL$b}/api/kos/descriptor/system:app/kondra.ncui.navigations`
+      });
+      return response?.data ?? [];
+    }
+    return extensionResponse?.data ?? [];
+  } catch (error) {
+    const response = await getAll$8({
+      urlOverride: `${URL$b}/api/kos/descriptor/system:app/kondra.ncui.navigations`
+    });
+    return response?.data ?? [];
+  }
+};
+const navigateToCui = async () => {
+  log$c.debug("navigating to CUI");
+  const response = await getOne$3({
+    urlOverride: `${URL$b}/api/app/kosdev.ddk/cui/open`
+  });
+  return response;
+};
+const navigateToNCui$1 = async () => {
+  log$c.debug("navigating to NCUI");
+  const response = await getOne$3({
+    urlOverride: `${URL$b}/api/app/kosdev.ddk/ncui/open`
+  });
+  return response;
+};
+var __defProp$g = Object.defineProperty;
+var __getOwnPropDesc$l = Object.getOwnPropertyDescriptor;
+var __decorateClass$l = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$l(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$g(target, key, result);
+  return result;
+};
+const MODEL_TYPE$l = "application-model";
+const flattenNavigationItems = (items, path = "") => items.reduce((acc, item) => {
+  const itemPath = path ? `${path}.${item.name}` : item.name;
+  acc[itemPath] = { ...item, root: !path };
+  if (item.children) {
+    const childItems = flattenNavigationItems(item.children, itemPath);
+    Object.keys(childItems).forEach((key) => {
+      acc[key] = childItems[key];
+    });
+  }
+  return acc;
+}, {});
+let ApplicationModelImpl = class {
+  id;
+  device;
+  authModel;
+  setupStepContainer;
+  door;
+  ncuiLanguage;
+  activeCui;
+  fallbackCui;
+  _cuis = [];
+  _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>;
+  languages;
+  logger;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.languages = [];
+    this._cuis = [];
+    this.logger = context.logger;
+    this.door = Door.instance("app:kosdev.ddk:service:door:door").options({
+      doorPath: "app:kosdev.ddk:service:door:door"
+    }).build();
+  }
+  get setupRequired() {
+    return this.authModel.currentRole === "crew" ? false : this.setupStepContainer.setupRequired;
+  }
+  get currentRole() {
+    return this.authModel.currentRole;
+  }
+  get cuis() {
+    return this._cuis.reduce((acc, cui) => {
+      acc[cui.appId] = cui;
+      return acc;
+    }, {});
+  }
+  get navigationItems() {
+    return flattenNavigationItems(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 navigateToNCui$1();
+  }
+  async exit() {
+    this.logger.info("navigating to CUI");
+    await navigateToCui();
+  }
+  // -------------------LIFECYCLE----------------------------
+  async load() {
+    this.logger.debug(`loading application ${this.id}`);
+    const navigationItems = await getNavigation();
+    this._navigationItems = navigationItems;
+    const cuis = await getCuis();
+    this._cuis = cuis;
+    if (this.setupStepContainer?.hasIncompletePreSteps) {
+      this.authModel?.forceRole("technician");
+    }
+    this.languages = [
+      {
+        name: "English",
+        locale: "en"
+      }
+    ];
+  }
+};
+__decorateClass$l([
+  kosDependency({ modelType: Device.type })
+], ApplicationModelImpl.prototype, "device", 2);
+__decorateClass$l([
+  kosDependency({ modelType: Auth.type })
+], ApplicationModelImpl.prototype, "authModel", 2);
+__decorateClass$l([
+  kosDependency({ modelType: SetupStepContainer.type })
+], ApplicationModelImpl.prototype, "setupStepContainer", 2);
+__decorateClass$l([
+  kosChild
+], ApplicationModelImpl.prototype, "door", 2);
+__decorateClass$l([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.ncuiLanguage"
+    //updated attribute for language config property
+  })
+], ApplicationModelImpl.prototype, "ncuiLanguage", 2);
+__decorateClass$l([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:service:cui",
+    attribute: "activeCui"
+  })
+], ApplicationModelImpl.prototype, "activeCui", 2);
+__decorateClass$l([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:service:cui",
+    attribute: "fallbackCui"
+  })
+], ApplicationModelImpl.prototype, "fallbackCui", 2);
+ApplicationModelImpl = __decorateClass$l([
+  kosModel(MODEL_TYPE$l)
+], ApplicationModelImpl);
+const Application = {
+  registration: {
+    [MODEL_TYPE$l]: {
+      class: ApplicationModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$l,
+  predicate: isKosModel(MODEL_TYPE$l),
+  factory: Kos.Singleton.create(
+    MODEL_TYPE$l
+  )
+};
+const RoleMap = {
+  none: 999,
+  crew: 0,
+  technician: 1,
+  manager: 2
+};
+const troubleVisibilityFilter = (currentRole) => (trouble) => {
+  if (trouble.type === AGITATION_REQUIRED_TROUBLE) {
+    return false;
+  }
+  const visibleRole = trouble?.role || "technician";
+  if (currentRole && visibleRole) {
+    const currentRoleIndex = RoleMap[currentRole.toLowerCase()] ?? RoleMap["crew"];
+    const visibleRoleIndex = RoleMap[visibleRole.toLowerCase()] ?? RoleMap["crew"];
+    return currentRoleIndex >= visibleRoleIndex;
+  }
+  return false;
+};
+var __defProp$f = Object.defineProperty;
+var __getOwnPropDesc$k = Object.getOwnPropertyDescriptor;
+var __decorateClass$k = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$k(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$f(target, key, result);
+  return result;
+};
+const MODEL_TYPE$k = "agitation-control-model";
+const FUTURE_RESOLVE = "resolve";
+const FUTURE_AGITATE = "agitate";
+let AgitationControlModelImpl = class {
+  id;
+  futureHandler;
+  logger;
+  troubleContainer;
+  _agitationFutureId;
+  _canExit = true;
+  _exiting = false;
+  _isFailed = false;
+  disposer;
+  application;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.troubleContainer = options.companionParent;
+    this.futureHandler = new MultipleFutureHandler(this, FUTURE_RESOLVE);
+  }
+  set isFailed(value) {
+    this._isFailed = value;
+  }
+  get isFailed() {
+    return this._isFailed;
+  }
+  get isDoorClosed() {
+    return !this.application.doorIsOpen;
+  }
+  get isAgitating() {
+    return !!this._agitationFutureId;
+  }
+  set exiting(value) {
+    this._exiting = value;
+  }
+  get exiting() {
+    return this._exiting;
+  }
+  get canExit() {
+    const allDeferredCount = this.queuedTroubles.length;
+    return allDeferredCount === 0 && this._canExit;
+  }
+  clearAll() {
+    this.queuedTroubles.forEach((trouble) => {
+      trouble.clearDefer();
+    });
+  }
+  get readyToResolve() {
+    const allDeferredCount = this.queuedTroubles.length;
+    const notResolvable = this.queuedTroubles.filter((t) => t.shouldDefer);
+    const _readyToResolve = allDeferredCount > 0 && notResolvable.length === 0;
+    return this.isDoorClosed && _readyToResolve && this.exiting;
+  }
+  onFutureUpdate(future) {
+    if (future.endState === FutureEndState.Success) {
+      this.logger.debug(
+        `Resolve deferred troubles future ${future.id} completed successfully`
+      );
+      this.queuedTroubles.forEach((trouble) => {
+        trouble.clearDefer();
+      });
+      kosAction(() => {
+        this._canExit = true;
+        this._isFailed = false;
+      });
+    } else if (future.endState === FutureEndState.Fail || future.endState === FutureEndState.Canceled || future.endState === FutureEndState.Aborted) {
+      this.logger.error(`Resolve deferred troubles future ${future.id} failed`);
+      this.clearAll();
+      kosAction(() => {
+        this._canExit = false;
+        this._isFailed = true;
+      });
+    }
+  }
+  inProgress = [];
+  async resolveDeferredTroubles(tracker) {
+    const toResolve = this.queuedTroubles.filter((t) => !t.shouldDefer).map((trouble) => trouble.rawId).filter((id) => !this.inProgress.includes(id));
+    this.inProgress.push(...toResolve);
+    if (toResolve.length === 0) {
+      return void 0;
+    }
+    const response = await TroubleServices.bulkResolveTroubles(
+      toResolve,
+      void 0,
+      tracker
+    );
+    return response;
+  }
+  get hasQueuedTroubles() {
+    return this.queuedTroubles.length > 0;
+  }
+  get queuedTroubles() {
+    return this.troubleContainer.troubles.getIndexByKey(
+      Troubles.INDEX_TROUBLES_BY_DEFERRED,
+      Troubles.TROUBLES_DEFERRED
+    );
+  }
+  get visibleTroubles() {
+    const currentRole = this.application.currentRole;
+    return this.troubleContainer.troubles.data.filter(troubleVisibilityFilter(currentRole)).filter((trouble) => trouble.type !== AGITATION_REQUIRED_TROUBLE);
+  }
+  // -------------------LIFECYCLE----------------------------
+  get future() {
+    return this.futureHandler.future;
+  }
+  get resolveFuture() {
+    return this.futureHandler.getFuture(FUTURE_RESOLVE);
+  }
+  get agitateFuture() {
+    return this.futureHandler.getFuture(FUTURE_AGITATE);
+  }
+  handleAgitationStarted(event) {
+    this.logger.info(`Agitation started for ${event.path}`);
+    this._agitationFutureId = String(event.futureId);
+  }
+  handleAgitationEnded(event) {
+    this.logger.info(`Agitation ended for ${event.path}`);
+    this._agitationFutureId = void 0;
+  }
+  async init() {
+    this.logger.debug(`initializing agitation-control ${this.id}`);
+  }
+  unload() {
+    this.logger.debug(`unloading agitation-control ${this.id}`);
+    if (this.disposer) {
+      this.disposer();
+    }
+  }
+  handleReadyToResolve() {
+    if (this.readyToResolve) {
+      this.logger.info(`AgitationControl - Resolving deferred troubles`);
+      this.resolveDeferredTroubles();
+    }
+    if (this._agitationFutureId) {
+      this.logger.info(`AgitationControl - Agitation started`);
+    }
+  }
+  async load() {
+    this.logger.debug(`loading agitation-control ${this.id}`);
+  }
+};
+__decorateClass$k([
+  kosDependency({ modelType: Application.type })
+], AgitationControlModelImpl.prototype, "application", 2);
+__decorateClass$k([
+  kosFuture({ alias: FUTURE_RESOLVE })
+], AgitationControlModelImpl.prototype, "resolveDeferredTroubles", 1);
+__decorateClass$k([
+  kosTopicHandler({ topic: CartridgeAgitatorEvents.TOPIC_AGITATION_STARTED })
+], AgitationControlModelImpl.prototype, "handleAgitationStarted", 1);
+__decorateClass$k([
+  kosTopicHandler({ topic: CartridgeAgitatorEvents.TOPIC_AGITATION_ENDED })
+], AgitationControlModelImpl.prototype, "handleAgitationEnded", 1);
+__decorateClass$k([
+  kosModelEffect({
+    dependencies: (model) => [model.readyToResolve, model._agitationFutureId]
+  })
+], AgitationControlModelImpl.prototype, "handleReadyToResolve", 1);
+AgitationControlModelImpl = __decorateClass$k([
+  kosModel(MODEL_TYPE$k)
+], AgitationControlModelImpl);
+const AgitationControl = new SingletonKosModelRegistrationFactory({
+  class: AgitationControlModelImpl,
+  type: MODEL_TYPE$k
+});
+var __defProp$e = Object.defineProperty;
+var __getOwnPropDesc$j = Object.getOwnPropertyDescriptor;
+var __decorateClass$j = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$j(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$e(target, key, result);
+  return result;
+};
+const MODEL_TYPE$j = "animation-model";
+let AnimationModelImpl = class {
+  id;
+  logger;
+  disableAll;
+  enableDial;
+  enableModal;
+  enableSideBar;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+  }
+};
+__decorateClass$j([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.disableAll"
+  })
+], AnimationModelImpl.prototype, "disableAll", 2);
+__decorateClass$j([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.enableDial"
+  })
+], AnimationModelImpl.prototype, "enableDial", 2);
+__decorateClass$j([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.enableModal"
+  })
+], AnimationModelImpl.prototype, "enableModal", 2);
+__decorateClass$j([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.animations.enableSideBar"
+  })
+], AnimationModelImpl.prototype, "enableSideBar", 2);
+AnimationModelImpl = __decorateClass$j([
+  kosModel(MODEL_TYPE$j)
+], AnimationModelImpl);
+const Animation = {
+  registration: {
+    [MODEL_TYPE$j]: {
+      class: AnimationModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$j,
+  predicate: isKosModel(MODEL_TYPE$j),
+  factory: Kos.Singleton.create(MODEL_TYPE$j)
+};
+const { URL: URL$a } = resolveServiceUrl("ANIMATION_SERVICE");
+const { getAll: getAll$7 } = ServiceFactory.build({
+  basePath: `${URL$a}/api/animation`
+});
+const log$b = KosLog.createLogger({
+  name: "animation-service",
+  group: "Services"
+});
+const getAnimations = async () => {
+  log$b.debug("sending GET for animation");
+  const response = await getAll$7({});
+  return response;
+};
+const index$b = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getAnimations
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$d = Object.defineProperty;
+var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
+var __decorateClass$i = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$i(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$d(target, key, result);
+  return result;
+};
+const MODEL_TYPE$i = "carb-water-model";
+let CarbWaterModelImpl = class {
+  id;
+  assemblyModel;
+  logger;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+  }
+  getPump() {
+    const carbHolder = this.assemblyModel.getHoldersByGroup("carb")[0];
+    const pump = carbHolder.pumps.data[0];
+    const model = getKosCompanionModel(pump, FcmPump.type);
+    return model;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing carb-water ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading carb-water ${this.id}`);
+  }
+};
+__decorateClass$i([
+  kosDependency({ modelType: Assembly.type })
+], CarbWaterModelImpl.prototype, "assemblyModel", 2);
+CarbWaterModelImpl = __decorateClass$i([
+  kosModel(MODEL_TYPE$i)
+], CarbWaterModelImpl);
+const CarbWater = {
+  registration: {
+    [MODEL_TYPE$i]: {
+      class: CarbWaterModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$i,
+  predicate: isKosModel(MODEL_TYPE$i),
+  factory: Kos.Factory.create(MODEL_TYPE$i)
+};
+const { URL: URL$9 } = resolveServiceUrl("COPY-LOGS_SERVICE");
+const { getAll: getAll$6, getOne: getOne$2, postModel: postModel$2, deleteModel } = ServiceFactory.build({
+  basePath: `${URL$9}/api/copy-logs`
+});
+const log$a = KosLog.createLogger({
+  name: "copy-logs-service",
+  group: "Services"
+});
+const eraseVolume = async (volumeId, tracker) => {
+  const response = await deleteModel({
+    tracker,
+    id: volumeId,
+    urlOverride: `${URL$9}/api/app/kosdev.ddk/copyLogs/${volumeId}`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response.data;
+};
+const eraseAndCopyLogsToVolume = async (volumeId, tracker) => {
+  const response = await postModel$2({
+    model: {},
+    tracker,
+    urlOverride: `${URL$9}/api/app/kosdev.ddk/copyLogs/eraseAndCopy/${volumeId}`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response.data;
+};
+const copyLogFromVolume = async (volumeId, tracker) => {
+  const response = await postModel$2({
+    model: {},
+    tracker,
+    urlOverride: `${URL$9}/api/app/kosdev.ddk/copyLogs/${volumeId}`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response.data;
+};
+const getVolumes = async () => {
+  log$a.debug("sending GET for copy-logs");
+  try {
+    const response = await getAll$6({
+      urlOverride: `${URL$9}/api/app/kosdev.ddk/copyLogs/volumes/size`
+    });
+    return [void 0, response?.data];
+  } catch (error) {
+    if (error instanceof FetchError) {
+      log$a.error(`Error fetching log file size: ${error.payload.error}`);
+      return [error.payload.error, void 0];
+    }
+  }
+  return ["unknownError", void 0];
+};
+const getLogFileSize = async () => {
+  log$a.debug("sending GET for log file size");
+  try {
+    const response = await getOne$2({
+      urlOverride: `${URL$9}/api/app/kosdev.ddk/copyLogs/files/size`
+    });
+    return [void 0, response?.data];
+  } catch (error) {
+    if (error instanceof FetchError) {
+      log$a.error(`Error fetching log file size: ${error.payload.error}`);
+      return [error.payload.error, void 0];
+    }
+  }
+  return ["unknownError", void 0];
+};
+const index$a = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  copyLogFromVolume,
+  eraseAndCopyLogsToVolume,
+  eraseVolume,
+  getLogFileSize,
+  getVolumes
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$c = Object.defineProperty;
+var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$h = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$c(target, key, result);
+  return result;
+};
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "", value);
+const MODEL_TYPE$h = "copy-logs-model";
+let CopyLogsModelImpl = class {
+  id;
+  _volumes;
+  storageDeviceContainer;
+  _activeVolume;
+  _logFileSize = 0;
+  _actionState = "idle";
+  copyProgress;
+  constructor(modelId) {
+    this.id = modelId;
+    this._volumes = new KosDataContainer();
+    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(volume) {
+    this._activeVolume = volume;
+  }
+  get inserted() {
+    return this.storageDeviceContainer.isStorageInserted;
+  }
+  updateLogFileSize(size) {
+    this._logFileSize = size;
+  }
+  get canCopyLogs() {
+    return this.inserted && this._activeVolume;
+  }
+  get actionState() {
+    return this._actionState;
+  }
+  get diskFull() {
+    return this.future?.status === FutureEndState.Success && this.copyProgress.filesSkipped > 0;
+  }
+  onFutureUpdate(update) {
+    this.logger.info(`Future update: ${update.status}`);
+    if (update.status === FutureEndState.Success) {
+      this.logger.info(`Future success: ${update.status}`);
+      if (this.diskFull) {
+        kosAction(() => {
+          update.endState = FutureEndState.Fail;
+          update.reason = "errDiskFull";
+        });
+      }
+    }
+    if (update.status === FutureEndState.Fail) {
+      this.logger.error(`Future failed: ${update.status}`);
+    }
+    if (update.note === "copy") {
+      kosAction(() => {
+        this._actionState = "copying";
+        this.copyProgress = update.clientData || {
+          bytesCopied: 0,
+          bytesToCopy: 0,
+          filesCopied: 0,
+          filesSkipped: 0
+        };
+      });
+    } else {
+      this._actionState = "erasing";
+      kosAction(() => {
+        this.copyProgress = {
+          bytesCopied: 0,
+          bytesToCopy: 0,
+          filesCopied: 0,
+          filesSkipped: 0
+        };
+      });
+    }
+  }
+  async eraseAndCopyVolume(tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    kosAction(() => {
+      this._actionState = "erasing";
+    });
+    if (!this._activeVolume) {
+      this.logger.error("No active volume selected");
+      throw new Error("No active volume selected");
+    }
+    this.logger.info(`Erasing volume ${this._activeVolume?.name}`);
+    return eraseAndCopyLogsToVolume(this._activeVolume.id, tracker);
+  }
+  async eraseVolume(tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    kosAction(() => {
+      this._actionState = "erasing";
+    });
+    if (!this._activeVolume) {
+      this.logger.error("No active volume selected");
+      throw new Error("No active volume selected");
+    }
+    this.logger.info(`Erasing volume ${this._activeVolume?.name}`);
+    return eraseVolume(this._activeVolume.id, tracker);
+  }
+  async copyLogs(tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    kosAction(() => {
+      this._actionState = "copying";
+    });
+    if (!this._activeVolume) {
+      this.logger.error("No active volume selected");
+      throw new Error("No active volume selected");
+    }
+    this.logger.info(`Copying logs to ${this._activeVolume?.name}`);
+    return copyLogFromVolume(this._activeVolume.id, tracker);
+  }
+  handleInsertion() {
+    if (this.inserted) {
+      this.syncVolumes();
+    } else {
+      this._volumes.clear();
+      this.clearActiveVolume();
+    }
+  }
+  async init() {
+    this.logger.debug(`initializing copy-logs ${this.id}`);
+  }
+  async syncVolumes() {
+    const [volumeError, volumes] = await getVolumes();
+    const [error, logSize] = await getLogFileSize();
+    if (error) {
+      this.logger.error(`Error fetching log file size: ${error}`);
+      return;
+    }
+    if (volumeError) {
+      this.logger.error(`Error fetching volumes: ${volumeError}`);
+      return;
+    }
+    if (volumes) {
+      volumes.forEach((volume) => {
+        const storageVolume = this.storageDeviceContainer.getModel(volume.id);
+        if (storageVolume) {
+          const _volume = {
+            id: volume.id,
+            name: storageVolume.label,
+            freeBytes: volume.info.freeBytes,
+            totalBytes: volume.info.totalBytes
+          };
+          this._volumes.addModel(_volume);
+        }
+      });
+      if (volumes.length === 1) {
+        this.updateActiveVolume(this._volumes.data[0]);
+      } else {
+        this.clearActiveVolume();
+      }
+    }
+    if (logSize) {
+      this.logger.info(`Log file size: ${logSize}`);
+      this.updateLogFileSize(parseInt(logSize, 10));
+    }
+  }
+  async activate() {
+    this.logger.debug(`activating copy-logs ${this.id}`);
+    await this.syncVolumes();
+  }
+  async load() {
+    this.logger.debug(`loading copy-logs ${this.id}`);
+  }
+};
+__publicField$1(CopyLogsModelImpl, "Registration");
+__decorateClass$h([
+  kosDependency({ modelType: StorageDeviceContainer.type })
+], CopyLogsModelImpl.prototype, "storageDeviceContainer", 2);
+__decorateClass$h([
+  kosFuture()
+], CopyLogsModelImpl.prototype, "eraseAndCopyVolume", 1);
+__decorateClass$h([
+  kosFuture()
+], CopyLogsModelImpl.prototype, "eraseVolume", 1);
+__decorateClass$h([
+  kosFuture()
+], CopyLogsModelImpl.prototype, "copyLogs", 1);
+__decorateClass$h([
+  kosModelEffect({
+    dependencies: (model) => [model.inserted]
+  })
+], CopyLogsModelImpl.prototype, "handleInsertion", 1);
+CopyLogsModelImpl = __decorateClass$h([
+  kosModel({ modelTypeId: MODEL_TYPE$h, singleton: true }),
+  kosFutureAware(),
+  kosLoggerAware()
+], CopyLogsModelImpl);
+const CopyLogs = CopyLogsModelImpl.Registration;
+const log$9 = KosLog.createLogger({
+  name: "dashboard-operations-service",
+  group: "Services"
+});
+const resolveAll = async (troubleIds, tracker) => {
+  log$9.debug("resolveAll");
+  const response = await TroubleServices.bulkResolveTroubles(
+    troubleIds,
+    void 0,
+    tracker
+  );
+  return response;
+};
+const resolveTrouble = async (troubleId, tracker) => {
+  log$9.debug("resolveTrouble");
+  const response = await TroubleServices.resolveTrouble(
+    troubleId,
+    void 0,
+    tracker
+  );
+  return response;
+};
+const index$9 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  resolveAll,
+  resolveTrouble
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$b = Object.defineProperty;
+var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
+var __decorateClass$g = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$b(target, key, result);
+  return result;
+};
+const MODEL_TYPE$g = "dashboard-operations-model";
+function resolvableTroubleFilter(trouble) {
+  return !trouble.deferred;
+}
+function deferredTroubleFilter(trouble) {
+  return trouble.deferred;
+}
+let DashboardOperationsModelImpl = class {
+  id;
+  troubles;
+  futureHandler;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.futureHandler = new FutureHandler(this);
+    this.logger = context.logger;
+  }
+  get troublesByType() {
+    return this.troubles.troubles.data.reduce(
+      troubleByTypeReducer,
+      {}
+    );
+  }
+  get queuedPurgeTroubles() {
+    return this.purgeTroubles.filter(deferredTroubleFilter);
+  }
+  get queuedPrimeTroubles() {
+    return this.primeTroubles.filter(deferredTroubleFilter);
+  }
+  get resolvablePrimeTroubles() {
+    return this.primeTroubles.filter(resolvableTroubleFilter);
+  }
+  get resolvablePurgeTroubles() {
+    return this.purgeTroubles.filter(resolvableTroubleFilter);
+  }
+  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[TROUBLE_TYPE_PURGE$1] || [];
+  }
+  get primeTroubles() {
+    return this.troublesByType[TROUBLE_TYPE_PRIME$1] || [];
+  }
+  get future() {
+    return this.futureHandler.getFuture();
+  }
+  async resolveAllTroubles(type, tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    const container = type === TROUBLE_TYPE_PURGE$1 ? this.purgeTroubles : this.primeTroubles;
+    const shouldDefer = container.filter((trouble) => trouble.shouldDefer);
+    shouldDefer.forEach((trouble) => {
+      this.logger.info(`Deferring trouble ${trouble.rawId}`);
+      trouble.defer();
+    });
+    const allTroubles = container.filter((trouble) => !trouble.shouldDefer).map((trouble) => trouble.rawId);
+    if (allTroubles.length === 0) {
+      return void 0;
+    }
+    const response = await resolveAll(allTroubles, tracker);
+    return response;
+  }
+  async resolveTrouble(troubleId, tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    const response = await resolveTrouble(troubleId, tracker);
+    return response;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing dashboard-operations ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading dashboard-operations ${this.id}`);
+  }
+};
+__decorateClass$g([
+  kosDependency({
+    modelType: TroubleContainer.type
+  })
+], DashboardOperationsModelImpl.prototype, "troubles", 2);
+__decorateClass$g([
+  kosFuture()
+], DashboardOperationsModelImpl.prototype, "resolveAllTroubles", 1);
+__decorateClass$g([
+  kosFuture()
+], DashboardOperationsModelImpl.prototype, "resolveTrouble", 1);
+DashboardOperationsModelImpl = __decorateClass$g([
+  kosModel(MODEL_TYPE$g)
+], DashboardOperationsModelImpl);
+const DashboardOperations = {
+  registration: {
+    [MODEL_TYPE$g]: {
+      class: DashboardOperationsModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$g,
+  predicate: isKosModel(MODEL_TYPE$g),
+  factory: Kos.Singleton.create(MODEL_TYPE$g)
+};
+var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
+var __decorateClass$f = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$f = "dispenser-model";
+let DispenserModelImpl = class {
+  id;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing dispenser ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading dispenser ${this.id}`);
+  }
+};
+DispenserModelImpl = __decorateClass$f([
+  kosModel(MODEL_TYPE$f)
+], DispenserModelImpl);
+const Dispenser = {
+  registration: {
+    [MODEL_TYPE$f]: {
+      class: DispenserModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$f,
+  predicate: isKosModel(MODEL_TYPE$f),
+  factory: Kos.Singleton.create(MODEL_TYPE$f)
+};
+const { URL: URL$8 } = resolveServiceUrl("DISPENSER_SERVICE");
+const { getAll: getAll$5 } = ServiceFactory.build({
+  basePath: `${URL$8}/api/dispenser`
+});
+const log$8 = KosLog.createLogger({
+  name: "dispenser-service",
+  group: "Services"
+});
+const getDispensers = async () => {
+  log$8.debug("sending GET for dispenser");
+  const response = await getAll$5({});
+  return response;
+};
+const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getDispensers
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$a = Object.defineProperty;
+var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
+var __decorateClass$e = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$a(target, key, result);
+  return result;
+};
+const MODEL_TYPE$e = "dispenser-info-model";
+let DispenserInfoModelImpl = class {
+  logger;
+  id;
+  name;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing dispenser-info ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading dispenser-info ${this.id}`);
+  }
+};
+__decorateClass$e([
+  kosConfigProperty({
+    path: "kos:device",
+    attribute: "name"
+  })
+], DispenserInfoModelImpl.prototype, "name", 2);
+DispenserInfoModelImpl = __decorateClass$e([
+  kosModel(MODEL_TYPE$e)
+], DispenserInfoModelImpl);
+const DispenserInfo = {
+  registration: {
+    [MODEL_TYPE$e]: {
+      class: DispenserInfoModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$e,
+  predicate: isKosModel(MODEL_TYPE$e),
+  factory: Kos.Factory.create(
+    MODEL_TYPE$e
+  )
+};
+const { URL: URL$7 } = resolveServiceUrl("DISPENSER-INFO_SERVICE");
+const { getAll: getAll$4 } = ServiceFactory.build({
+  basePath: `${URL$7}/api/dispenser-info`
+});
+const log$7 = KosLog.createLogger({
+  name: "dispenser-info-service",
+  group: "Services"
+});
+const getDispenserInfos = async () => {
+  log$7.debug("sending GET for dispenser-info");
+  const response = await getAll$4({});
+  return response;
+};
+const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getDispenserInfos
+}, Symbol.toStringTag, { value: "Module" }));
+var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
+var __decorateClass$d = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$d = "enrollment-model";
+let EnrollmentModelImpl = class {
+  id;
+  logger;
+  enrolled;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.enrolled = false;
+  }
+  updateModel(options) {
+    console.log("updateModel:", options);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing enrollment ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading enrollment ${this.id}`);
+  }
+};
+EnrollmentModelImpl = __decorateClass$d([
+  kosModel(MODEL_TYPE$d)
+], EnrollmentModelImpl);
+const Enrollment = {
+  registration: {
+    [MODEL_TYPE$d]: {
+      class: EnrollmentModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$d,
+  predicate: isKosModel(MODEL_TYPE$d),
+  factory: Kos.Singleton.create(MODEL_TYPE$d)
+};
+const { URL: URL$6 } = resolveServiceUrl("ENROLLMENT_SERVICE");
+const { getAll: getAll$3 } = ServiceFactory.build({
+  basePath: `${URL$6}/api/enrollment`
+});
+const log$6 = KosLog.createLogger({
+  name: "enrollment-service",
+  group: "Services"
+});
+const getEnrollments = async () => {
+  log$6.debug("sending GET for enrollment");
+  const response = await getAll$3({});
+  return response;
+};
+const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getEnrollments
+}, Symbol.toStringTag, { value: "Module" }));
+const isMicroGroup = (group) => group.toLowerCase().includes("micros");
+const isMacroGroup = (group) => !group.toLowerCase().includes("micros");
+const macroHolderMap = (assembly) => (holderName) => {
+  const holderGroup = assembly?.getHoldersByGroup(holderName);
+  if (!holderGroup) {
+    return null;
+  }
+  return holderGroup.map((holder) => {
+    return { id: holder.id, name: holder.ingredientName, path: holder.path };
+  });
+};
+const MACRO_KEYS = ["water", "carb", "ns", "nss"];
+const EXTENSION_POINT_DASHBOARD_KEY_FACTORY = "dashboardKeyFactory";
+const dashboardKeyFactories = [];
+registerExtensionPoint(EXTENSION_POINT_DASHBOARD_KEY_FACTORY, {
+  register: (_id, factory) => {
+    if (dashboardKeyFactories.includes(factory)) {
+      return;
+    }
+    dashboardKeyFactories.push(factory);
+  },
+  execute: (_id, holder) => {
+    const factories = dashboardKeyFactories.sort((a, b) => a.rank - b.rank);
+    for (const factory of factories) {
+      const key = factory.factory(holder);
+      if (key) {
+        return key;
+      }
+    }
+    return void 0;
+  }
+});
+const registerDashboardKeyFactory = (factory) => {
+  ExtensionManager[EXTENSION_POINT_DASHBOARD_KEY_FACTORY].register(
+    EXTENSION_POINT_DASHBOARD_KEY_FACTORY,
+    factory
+  );
+};
+const executeDashboardKeyFactory = (holder) => ExtensionManager[EXTENSION_POINT_DASHBOARD_KEY_FACTORY].execute(
+  EXTENSION_POINT_DASHBOARD_KEY_FACTORY,
+  holder
+);
+ExtensionManager.registerDashboardKeyFactory = registerDashboardKeyFactory;
+ExtensionManager.executeDashboardKeyFactory = executeDashboardKeyFactory;
+const HOUR = 3600;
+const MINUTE = 60;
+const toTimeComponents = (seconds) => {
+  const hours = Math.floor(seconds / HOUR);
+  const minutes = Math.floor(seconds % HOUR / MINUTE);
+  return { hours, minutes };
+};
+const toSeconds = (hours, minutes) => {
+  const time = hours * HOUR + minutes * MINUTE;
+  return time;
+};
+const calculateTimeDifference = (date) => {
+  const currentDate = /* @__PURE__ */ new Date();
+  const timeDifference = currentDate.valueOf() - date.valueOf();
+  const minutes = Math.floor(timeDifference / (1e3 * 60));
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const remainingMinutes = minutes % 60;
+  const remainingHours = hours % 24;
+  let result = "";
+  if (days > 0) {
+    result += `${days} day${days > 1 ? "s" : ""} `;
+  }
+  if (remainingHours > 0) {
+    result += `${remainingHours} hour${remainingHours > 1 ? "s" : ""} `;
+  }
+  if (remainingMinutes > 0 || days === 0 && remainingHours === 0) {
+    result += `${remainingMinutes} minute${remainingMinutes > 1 ? "s" : ""} `;
+  }
+  return result;
+};
+var __defProp$9 = Object.defineProperty;
+var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
+var __decorateClass$c = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$9(target, key, result);
+  return result;
+};
+const MODEL_TYPE$c = "ingredient-summary-model";
+let IngredientSummaryModelImpl = class {
+  id;
+  assemblyModel;
+  dashboardOperationModel;
+  appModel;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.dashboardOperationModel = DashboardOperations.factory({});
+  }
+  get highPriorityHolders() {
+    return this.assemblyModel.allHolders.filter(
+      (holder) => holder.troubles.length > 0 && holder.troubles.find((trouble) => trouble.rank >= 400)
+    );
+  }
+  get actionRequiredHolders() {
+    const currentRole = this.appModel.currentRole;
+    const filter = troubleVisibilityFilter(currentRole);
+    return this.assemblyModel.allHolders.filter((holder) => {
+      const companionModel = getKosCompanionModel(
+        holder,
+        FreestyleHolder.type
+      );
+      if (companionModel?.isRemote) {
+        return false;
+      }
+      const visibleTroubles = holder.troubles.filter(filter);
+      return visibleTroubles.length > 0 && visibleTroubles.find((trouble) => trouble.resolvable);
+    });
+  }
+  get lowLevelHolders() {
+    return this.assemblyModel.allHolders.filter((holder) => {
+      const fillPercent = holder.fillPercent;
+      const hasFuelGuage = holder.hasFuelGuage;
+      return hasFuelGuage && fillPercent < 20;
+    });
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing ingredient-summary ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading ingredient-summary ${this.id}`);
+  }
+};
+__decorateClass$c([
+  kosDependency({ modelType: Assembly.type })
+], IngredientSummaryModelImpl.prototype, "assemblyModel", 2);
+__decorateClass$c([
+  kosDependency({ modelType: DashboardOperations.type })
+], IngredientSummaryModelImpl.prototype, "dashboardOperationModel", 2);
+__decorateClass$c([
+  kosDependency({ modelType: Application.type })
+], IngredientSummaryModelImpl.prototype, "appModel", 2);
+IngredientSummaryModelImpl = __decorateClass$c([
+  kosModel(MODEL_TYPE$c)
+], IngredientSummaryModelImpl);
+const IngredientSummary = {
+  registration: {
+    [MODEL_TYPE$c]: {
+      class: IngredientSummaryModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$c,
+  predicate: isKosModel(MODEL_TYPE$c),
+  factory: Kos.Factory.create(
+    MODEL_TYPE$c
+  )
+};
+const { URL: URL$5 } = resolveServiceUrl("LOCKOUT_SERVICE");
+const { postModel: postModel$1 } = ServiceFactory.build({
+  basePath: `${URL$5}/api/app/kosdev.ddk/lockout`
+});
+const log$5 = KosLog.createLogger({ name: "lockout-service", group: "Services" });
+const lock = async () => {
+  log$5.info("lock");
+  const response = await postModel$1({
+    model: {},
+    urlOverride: `${URL$5}/api/app/kosdev.ddk/lockout/lockNow`
+  });
+  return response;
+};
+const unlock = async (pin) => {
+  log$5.info("unlock");
+  const response = await postModel$1({
+    model: {},
+    urlOverride: `${URL$5}/api/app/kosdev.ddk/lockout/unlock/${pin}`
+  });
+  return response?.data;
+};
+const index$5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  lock,
+  unlock
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$8 = Object.defineProperty;
+var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+var __decorateClass$b = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$8(target, key, result);
+  return result;
+};
+const MODEL_TYPE$b = "lockout-model";
+const scheduleData = [
+  { 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 LockoutModelImpl = class {
+  id;
+  logger;
+  dayEnabledList = [
+    "dayWiseLockConfigMap.Sun.enabled",
+    "dayWiseLockConfigMap.Mon.enabled",
+    "dayWiseLockConfigMap.Tue.enabled",
+    "dayWiseLockConfigMap.Wed.enabled",
+    "dayWiseLockConfigMap.Thu.enabled",
+    "dayWiseLockConfigMap.Fri.enabled",
+    "dayWiseLockConfigMap.Sat.enabled"
+  ];
+  dayOpenAtList = [
+    "dayWiseLockConfigMap.Sun.unlockTime",
+    "dayWiseLockConfigMap.Mon.unlockTime",
+    "dayWiseLockConfigMap.Tue.unlockTime",
+    "dayWiseLockConfigMap.Wed.unlockTime",
+    "dayWiseLockConfigMap.Thu.unlockTime",
+    "dayWiseLockConfigMap.Fri.unlockTime",
+    "dayWiseLockConfigMap.Sat.unlockTime"
+  ];
+  dayCloseAtList = [
+    "dayWiseLockConfigMap.Sun.lockTime",
+    "dayWiseLockConfigMap.Mon.lockTime",
+    "dayWiseLockConfigMap.Tue.lockTime",
+    "dayWiseLockConfigMap.Wed.lockTime",
+    "dayWiseLockConfigMap.Thu.lockTime",
+    "dayWiseLockConfigMap.Fri.lockTime",
+    "dayWiseLockConfigMap.Sat.lockTime"
+  ];
+  saveMap;
+  pin;
+  nextLockSkipped;
+  nextLockTime;
+  nextUnLockTime;
+  cuiLockout;
+  get enabled() {
+    const oneTimeLockConfigLockTime = this.getProp(
+      "oneTimeLockConfig.lockTime"
+    );
+    const oneTimeLockEnabled = oneTimeLockConfigLockTime !== void 0 && oneTimeLockConfigLockTime !== "";
+    const lockScheduleEnabled = this.getProp("lockScheduleEnabled");
+    const enabled = oneTimeLockEnabled || lockScheduleEnabled;
+    return enabled;
+  }
+  get schedule() {
+    return scheduleData;
+  }
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.saveMap = /* @__PURE__ */ new Map();
+  }
+  getProp(key) {
+    return this.saveMap.get(key);
+  }
+  setProp(key, value) {
+    this.saveMap.set(key, value);
+  }
+  // Skip or resume the next lock...
+  toggleSkip() {
+    const nextLockSkipped = this.nextLockSkipped.value;
+    if (nextLockSkipped === "0") {
+      const nextLockTime = this.nextLockTime.value;
+      if (nextLockTime !== void 0)
+        this.nextLockSkipped.updateProperty(nextLockTime);
+    } else {
+      this.nextLockSkipped.updateProperty("0");
+    }
+  }
+  async unlock(pin) {
+    return await unlock(pin);
+  }
+  async save() {
+    this.saveMap.forEach((value, key) => {
+      if (value !== this.cuiLockout.props[key])
+        this.cuiLockout.props[key] = value;
+    });
+    return this.cuiLockout.updateConfigBean();
+  }
+  reset() {
+    this.cuiLockout.props.entries.forEach(
+      ([key, value]) => this.saveMap.set(key, value)
+    );
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing lockout ${this.id}`);
+    this.cuiLockout.props.entries.forEach(
+      ([key, value]) => this.saveMap.set(key, value)
+    );
+  }
+  async load() {
+    this.logger.debug(`loading lockout ${this.id}`);
+  }
+};
+__decorateClass$b([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "pin"
+  })
+], LockoutModelImpl.prototype, "pin", 2);
+__decorateClass$b([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "nextLockSkipped"
+  })
+], LockoutModelImpl.prototype, "nextLockSkipped", 2);
+__decorateClass$b([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "nextLockTime"
+  })
+], LockoutModelImpl.prototype, "nextLockTime", 2);
+__decorateClass$b([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:service:cuiLockout",
+    attribute: "nextUnLockTime"
+  })
+], LockoutModelImpl.prototype, "nextUnLockTime", 2);
+__decorateClass$b([
+  kosConfigBean({ path: "app:kosdev.ddk:service:cuiLockout" })
+], LockoutModelImpl.prototype, "cuiLockout", 2);
+LockoutModelImpl = __decorateClass$b([
+  kosModel(MODEL_TYPE$b)
+], LockoutModelImpl);
+const Lockout = new SingletonKosModelRegistrationFactory({
+  class: LockoutModelImpl,
+  type: MODEL_TYPE$b
+});
+const purgeMacroPumps = async (troubleIds, tracker) => {
+  const response = await TroubleServices.bulkResolveTroubles(
+    troubleIds,
+    void 0,
+    tracker
+  );
+  return response;
+};
+var __defProp$7 = Object.defineProperty;
+var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
+var __decorateClass$a = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$7(target, key, result);
+  return result;
+};
+const MODEL_TYPE$a = "macro-assignment-model";
+const TROUBLE_TYPE_PURGE = "PurgeTrouble";
+const TROUBLE_TYPE_PRIME = "PrimeTrouble";
+let MacroAssignmentModelImpl = class {
+  id;
+  logger;
+  /**
+   * futureHandler is used to handle async operations
+   */
+  futureHandler;
+  holders;
+  ingredients;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.futureHandler = new FutureHandler();
+    this.logger = context.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((a, b) => {
+      if (a.name < b.name) return -1;
+      if (a.name > b.name) return 1;
+      return 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() {
+    const troubles = this.macroHolders.reduce((acc, curr) => {
+      const purgeTroubles = curr.troublesByType[TROUBLE_TYPE_PURGE] || [];
+      acc = [...acc, ...purgeTroubles];
+      return acc;
+    }, []);
+    return troubles;
+  }
+  get holderPrimeTroubles() {
+    const troubles = this.macroHolders.reduce((acc, curr) => {
+      const primeTroubles = curr.troublesByType[TROUBLE_TYPE_PRIME] || [];
+      acc = [...acc, ...primeTroubles];
+      return acc;
+    }, []);
+    return troubles;
+  }
+  /**
+   * 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(type, tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    const container = type === TROUBLE_TYPE_PURGE ? this.holderPurgeTroubles : this.holderPrimeTroubles;
+    const allTroubles = container.map((trouble) => trouble.rawId);
+    const response = await purgeMacroPumps(allTroubles, tracker);
+    return response;
+  }
+};
+__decorateClass$a([
+  kosDependency({ modelType: HolderContainer.type })
+], MacroAssignmentModelImpl.prototype, "holders", 2);
+__decorateClass$a([
+  kosDependency({ modelType: IngredientContainer.type })
+], MacroAssignmentModelImpl.prototype, "ingredients", 2);
+__decorateClass$a([
+  kosFuture()
+], MacroAssignmentModelImpl.prototype, "resolveAll", 1);
+MacroAssignmentModelImpl = __decorateClass$a([
+  kosModel(MODEL_TYPE$a)
+], MacroAssignmentModelImpl);
+const MacroAssignment = {
+  registration: {
+    [MODEL_TYPE$a]: {
+      class: MacroAssignmentModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$a,
+  predicate: isKosModel(MODEL_TYPE$a),
+  factory: Kos.Singleton.create(
+    MODEL_TYPE$a
+  )
+};
+var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
+var __decorateClass$9 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$9 = "network-test-model";
+let NetworkTestModelImpl = class {
+  id;
+  group;
+  passed;
+  inProgress;
+  failureTime;
+  timestamp;
+  name;
+  results;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.group = options.group;
+    this.passed = false;
+    this.inProgress = false;
+    this.name = options.name;
+    this.results = [];
+  }
+  updateModel(options) {
+    this.group = options.group;
+    this.name = options.name;
+    this.passed = options.passed;
+    this.failureTime = options.failureTime;
+    this.inProgress = options.inProgress;
+    this.timestamp = options.timestamp;
+    this.results = options.results;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing network-test ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading network-test ${this.id}`);
+  }
+};
+NetworkTestModelImpl = __decorateClass$9([
+  kosModel(MODEL_TYPE$9)
+], NetworkTestModelImpl);
+const NetworkTest = {
+  registration: {
+    [MODEL_TYPE$9]: {
+      class: NetworkTestModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$9,
+  predicate: isKosModel(MODEL_TYPE$9),
+  factory: Kos.Factory.create(MODEL_TYPE$9)
+};
+const { URL: URL$4 } = resolveServiceUrl("NETWORK-TEST_SERVICE");
+const { getAll: getAll$2, getOne: getOne$1 } = ServiceFactory.build({
+  basePath: `${URL$4}/api/app/ncui/network/tests`
+});
+const log$4 = KosLog.createLogger({
+  name: "network-test-service",
+  group: "Services"
+});
+const getNetworkTests = async () => {
+  log$4.debug("sending GET for network-test");
+  const response = await getAll$2({
+    urlOverride: `${URL$4}/api/app/kosdev.ddk/network/tests`
+  });
+  return response?.data;
+};
+const getTestsReports = async () => {
+  const response = await getOne$1({
+    urlOverride: `${URL$4}/api/app/kosdev.ddk/network/reports`
+  });
+  return response?.data;
+};
+const performGroupTest = async (group, tracker) => {
+  const response = await getOne$1({
+    urlOverride: `${URL$4}/api/app/kosdev.ddk/network/tests/run/group/${group}`,
+    tracker
+  });
+  return response;
+};
+const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getNetworkTests,
+  getTestsReports,
+  performGroupTest
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$6(target, key, result);
+  return result;
+};
+const MODEL_TYPE$8 = "network-test-container-model";
+let NetworkTestContainerModelImpl = class {
+  id;
+  logger;
+  lastTested;
+  futureHandler;
+  models;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.futureHandler = new FutureHandler(this);
+    this.models = new KosModelContainer({
+      parentId: modelId,
+      indexMap: {
+        group: "group"
+      }
+    });
+    this.lastTested = /* @__PURE__ */ new Date("default");
+  }
+  get data() {
+    return this.models.data;
+  }
+  addModel(model) {
+    this.models.addModel(model);
+  }
+  removeModel(id) {
+    this.models.removeModel(id);
+  }
+  getModel(id) {
+    return this.models.getModel(id);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(
+      `initializing network-test-container container ${this.id}`
+    );
+  }
+  getLastTested(groupName) {
+    const dateArray = this.models.getIndexByKey("group", groupName).map((obj) => obj.timestamp && new Date(obj.timestamp));
+    const latestDate = Math.max(
+      ...dateArray.map((date) => date ? date.getTime() : 0)
+    );
+    return latestDate ? calculateTimeDifference(new Date(latestDate)) : "";
+  }
+  async load() {
+    this.logger.debug(`loading network-test-container container ${this.id}`);
+    const testResponse = await getNetworkTests();
+    const testReportResponse = await getTestsReports();
+    if (testResponse) {
+      testResponse.forEach((item) => {
+        const testModel = NetworkTest.factory(item.id)(item);
+        this.addModel(testModel);
+      });
+    }
+    if (testResponse && testReportResponse) {
+      testResponse.forEach((item) => {
+        const groupReport = testReportResponse?.[item.group];
+        const testReport = groupReport?.[item.id];
+        const testModel = this.getModel(item.id);
+        if (testModel && testReport) {
+          const update = {
+            group: testReport.group,
+            name: testReport.name,
+            passed: testReport.passed,
+            failureTime: testReport.failureTime ? new Date(testReport.failureTime) : void 0,
+            inProgress: testReport.inProgress,
+            timestamp: new Date(testReport.timestamp),
+            results: testReport.results
+          };
+          testModel.updateModel(update);
+        }
+      });
+    }
+  }
+  async performTest(group, tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    const result = await performGroupTest(group, tracker);
+    return result?.data;
+  }
+  onFutureUpdate(future) {
+    const { clientData } = future;
+    if (clientData) {
+      clientData.forEach((item) => {
+        const testModel = this.getModel(item.id);
+        kosAction(() => {
+          this.lastTested = this.lastTested > new Date(item.timestamp) ? this.lastTested : new Date(item.timestamp);
+        });
+        if (testModel) {
+          const update = {
+            group: item.group,
+            name: item.name,
+            passed: item.passed,
+            failureTime: item.failureTime ? new Date(item.failureTime) : void 0,
+            inProgress: item.inProgress,
+            timestamp: new Date(item.timestamp),
+            results: item.results
+          };
+          kosAction(() => {
+            testModel.updateModel(update);
+          });
+        }
+      });
+    }
+  }
+};
+__decorateClass$8([
+  kosChild
+], NetworkTestContainerModelImpl.prototype, "models", 2);
+__decorateClass$8([
+  kosFuture()
+], NetworkTestContainerModelImpl.prototype, "performTest", 1);
+NetworkTestContainerModelImpl = __decorateClass$8([
+  kosModel(MODEL_TYPE$8)
+], NetworkTestContainerModelImpl);
+const NetworkTestContainer = {
+  registration: {
+    [MODEL_TYPE$8]: {
+      class: NetworkTestContainerModelImpl,
+      singleton: true
+    },
+    ...NetworkTest.registration
+  },
+  type: MODEL_TYPE$8,
+  predicate: isKosModel(MODEL_TYPE$8),
+  factory: Kos.Singleton.create(MODEL_TYPE$8)
+};
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$5(target, key, result);
+  return result;
+};
+const MODEL_TYPE$7 = "nutritive-sweetener-model";
+const PATH_PUMP_STATE = createPropKey("statePath");
+let NutritiveSweetenerModelImpl = class {
+  id;
+  assemblyModel;
+  pumpState;
+  constructor(modelId, _options) {
+    this.id = modelId;
+  }
+  get holder() {
+    const nsHolder = this.assemblyModel.getHoldersByGroup("ns")[0];
+    return nsHolder;
+  }
+  getHolder() {
+    return this.holder;
+  }
+  get statePath() {
+    return `${this.pump.path}:airVent:state`;
+  }
+  get pump() {
+    return this.holder.pumps.data[0];
+  }
+  getPump() {
+    return this.pump;
+  }
+};
+__decorateClass$7([
+  kosDependency({ modelType: Assembly.type })
+], NutritiveSweetenerModelImpl.prototype, "assemblyModel", 2);
+__decorateClass$7([
+  kosStateBean({
+    path: PATH_PUMP_STATE
+  })
+], NutritiveSweetenerModelImpl.prototype, "pumpState", 2);
+NutritiveSweetenerModelImpl = __decorateClass$7([
+  kosModel(MODEL_TYPE$7),
+  kosLoggerAware()
+], NutritiveSweetenerModelImpl);
+const NutritiveSweetener = {
+  registration: {
+    [MODEL_TYPE$7]: {
+      class: NutritiveSweetenerModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$7,
+  predicate: isKosModel(MODEL_TYPE$7),
+  factory: Kos.Factory.create(MODEL_TYPE$7)
+};
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$4(target, key, result);
+  return result;
+};
+const MODEL_TYPE$6 = "plain-water-model";
+let PlainWaterModelImpl = class {
+  id;
+  assemblyModel;
+  logger;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+  }
+  getHolder() {
+    const waterHolder = this.assemblyModel.getHoldersByGroup("water")[0];
+    return waterHolder;
+  }
+  getPump() {
+    const waterHolder = this.getHolder();
+    const pump = waterHolder?.pumps?.data?.[0];
+    const model = getKosCompanionModel(pump, FcmPump.type);
+    return model;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing plain-water ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading plain-water ${this.id}`);
+  }
+};
+__decorateClass$6([
+  kosDependency({ modelType: Assembly.type })
+], PlainWaterModelImpl.prototype, "assemblyModel", 2);
+PlainWaterModelImpl = __decorateClass$6([
+  kosModel(MODEL_TYPE$6)
+], PlainWaterModelImpl);
+const PlainWater = {
+  registration: {
+    [MODEL_TYPE$6]: {
+      class: PlainWaterModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$6,
+  predicate: isKosModel(MODEL_TYPE$6),
+  factory: Kos.Factory.create(MODEL_TYPE$6)
+};
+const { URL: URL$3 } = resolveServiceUrl("REBOOT_SERVICE");
+const { postModel } = ServiceFactory.build({
+  basePath: `${URL$3}/api/reboot`
+});
+const log$3 = KosLog.createLogger({ name: "reboot-service", group: "Services" });
+const rebootDispenser = async () => {
+  log$3.debug("sending POST call for Reboot Dispenser");
+  const response = await postModel({
+    urlOverride: `${URL$3}/api/app/kosdev.ddk/ncui/reboot`,
+    model: {}
+  });
+  return response;
+};
+const index$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  rebootDispenser
+}, Symbol.toStringTag, { value: "Module" }));
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$5 = "reboot-model";
+let RebootModelImpl = class {
+  id;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+  }
+  async completeReboot() {
+    await rebootDispenser();
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing reboot ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading reboot ${this.id}`);
+  }
+};
+RebootModelImpl = __decorateClass$5([
+  kosModel(MODEL_TYPE$5)
+], RebootModelImpl);
+const Reboot = {
+  registration: {
+    [MODEL_TYPE$5]: {
+      class: RebootModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$5,
+  predicate: isKosModel(MODEL_TYPE$5),
+  factory: Kos.Factory.create(MODEL_TYPE$5)
+};
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$3(target, key, result);
+  return result;
+};
+const MODEL_TYPE$4 = "settings-model";
+let SettingsModelImpl = class {
+  id;
+  logger;
+  ncuiLanguageData;
+  resolveDelaysMs;
+  dateFormat;
+  timeFormat;
+  hidePlainWaterBev;
+  hideCarbWaterBev;
+  ncuiLanguage;
+  name;
+  activateAndRebootTime;
+  horizontalMode;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async ready() {
+    this.updateDisplayMode();
+  }
+  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"
+          }
+        ]
+      }
+    };
+  }
+  handleUpdateDisplayMode() {
+    this.updateDisplayMode();
+  }
+  updateDisplayMode() {
+    if (this.horizontalMode.value) {
+      document.body.setAttribute("data-dashboard-layout", "horizontal");
+    } else {
+      document.body.setAttribute("data-dashboard-layout", "vertical");
+    }
+  }
+};
+__decorateClass$4([
+  kosConfigProperty({
+    path: "system:app",
+    attribute: "resolveDelaysMs"
+    // optionsExpander: () => [],
+  })
+], SettingsModelImpl.prototype, "resolveDelaysMs", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "system:app",
+    attribute: "dateFormat"
+    // optionsExpander: () => [],
+  })
+], SettingsModelImpl.prototype, "dateFormat", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "system:app",
+    attribute: "timeFormat"
+    // optionsExpander: () => [],
+  })
+], SettingsModelImpl.prototype, "timeFormat", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.hidePlainWaterBev"
+  })
+], SettingsModelImpl.prototype, "hidePlainWaterBev", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.hideCarbWaterBev"
+  })
+], SettingsModelImpl.prototype, "hideCarbWaterBev", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.ncuiLanguage"
+  })
+], SettingsModelImpl.prototype, "ncuiLanguage", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "kos:device",
+    attribute: "name"
+  })
+], SettingsModelImpl.prototype, "name", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "kos:service:OTA",
+    attribute: "activateAndRebootTime"
+  })
+], SettingsModelImpl.prototype, "activateAndRebootTime", 2);
+__decorateClass$4([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.uiConfig.display.horizontalMode"
+  })
+], SettingsModelImpl.prototype, "horizontalMode", 2);
+__decorateClass$4([
+  kosModelEffect({
+    dependencies: (model) => [model.horizontalMode.value]
+  })
+], SettingsModelImpl.prototype, "handleUpdateDisplayMode", 1);
+SettingsModelImpl = __decorateClass$4([
+  kosModel(MODEL_TYPE$4)
+], SettingsModelImpl);
+const Settings = {
+  registration: {
+    [MODEL_TYPE$4]: {
+      class: SettingsModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$4,
+  predicate: isKosModel(MODEL_TYPE$4),
+  factory: Kos.Singleton.create(MODEL_TYPE$4)
+};
+const { URL: URL$2 } = resolveServiceUrl("SETTINGS_SERVICE");
+const { getAll: getAll$1 } = ServiceFactory.build({
+  basePath: `${URL$2}/api/settings`
+});
+const log$2 = KosLog.createLogger({
+  name: "settings-service",
+  group: "Services"
+});
+const getSettings = async () => {
+  log$2.debug("sending GET for settings");
+  const response = await getAll$1({});
+  return response;
+};
+const getNcuiLanguage = async () => {
+  const response = await getAll$1({
+    urlOverride: `${URL$2}api/app/kosdev.ddk/ncui/languages`
+  });
+  return response;
+};
+const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getNcuiLanguage,
+  getSettings
+}, Symbol.toStringTag, { value: "Module" }));
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$3 = "utilities-model";
+let UtilitiesModelImpl = class {
+  id;
+  name;
+  options;
+  roles;
+  columnId;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.name = options.name;
+    this.options = options.options;
+    this.roles = options?.roles;
+    this.columnId = options.columnId;
+  }
+  updateModel(options) {
+    this.name = options.name;
+    this.options = options.options;
+    this.roles = options?.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}`);
+  }
+};
+UtilitiesModelImpl = __decorateClass$3([
+  kosModel(MODEL_TYPE$3)
+], UtilitiesModelImpl);
+const Utilities = {
+  registration: {
+    [MODEL_TYPE$3]: {
+      class: UtilitiesModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$3,
+  predicate: isKosModel(MODEL_TYPE$3),
+  factory: Kos.Factory.create(MODEL_TYPE$3)
+};
+const { URL: URL$1 } = resolveServiceUrl("UTILITIES_SERVICE");
+const { getAll } = ServiceFactory.build({
+  basePath: `${URL$1}/api/utilities`
+});
+const log$1 = KosLog.createLogger({
+  name: "utilities-service",
+  group: "Services"
+});
+const getUtilities = async () => {
+  log$1.debug("sending GET for utilities");
+  try {
+    const extensionResponse = await getAll({
+      urlOverride: `${URL$1}/api/kos/descriptor/app:kosdev.ddk:ncuiDescriptor/kondra.ncui.utilities`
+    });
+    if (extensionResponse?.status !== 200) {
+      log$1.info(`no extensions found, using base data`);
+      const response = await getAll({
+        urlOverride: `${URL$1}/api/kos/descriptor/system:app/kondra.ncui.utilities`
+      });
+      return response?.data ?? [];
+    }
+    return extensionResponse?.data ?? [];
+  } catch (error) {
+    log$1.info(`error fetching utilities: ${error}. Using base data`);
+    const response = await getAll({
+      urlOverride: `${URL$1}/api/kos/descriptor/system:app/kondra.ncui.utilities`
+    });
+    return response?.data ?? [];
+  }
+};
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getUtilities
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+const MODEL_TYPE$2 = "utilities-container-model";
+let UtilitiesContainerModelImpl = class {
+  id;
+  logger;
+  _models;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this._models = new KosModelContainer({
+      parentId: modelId,
+      sortKey: "id",
+      indexMap: {
+        byColumn: "columnId"
+      }
+    });
+  }
+  get data() {
+    return this._models.data;
+  }
+  get models() {
+    return this._models;
+  }
+  get columns() {
+    return this._models.getIndexKeys("byColumn").sort((a, b) => a.localeCompare(b));
+  }
+  addModel(model) {
+    this._models.addModel(model);
+  }
+  removeModel(id) {
+    this._models.removeModel(id);
+  }
+  getModel(id) {
+    return this._models.getModel(id);
+  }
+  getUtilitiesByColumn(id) {
+    return this._models.getIndexByKey("byColumn", id);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async load() {
+    this.logger.debug(`loading utilities-container container ${this.id}`);
+    const utilitiesResponse = await getUtilities();
+    utilitiesResponse?.forEach((utilityColumnsResponse, columnId) => {
+      utilityColumnsResponse.forEach((utilityResponse) => {
+        const utilityOptions = {
+          ...utilityResponse,
+          columnId: String(columnId)
+        };
+        const utilityModel = Utilities.factory(utilityResponse.name)(
+          utilityOptions
+        );
+        this.addModel(utilityModel);
+      });
+    });
+  }
+};
+__decorateClass$2([
+  kosChild
+], UtilitiesContainerModelImpl.prototype, "_models", 2);
+UtilitiesContainerModelImpl = __decorateClass$2([
+  kosModel(MODEL_TYPE$2)
+], UtilitiesContainerModelImpl);
+const UtilitiesContainer = {
+  registration: {
+    [MODEL_TYPE$2]: {
+      class: UtilitiesContainerModelImpl,
+      singleton: true
+    },
+    ...Utilities.registration
+  },
+  type: MODEL_TYPE$2,
+  predicate: isKosModel(MODEL_TYPE$2),
+  factory: Kos.Singleton.create(MODEL_TYPE$2)
+};
+const DDKModels = {
+  ...Animation.registration,
+  ...Application.registration,
+  ...Auth.registration,
+  ...CarbWater.registration,
+  ...DashboardOperations.registration,
+  ...Dispenser.registration,
+  ...DispenserInfo.registration,
+  ...Enrollment.registration,
+  ...IngredientSummary.registration,
+  ...MacroAssignment.registration,
+  ...NetworkTestContainer.registration,
+  ...NutritiveSweetener.registration,
+  ...PlainWater.registration,
+  ...Reboot.registration,
+  ...Settings.registration,
+  ...SetupStepContainer.registration,
+  ...UtilitiesContainer.registration
+};
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "", value);
+const MODEL_TYPE$1 = "trouble-action-model";
+let TroubleActionModelImpl = class {
+  /**
+   * Unique identifier for this model instance.
+   *
+   * Set during construction and used for model lifecycle management
+   * and debugging purposes.
+   *
+   * @category Model Properties
+   */
+  id;
+  troubleContainer;
+  /**
+   * Observable state object mapping trouble state keys to values.
+   *
+   * This reactive state object is automatically updated when troubles are
+   * added or removed from the system. Keys and values are determined by
+   * the trouble action definitions provided during model initialization.
+   *
+   * State keys that no longer have associated active troubles are set to
+   * undefined.
+   *
+   * @example
+   * ```typescript
+   * // Access state values
+   * const isAgitationRequired = troubleActionModel.state.agitationRequired;
+   *
+   * // State is reactive - updates automatically propagate to React components
+   * ```
+   *
+   * @category Model State
+   */
+  state;
+  /**
+   * Internal mapping of trouble types to their action definitions.
+   *
+   * Built from the definitions array provided in TroubleActionOptions during
+   * construction. Used for efficient lookup when processing trouble changes.
+   *
+   * @category Internal State
+   */
+  troubleActionData;
+  /**
+   * Creates a new TroubleActionModel instance.
+   *
+   * Initializes the model with trouble action definitions that map trouble
+   * types to state key-value pairs. The model begins monitoring the trouble
+   * container immediately upon creation.
+   *
+   * @param modelId - Unique identifier for this model instance
+   * @param options - Configuration options containing trouble action definitions
+   * @param context - KOS creation context providing logger and framework services
+   *
+   * @category Lifecycle
+   */
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.state = ObservableData();
+    this.troubleActionData = options.definitions.reduce((acc, curr) => {
+      acc[curr.troubleType] = curr;
+      return acc;
+    }, {});
+  }
+  // -------------------LIFECYCLE----------------------------
+  /**
+   * Gets the first active trouble that has an associated action definition.
+   *
+   * Returns the first trouble found that matches any of the configured trouble
+   * action definitions. If multiple troubles are active, priority is determined
+   * by the order of trouble type keys in the troubleActionData object.
+   *
+   * @returns The active trouble model, or undefined if no matching troubles exist
+   *
+   * @example
+   * ```typescript
+   * const trouble = troubleActionModel.activeTrouble;
+   * if (trouble) {
+   *   console.log(`Active trouble: ${trouble.type}`);
+   *   console.log(`Resolvable: ${trouble.resolvable}`);
+   * }
+   * ```
+   *
+   * @category Trouble Access
+   * @see {@link TroubleContainerModel} for trouble data structure
+   */
+  get activeTrouble() {
+    const actions = Object.keys(this.troubleActionData);
+    if (actions.length > 0) {
+      const firstAction = actions[0];
+      const troubles = this.troubleContainer.troubles.getIndexByKey(
+        "byType",
+        firstAction
+      );
+      if (troubles.length > 0) {
+        return troubles[0];
+      } else {
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Gets the type of the first active trouble with an associated action definition.
+   *
+   * Convenience getter that extracts the trouble type from the active trouble.
+   * Commonly used for conditional UI rendering based on trouble type.
+   *
+   * @returns The active trouble type string, or undefined if no troubles are active
+   *
+   * @example
+   * ```typescript
+   * const troubleType = troubleActionModel.activeTroubleType;
+   * if (troubleType === 'InsufficientAgitationTrouble') {
+   *   // Show agitation required UI
+   * }
+   * ```
+   *
+   * @category Trouble Access
+   */
+  get activeTroubleType() {
+    return this.activeTrouble?.type;
+  }
+  handleTroubleActions() {
+    const _state = this.troubleContainer.troubles.data.reduce((acc, curr) => {
+      const _troubleType = curr.type;
+      if (this.troubleActionData[_troubleType]) {
+        const _stateKey = this.troubleActionData[_troubleType].stateKey ?? _troubleType;
+        const _stateValue = this.troubleActionData[_troubleType].stateValue ?? _troubleType;
+        acc[_stateKey] = _stateValue;
+      }
+      return acc;
+    }, {});
+    this.state.setValues(_state);
+    Object.keys(this.troubleActionData).forEach((key) => {
+      if (this.troubleContainer.troubles.getIndexByKey("byType", key).length === 0) {
+        const _stateKey = this.troubleActionData[key].stateKey ?? key;
+        this.state[_stateKey] = void 0;
+      }
+    });
+  }
+};
+__publicField(TroubleActionModelImpl, "Registration");
+__decorateClass$1([
+  kosDependency({ modelType: TroubleContainer.type })
+], TroubleActionModelImpl.prototype, "troubleContainer", 2);
+__decorateClass$1([
+  kosModelEffect({
+    dependencies: (model) => [model.troubleContainer.troubles.data]
+  })
+], TroubleActionModelImpl.prototype, "handleTroubleActions", 1);
+TroubleActionModelImpl = __decorateClass$1([
+  kosModel({ modelTypeId: MODEL_TYPE$1, singleton: true }),
+  kosLoggerAware()
+], TroubleActionModelImpl);
+const TroubleAction = TroubleActionModelImpl.Registration;
+const { URL } = resolveServiceUrl("START_SERVICE");
+const { getOne } = ServiceFactory.build({
+  basePath: `${URL}/api/start`
+});
+const log = KosLog.createLogger({ name: "start-service", group: "Services" });
+const navigateToNCui = async () => {
+  log.debug("navigating to NCUI");
+  const response = await getOne({
+    urlOverride: `${URL}/api/app/kosdev.ddk/ncui/open`
+  });
+  return response;
+};
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  navigateToNCui
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+const MODEL_TYPE = "start-model";
+let StartModelImpl = class {
+  id;
+  logger;
+  troubles;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.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 navigateToNCui();
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing start ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading start ${this.id}`);
+  }
+};
+__decorateClass([
+  kosDependency({ modelType: TroubleContainer.type })
+], StartModelImpl.prototype, "troubles", 2);
+StartModelImpl = __decorateClass([
+  kosModel(MODEL_TYPE)
+], StartModelImpl);
+const Start = new SingletonKosModelRegistrationFactory({
+  class: StartModelImpl,
+  type: MODEL_TYPE
+});
+export {
+  AgitationControl,
+  Animation,
+  index$b as AnimationServices,
+  Application,
+  Auth,
+  index$d as AuthServices,
+  CarbWater,
+  CopyLogs,
+  index$a as CopyLogsServices,
+  DDKModels,
+  DashboardOperations,
+  index$9 as DashboardOperationsServices,
+  Dispenser,
+  DispenserInfo,
+  index$7 as DispenserInfoServices,
+  index$8 as DispenserServices,
+  Door,
+  EXTENSION_POINT_DASHBOARD_KEY_FACTORY,
+  Enrollment,
+  index$6 as EnrollmentServices,
+  IngredientSummary,
+  Lockout,
+  index$5 as LockoutServices,
+  MACRO_KEYS,
+  MacroAssignment,
+  NetworkTest,
+  NetworkTestContainer,
+  index$4 as NetworkTestServices,
+  NutritiveSweetener,
+  PlainWater,
+  Reboot,
+  index$3 as RebootServices,
+  Settings,
+  index$2 as SettingsServices,
+  SetupStep,
+  SetupStepContainer,
+  index$c as SetupStepServices,
+  Start,
+  index as StartServices,
+  TROUBLE_TYPE_PRIME$1 as TROUBLE_TYPE_PRIME,
+  TROUBLE_TYPE_PURGE$1 as TROUBLE_TYPE_PURGE,
+  TroubleAction as TroubleActionManager,
+  Utilities,
+  UtilitiesContainer,
+  index$1 as UtilitiesServices,
+  calculateTimeDifference,
+  executeDashboardKeyFactory,
+  isMacroGroup,
+  isMicroGroup,
+  macroHolderMap,
+  registerDashboardKeyFactory,
+  toSeconds,
+  toTimeComponents,
+  troubleVisibilityFilter
+};
+//# sourceMappingURL=index.mjs.map