@kosdev-code/kos-dispense-sdk 3.0.26 → 3.0.27

package/extension-utils-D_dnBLH6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-utils-D_dnBLH6.js","sources":["../../../packages/kos-dispense-sdk/src/models/models/holder/utils/holder-utils.ts","../../../packages/kos-dispense-sdk/src/models/utils/extension-utils.ts"],"sourcesContent":["import { kosAutoEffect } from \"@kosdev-code/kos-ui-sdk\";\nimport { useEffect, useState } from \"react\";\nimport type { HolderModel } from \"../types\";\n\nexport const getFuelGaugeValue = (holder: HolderModel) => {\n  const [maxVolume, setMaxVolume] = useState<number>(\n    holder?.slice?.maxVolMl ?? 0\n  );\n  const [remainingVolume, setRemainingVolume] = useState<number>(\n    holder?.slice?.currentVolMl ?? 0\n  );\n\n  const [hasMaxVolume, setHasMaxVolume] = useState<boolean>(\n    holder?.slice?.maxVolMl !== undefined\n  );\n\n  const [hasRemainingVolume, setHasRemainingVolume] = useState<boolean>(\n    holder?.slice?.currentVolMl !== undefined\n  );\n\n  const [fillPercent, setFillPercent] = useState<number>(\n    remainingVolume <= 0\n      ? 0\n      : Math.floor(((remainingVolume || 1) / (maxVolume || 1)) * 100)\n  );\n\n  const [hasFuelGuage, setHasFuelGuage] = useState<boolean>(\n    hasMaxVolume && hasRemainingVolume\n  );\n\n  useEffect(() => {\n    const disposer = kosAutoEffect(() => {\n      setMaxVolume(holder?.slice?.maxVolMl ?? 0);\n      setRemainingVolume(holder?.slice?.currentVolMl ?? 0);\n      setHasMaxVolume(holder?.slice?.maxVolMl !== undefined);\n      setHasRemainingVolume(holder?.slice?.currentVolMl !== undefined);\n      setFillPercent(\n        remainingVolume <= 0\n          ? 0\n          : Math.floor(((remainingVolume || 1) / (maxVolume || 1)) * 100)\n      );\n      setHasFuelGuage(hasMaxVolume && hasRemainingVolume);\n    });\n\n    return () => {\n      disposer();\n    };\n  }, [holder]);\n\n  return { maxVolume, remainingVolume, fillPercent, hasFuelGuage };\n};\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  CoreExtensionManager,\n  DataLoader,\n  DataMapper,\n  EXTENSION_FEATURE_FLAG_RESOLVER,\n  ExtensionManager,\n  ExtensionOptions,\n  IndexExtension,\n  PropertyMapper,\n  type FlagResolver,\n} from \"@kosdev-code/kos-ui-sdk\";\nimport { ExtensionType } from \"../constants\";\nimport { AssemblyTypes, type AssemblyModel } from \"../models\";\nimport type { HolderResponse } from \"../models/holder/services\";\nimport type { HolderModel } from \"../models/holder/types\";\nimport type { IngredientResponse } from \"../models/ingredient/services\";\nimport type { BeverageResponse } from \"../models/nozzle/services\";\nimport type { SelectedPourable } from \"../models/nozzle/types\";\n\nexport type IngredientDataMapper<\n  AdditionalData extends object = Record<string, any>\n> = DataMapper<IngredientResponse, AdditionalData, any>;\n\n/**\n * Mapping function that maps an ingredient response into the type property of\n * the {@link IngredientModel}.\n */\nexport type IngredientTypeMapper<\n  T extends IngredientResponse = IngredientResponse\n> = PropertyMapper<T, string>;\n\n/**\n * Mapping function that maps additional data from holder service response\n * into the {@link HolderModel} data.\n */\nexport type HolderTypeMapper<T extends HolderResponse = HolderResponse> =\n  PropertyMapper<T, string>;\n\n/**\n * Mapping function that maps additional data from holder service response\n * into the {@link HolderModel} data.\n */\nexport type HolderDataMapper<\n  AdditionalData extends object = Record<string, any>,\n  HolderData extends HolderResponse = HolderResponse\n> = DataMapper<HolderData, AdditionalData, any>;\n\nexport type GroupBeverageResponse = BeverageResponse & { groupId: string };\nexport type AvailabilityDataMapper<\n  AdditionalData extends object = Record<string, any>,\n  AvailabilityData extends GroupBeverageResponse = GroupBeverageResponse\n> = DataMapper<AvailabilityData, AdditionalData, any>;\n\nexport type SelectedPourableMapper = DataMapper<SelectedPourable, any>;\n\nexport type BoardDataMapper<\n  AdditionalData extends object = Record<string, any>,\n  BoardData extends AssemblyTypes.AssemblyBoard<any> = AssemblyTypes.AssemblyBoard<any>\n> = DataMapper<BoardData, AdditionalData, any>;\n\nexport type AssemblyMapper<\n  AdditionalData extends object = Record<string, any>,\n  AssemblyResponseData extends AssemblyTypes.AssemblyResponse<any> = AssemblyTypes.AssemblyResponse<any>\n> = DataMapper<AssemblyResponseData, AdditionalData, any>;\n/**\n * The DispenseExtensionManager is responsible for managing the extension points that are specific to the Dispense application.\n */\nexport class DispenseExtensionManager {\n  core: CoreExtensionManager = new CoreExtensionManager();\n  /**\n   * Registers a data mapper for the {@link IngredientModel}.\n   *\n   * Ingredient service data often needs properties the base model does not carry. The mapper receives each\n   * {@link IngredientResponse} and the data returned by the ingredient loader as context, and its result\n   * becomes the model's `data` property.\n   *\n   * @param ingredientDataMapper - Mapping function that maps an {@link IngredientResponse} into additional model data\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and continue processing remaining mappers.\n   * @returns this instance for chaining\n   */\n  registerIngredientDataMapper(\n    ingredientDataMapper: IngredientDataMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.dataMapper.registerDataMapper(\n      ExtensionType.IngredientMapper,\n      ingredientDataMapper,\n      options\n    );\n\n    return this;\n  }\n\n  /**\n   * Registers a loader whose result is passed as context to the ingredient data and type mappers.\n   *\n   * @param ingredientLoader - Async function that loads and returns ingredient context data\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on loader failure.\n   *   Set to `\"continue\"` to log the error and return `undefined` instead.\n   * @returns this instance for chaining\n   */\n  registerIngredientLoader(\n    ingredientLoader: DataLoader,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.loader.registerLoader(\n      ExtensionType.IngredientLoader,\n      ingredientLoader,\n      options\n    );\n    return this;\n  }\n\n  registerIngredientIndex(ingredientIndex: IndexExtension) {\n    ExtensionManager.indexExtension.registerIndexExtension(\n      ExtensionType.IngredientIndex,\n      ingredientIndex\n    );\n    return this;\n  }\n\n  /**\n   * Registers a property mapper that derives the `type` property of the {@link IngredientModel}\n   * from an {@link IngredientResponse}.\n   *\n   * @param ingredientTypeMapper - Mapping function that extracts a type string from an {@link IngredientResponse}\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and return a fallback value instead.\n   * @returns this instance for chaining\n   * */\n  registerIngredientTypeMapper(\n    ingredientTypeMapper: IngredientTypeMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.propertyMapper.registerPropertyMapper(\n      ExtensionType.IngredientTypeMapper,\n      ingredientTypeMapper,\n      options\n    );\n    return this;\n  }\n\n  /**\n   * Registers a data mapper for the {@link HolderModel} model.\n   *\n   * @param holderDataMapper - Mapping function that maps additional data from a {@link HolderResponse}\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and continue processing remaining mappers.\n   * @returns this instance for chaining\n   */\n  registerHolderDataMapper(\n    holderDataMapper: HolderDataMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.dataMapper.registerDataMapper(\n      ExtensionType.HolderMapper,\n      holderDataMapper,\n      options\n    );\n    return this;\n  }\n\n  /**\n   * Registers a property mapper that derives the `type` property of the {@link HolderModel}\n   * from a {@link HolderResponse}.\n   *\n   * @param holderTypeMapper - Mapping function that extracts a type string from a {@link HolderResponse}\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and return a fallback value instead.\n   * @returns this instance for chaining\n   */\n  registerHolderTypeMapper(\n    holderTypeMapper: HolderTypeMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.propertyMapper.registerPropertyMapper(\n      ExtensionType.HolderTypeMapper,\n      holderTypeMapper,\n      options\n    );\n    return this;\n  }\n\n  /**\n   * Maps the ingredientId property of the holder into the {@link HolderModel}.\n   * If not provided, the ingredientId will assume that the value is mapped from the\n   * ingredientId property of the service response.\n   *\n   * @param holderTypeMapper - Mapping function that extracts the ingredientId from a {@link HolderResponse}\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and return a fallback value instead.\n   * @returns this instance for chaining\n   * */\n  registerHolderIngredientMapper(\n    holderTypeMapper: HolderTypeMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.propertyMapper.registerPropertyMapper(\n      ExtensionType.HolderTypeMapper,\n      holderTypeMapper,\n      options\n    );\n    return this;\n  }\n\n  registerHolderIndex<T extends HolderModel = HolderModel>(\n    holderIndex: IndexExtension<T>\n  ) {\n    ExtensionManager.indexExtension.registerIndexExtension(\n      ExtensionType.HolderIndex,\n      holderIndex\n    );\n    return this;\n  }\n\n  /**\n   * Registers a data mapper for the {@link AvailabilityModel}.\n   *\n   * The mapper receives each availability node, with its `groupId`, and the data returned by the\n   * availability loader as context. Its result becomes the model's `data` property.\n   *\n   * @param availabilityMapper - Mapping function that maps a {@link GroupBeverageResponse} into additional availability data\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and continue processing remaining mappers.\n   * @returns this instance for chaining\n   *\n   * @example\n   * ```typescript\n   * const beverageDataMapper: AvailabilityDataMapper<BeverageData> = async (\n   *   data,\n   *   context?: Record<string, BrandsetIngredient>\n   * ) => ({\n   *   iconUrl: context?.[data.altId]?.icon ?? \"\",\n   * });\n   * ```\n   */\n  registerAvailabilityDataMapper(\n    availabilityMapper: AvailabilityDataMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.dataMapper.registerDataMapper(\n      ExtensionType.AvailabilityMapper,\n      availabilityMapper,\n      options\n    );\n    return this;\n  }\n\n  /**\n   * Registers a loader whose result is passed as context to the availability data mapper. A common use is\n   * loading UI-specific brandset data that the backend service does not provide.\n   *\n   * @param availabilityLoader - Async function that loads and returns availability context data\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on loader failure.\n   *   Set to `\"continue\"` to log the error and return `undefined` instead.\n   * @returns this instance for chaining\n   *\n   * @example\n   * ```typescript\n   * const beverageContextLoader = async () => {\n   *   const response = await kosFetch(\"kos:/system/brandset/brandset.json\");\n   *   const json: BrandsetResponse = await response.json();\n   *   return Object.fromEntries(json.ingredients.map((i) => [i.ingredientId, i]));\n   * };\n   * ```\n   */\n  registerAvailabilityLoader(\n    availabilityLoader: DataLoader,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.loader.registerLoader(\n      ExtensionType.AvailabilityLoader,\n      availabilityLoader,\n      options\n    );\n    return this;\n  }\n\n  /**\n   * Maps the abstract {@link SelectedPourable} data into a format that is specific to the nozzle.\n   *\n   * @param selectedPourableMapper - Mapping function that transforms {@link SelectedPourable} data\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and continue processing remaining mappers.\n   * @returns this instance for chaining\n   * */\n  registerSelectedPourableDataMapper(\n    selectedPourableMapper: SelectedPourableMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.dataMapper.registerDataMapper(\n      ExtensionType.SelectedPourableMapper,\n      selectedPourableMapper,\n      options\n    );\n    return this;\n  }\n\n  /**\n   * Registers a data mapper for the {@link AssemblyModel}, for backends that extend the assembly response\n   * with additional properties. The mapper's result is merged into the assembly model.\n   *\n   * @param assemblyDataMapper - Mapping function that maps an {@link AssemblyTypes.AssemblyResponse} into additional assembly data\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and continue processing remaining mappers.\n   * @returns this instance for chaining\n   *\n   * @example\n   * ```typescript\n   * interface IceAgitatorExt {\n   *   iceAgitator?: { name: string; path: string };\n   * }\n   *\n   * const assemblyDataMapper: AssemblyMapper<\n   *   { iceAgitatorPath?: string },\n   *   AssemblyTypes.AssemblyResponse<{ AssemblyExt: IceAgitatorExt }>\n   * > = async (data) => ({\n   *   iceAgitatorPath: data.assemblies.find((a) => a.iceAgitator)?.iceAgitator?.path,\n   * });\n   * ```\n   */\n  registerAssemblyDataMapper(\n    assemblyDataMapper: AssemblyMapper,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.dataMapper.registerDataMapper(\n      ExtensionType.AssemblyMapper,\n      assemblyDataMapper,\n      options\n    );\n    return this;\n  }\n\n  registerBoardIndex(boardIndex: IndexExtension) {\n    ExtensionManager.indexExtension.registerIndexExtension(\n      ExtensionType.BoardIndex,\n      boardIndex\n    );\n    return this;\n  }\n\n  /**\n   * Registers a data mapper for the board model within an assembly.\n   *\n   * @param boardDataMapper - Mapping function that maps an {@link AssemblyTypes.AssemblyBoard} into additional board data\n   * @param options - Optional {@link ExtensionOptions} to control failure behavior.\n   *   Defaults to `failurePolicy: \"throw\"`, which throws an {@link ExtensionException} on mapper failure.\n   *   Set to `\"continue\"` to log the error and continue processing remaining mappers.\n   * @returns this instance for chaining\n   */\n  registerBoardDataMapper(\n    boardDataMapper: BoardDataMapper<any, any>,\n    options?: ExtensionOptions\n  ) {\n    ExtensionManager.dataMapper.registerDataMapper(\n      ExtensionType.BoardMapper,\n      boardDataMapper,\n      options\n    );\n    return this;\n  }\n\n  registerAssemblyFeatureFlagResolver(\n    assemblyFeatureFlagResolver: FlagResolver<AssemblyModel>\n  ) {\n    ExtensionManager[EXTENSION_FEATURE_FLAG_RESOLVER]?.register(\n      ExtensionType.AssemblyFeatureFlags,\n      assemblyFeatureFlagResolver\n    );\n    return this;\n  }\n}\n\n/**\n * The KosExtensionManager provides access to the extension points that are provided in the SDK for Dispense applications.\n *\n * The extension points are divided into two categories:\n *\n * @param core - The core extension {@link CoreExtensionManager}  points are used to extend the base models that are provided by the SDK.\n * @param dispense -  The dispense extension {@link DispenseExtensionManager} points are used to extend the models that are specific to the Dispense SDK.\n */\nexport class KosExtensionManager {\n  dispense: DispenseExtensionManager;\n  core: CoreExtensionManager;\n  constructor() {\n    this.dispense = new DispenseExtensionManager();\n    this.core = new CoreExtensionManager();\n  }\n}\n"],"names":[],"mappings":"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"}

package/index.cjs

@@ -3,8 +3,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const kosApiLevels = require("@kosdev-code/kos-api-levels");
 const utilities = require("@kosdev-code/kos-ui-plugin/utilities");
 const dispenseRegistrationManager = require("./dispense-registration-manager-Dtb31fcI.cjs");
-const extensionUtils = require("./extension-utils-CwctwFhK.cjs");
-const pumpProvider = require("./pump-provider-SXrqGmxO.cjs");
+const extensionUtils = require("./extension-utils-Cfhe358W.cjs");
+const pumpProvider = require("./pump-provider-uNNMh9uh.cjs");
 const ControlPourSchema = utilities.createExtensionSchema({}, { rankable: false });
 const EXTENSION_ID = utilities.extensionPointId("cui", "control", "pour");
 const ControlPourExtension = utilities.defineExtensionPoint({

package/index.js

@@ -1,8 +1,8 @@
 import { registerApiLevels } from "@kosdev-code/kos-api-levels";
 import { createExtensionSchema, extensionPointId, defineExtensionPoint, createViewAwareTransform, validateWithSchema } from "@kosdev-code/kos-ui-plugin/utilities";
 import { A, a, B, b, c, C, d, D, e, o, E, G, H, f, I, g, K, N, P, h, i, j, T, k, l, m, n, o as o2, r } from "./dispense-registration-manager-Da9CW_cN.js";
-import { i as i2, a as a2, D as D2, b as b2, c as c2, d as d2, K as K2, e as e2, f as f2, g as g2 } from "./extension-utils-C_pwmFbZ.js";
-import { A as A2, a as a3, B as B2, b as b3, C as C2, c as c3, D as D3, d as d3, e as e3, f as f3, H as H2, g as g3, h as h2, i as i3, I as I2, j as j2, N as N2, P as P2, k as k2, T as T2, l as l2, m as m2, n as n2, u, o as o3, p, q, r as r2, s, t, v, w, x, y, z, E as E2, F, G as G2, J, K as K3, L, M, O, Q, R, S, U, V, W, X, Y, Z, _, $, a0, a1, a2 as a22, a3 as a32, a4, a5, a6, a7, a8, a9, aa, ab } from "./pump-provider-CAKW652V.js";
+import { i as i2, a as a2, D as D2, b as b2, c as c2, d as d2, K as K2, e as e2, f as f2, g as g2 } from "./extension-utils-D_dnBLH6.js";
+import { A as A2, a as a3, B as B2, b as b3, C as C2, c as c3, D as D3, d as d3, e as e3, f as f3, H as H2, g as g3, h as h2, i as i3, I as I2, j as j2, N as N2, P as P2, k as k2, T as T2, l as l2, m as m2, n as n2, u, o as o3, p, q, r as r2, s, t, v, w, x, y, z, E as E2, F, G as G2, J, K as K3, L, M, O, Q, R, S, U, V, W, X, Y, Z, _, $, a0, a1, a2 as a22, a3 as a32, a4, a5, a6, a7, a8, a9, aa, ab } from "./pump-provider-BQmCKz7S.js";
 const ControlPourSchema = createExtensionSchema({}, { rankable: false });
 const EXTENSION_ID = extensionPointId("cui", "control", "pour");
 const ControlPourExtension = defineExtensionPoint({

package/models/constants/constants.d.ts

@@ -3,73 +3,14 @@
  * */
 export declare enum ExtensionType {
     /**
-     * Loads data that will be provided as context into the {@link IngredientMapper}
-     *
-     * @example
-     * The following example shows how to load the brandset data, normalize it into a map and then provide it back to the framework
-     * where it can be used by the other extension points.
-     *
-     * In the ingredient container model, the data is provided to the {@link IngredientMapper} extension point in order to augment ingredient data
-     * and also loaded into the ingredient container model context in order to make the data available throughout the code.
-     *
-     * ```typescript
-     *  export const ingredientContextLoader = async (): Promise<BeverageContext> => {
-     *  const response = await kosFetch('kos:/system/some/ingredient/endpoint.json');
-     *
-     *   if (response.status !== 200) {
-     *     KosLog.error('Failed to load ingredient data');
-     *       return {};
-     *   }
-     *  const json = await response.json();
-     *  return json;
-     *  };
-     * ```
-     * */
+     * Loads data that is passed as context to the {@link IngredientMapper}. Register with
+     * {@link DispenseExtensionManager.registerIngredientLoader}.
+     */
     IngredientLoader = "kos.ingredient.loader",
     /**
-     * Maps data into the {@link IngredientModel}
-     *
-     * It is common for the ingredient data provided by the ingredient service to be augmented with additional properties that are
-     * not provided by the base KOS Ingredient model. The {@link IngredientMapper} extension point allows for the data to be mapped
-     * into the {@link IngredientModel} and the {@link IngredientModel.data} property to be augmented with additional properties.
-     *
-     * @example
-     * The following example shows how to map the data from the service response into the {@link IngredientModel}.
-     * The context is provided by the {@link IngredientLoader} extension point with its data being used to optionally augment the
-     * ingredient data.
-     *
-     * The result of the mapping will be available in the `data` property of the {@link IngredientModel}.
-     *
-     * In this case the `IngedientReponseData` interface represents the data being returned by the ingredient service and the
-     * `IngredientData` interface represents the data that will be available in the {@link IngredientModel.data} property.  The `ingredientDataMapper`
-     * is responsible for mapping from one format to the other.
-     *
-     * ```typescript
-     *
-     * interface IngredientResponseData extends NozzleServices.IngredientResponse {
-     *   chilled: boolean;
-     *   carbonated: boolean;
-     *   highYield: boolean;
-     * }
-     *
-     * interface IngredientData {
-     *   chilled: boolean;
-     *   carbonated: boolean;
-     *   highYield: boolean;
-     * }
-     *
-     * export const ingredientDataMapper = async (
-     * data: IngredientResponseData,
-     * context: IngredientContext
-     * ): Promise<IngredientData> => {
-     *  return {
-     *    chilled: data.chilled,
-     *    carbonated: data.carbonated,
-     *    highYield: data.highYield,
-     *  }
-     * }
-     * ```
-     * */
+     * Maps ingredient service data into the `data` property of the {@link IngredientModel}, for properties the
+     * base model does not carry. Register with {@link DispenseExtensionManager.registerIngredientDataMapper}.
+     */
     IngredientMapper = "kos.ingredient.mapper",
     IngredientIndex = "kos.ingredient.index",
     /**
@@ -89,127 +30,22 @@ export declare enum ExtensionType {
      * */
     HolderIngredientMapper = "kos.holder.ingredient.mapper",
     /**
-     * Maps data into the {@link AvailabilityModel}
-     *
-     * @example
-     * The following example shows how to map the data from the service response into the {@link AvailabilityModel}.
-     * The context is provided by the {@link AvailabilityLoader} extension point with its data being used to augment the
-     * availability data.
-     *
-     * The result of the mapping will be available in the `data` property of the {@link AvailabilityModel}.
-     *
-     * ```typescript
-     * export const beverageDataMapper = async (
-     * data: NozzleServices.BeverageResponse,
-     * context: BeverageContext
-     * ): Promise<BeverageData> => {
-     *  const id = data.altId;
-     *  const iconUrl = encodeURI(
-     *    `http://localhost:8081/system/brandset/${context?.[id]?.icon}`
-     *  );
-     *  const cuiColorCode = context?.[id]?.cuiColorCode
-     *    ? context?.[id]?.cuiColorCode
-     *    : '';
-     *  return { iconUrl, cuiColorCode };
-     * };
-     * ```
-     * */
+     * Maps availability service data into the `data` property of the {@link AvailabilityModel}. Register with
+     * {@link DispenseExtensionManager.registerAvailabilityDataMapper}.
+     */
     AvailabilityMapper = "kos.availability.mapper",
     /**
-     * Loads data that will be provided as context into the {@link AvailabilityMapper}
-     *
-     * @example
-     * A common use case is to load brandset data that is UI specific and not provided directly by the Java service.
-     *
-     * The following example shows how to load the brandset data, normalize it into a map and then provide it back to the framework
-     * where it can be used by the other extension points.
-     *
-     * In the nozzle model, the data is provided to the {@link AvailabilityMapper} extension point in order to augment availability data
-     * and also loaded into the nozzle model context in order to make the data available throughout the code.
-     *
-     * ```typescript
-     *  export const beverageContextLoader = async (): Promise<BeverageContext> => {
-     *  const response = await kosFetch('kos:/system/brandset/brandset.json');
-     *
-     *   if (response.status !== 200) {
-     *     KosLog.error('Failed to load beverage data');
-     *       return {};
-     *   }
-     *   const json: BrandsetResponse | null = await response.json();
-     *   const initialBeverages: Record<string, BrandsetIngredient> = {};
-     *   const beverages = json?.ingredients?.reduce((acc, beverage) => {
-     *     acc[beverage.ingredientId] = beverage;
-     *     return acc;
-     *   }, initialBeverages);
-     *  return beverages;
-     *  };
-     * ```
-     * */
+     * Loads data that is passed as context to the {@link AvailabilityMapper}, such as UI-specific brandset data.
+     * Register with {@link DispenseExtensionManager.registerAvailabilityLoader}.
+     */
     AvailabilityLoader = "kos.availability.loader",
     /**
      * Maps the abstract {@link SelectedPourable} data into a format that is specific to the nozzle.
      * */
     SelectedPourableMapper = "kos.selected.pourable.mapper",
     /**
-     * Maps data into the {@link AssemblyModel} data.
-     * Used in cases where the base assembly has been extended with additional properties in the backend.  This extension
-     * point allows for the data to be mapped into the {@link AssemblyModel} and augmented with additional properties.
-     *
-     * @example
-     *
-     * In this example of an implementation of a {@link AssemblyMapper}, the {@link AssemblyResponse} data is mapped into
-     * a {@link FreestyleAssembly} object.
-     *
-     * The {@link FreestyleAssemblyResponse} interface represents the additional data being returned by the assembly service and is
-     * merged into the {@link AssemblyResponse} interface.
-     *
-     * The {@link FreestyleAssembly} interface represents the additional data, beyond the base data set, that will be merged into the {@link AssemblyModel}.
-     *
-     * The mapper is responsible for mapping from the {@link FreestyleAssemblyResponse} format to the {@link FreestyleAssembly} format.
-     * ```typescript
-     *  import { AssemblyTypes } from "@kosdev-code/kos-dispense-sdk";
-     *  import { DataMapper } from "@kosdev-code/kos-ui-sdk";
-     *
-     *  // define the additional data being returned by the assembly service
-     *  export interface FreestyleAssemblyResponse {
-     *    iceAgitator?: {
-     *      name: "iceAgitator";
-     *      path: string;
-     *    };
-     *  }
-     *
-     *  // define the additional data structure that will be merged into the assembly model
-     *  export interface FreestyleAssembly {
-     *    iceAgitator: {
-     *      path: string;
-     *    };
-     *    carbAgitator: {
-     *      path: string;
-     *    };
-     *  }
-     *
-     *
-     *  // define the mapper that will map the data from the service response into the additional data structure
-     *  // that will be merged into the assembly model.
-     *  // In this case the mapper is responsible for mapping from the {@link FreestyleAssemblyResponse} format to the {@link FreestyleAssembly} format.
-     *  export const assemblyDataMapper: DataMapper<
-     *    AssemblyTypes.AssemblyResponse<FreestyleAssemblyResponse>,
-     *    FreestyleAssembly
-     *    > = async (data) => {
-     *    const response = data.assemblies.reduce((acc, assembly) => {
-     *      const agitatorKeys = ["iceAgitator", "carbAgitator"];
-     *      agitatorKeys.forEach((key) => {
-     *        const agitator = assembly[key];
-     *        if (agitator) {
-     *          acc[key] = agitator;
-     *        }
-     *      });
-     *
-     *      return acc;
-     *    }, {} as FreestyleAssembly);
-     *    return response;
-     *  };
-     *```
+     * Maps additional assembly response properties into the {@link AssemblyModel}, for backends that extend the
+     * base assembly. Register with {@link DispenseExtensionManager.registerAssemblyDataMapper}.
      */
     AssemblyMapper = "kos.assembly.mapper",
     BoardMapper = "kos.board.mapper",

package/models/constants/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-dispense-sdk/src/models/constants/constants.ts"],"names":[],"mappings":"AAAA;;KAEK;AACL,oBAAY,aAAa;IACvB;;;;;;;;;;;;;;;;;;;;;;SAsBK;IACL,gBAAgB,0BAA0B;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA2CK;IACL,gBAAgB,0BAA0B;IAE1C,eAAe,yBAAyB;IACxC;;SAEK;IACL,oBAAoB,+BAA+B;IAEnD;;SAEK;IACL,gBAAgB,2BAA2B;IAE3C,YAAY,sBAAsB;IAElC,WAAW,qBAAqB;IAChC;;;;SAIK;IACL,sBAAsB,iCAAiC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;SAyBK;IACL,kBAAkB,4BAA4B;IAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA6BK;IACL,kBAAkB,4BAA4B;IAE9C;;SAEK;IACL,sBAAsB,iCAAiC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4DG;IACH,cAAc,wBAAwB;IACtC,WAAW,qBAAqB;IAChC,UAAU,oBAAoB;IAC9B,SAAS,mBAAmB;IAC5B,oBAAoB,+BAA+B;CACpD;AAED,oBAAY,iBAAiB;IAC3B,MAAM,iBAAiB;IACvB,YAAY,uBAAuB;IACnC,MAAM,iBAAiB;IACvB,eAAe,2BAA2B;IAC1C,mBAAmB,+BAA+B;IAClD,UAAU,qBAAqB;IAC/B,IAAI,eAAe;IACnB,aAAa,yBAAyB;CACvC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-dispense-sdk/src/models/constants/constants.ts"],"names":[],"mappings":"AAAA;;KAEK;AACL,oBAAY,aAAa;IACvB;;;OAGG;IACH,gBAAgB,0BAA0B;IAE1C;;;OAGG;IACH,gBAAgB,0BAA0B;IAE1C,eAAe,yBAAyB;IACxC;;SAEK;IACL,oBAAoB,+BAA+B;IAEnD;;SAEK;IACL,gBAAgB,2BAA2B;IAE3C,YAAY,sBAAsB;IAElC,WAAW,qBAAqB;IAChC;;;;SAIK;IACL,sBAAsB,iCAAiC;IAEvD;;;OAGG;IACH,kBAAkB,4BAA4B;IAE9C;;;OAGG;IACH,kBAAkB,4BAA4B;IAE9C;;SAEK;IACL,sBAAsB,iCAAiC;IAEvD;;;OAGG;IACH,cAAc,wBAAwB;IACtC,WAAW,qBAAqB;IAChC,UAAU,oBAAoB;IAC9B,SAAS,mBAAmB;IAC5B,oBAAoB,+BAA+B;CACpD;AAED,oBAAY,iBAAiB;IAC3B,MAAM,iBAAiB;IACvB,YAAY,uBAAuB;IACnC,MAAM,iBAAiB;IACvB,eAAe,2BAA2B;IAC1C,mBAAmB,+BAA+B;IAClD,UAAU,qBAAqB;IAC/B,IAAI,eAAe;IACnB,aAAa,yBAAyB;CACvC"}

package/models/models/assembly/assembly-registration.d.ts

@@ -1,80 +1,20 @@
 import { SingletonKosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
 import { AssemblyModel, AssemblyOptions } from './types';
 /**
- * # Assembly
+ * Registration bean for {@link AssemblyModel}.
  *
- * The registration bean includes convenience methods for creating and working with AssemblyModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `Assembly.factory(options)` returns the single instance, creating it on the first call.
+ * - `predicate`: type guard that narrows an `IKosDataModel` to `AssemblyModel`.
+ * - `registration`: registry entry that can be spread into an `IKosRegistry["models"]` map.
  *
- * ## type
- * The type property is a string that identifies the model type.
- * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
- * used when declaring dependencies on models.
+ * Assembly is a singleton. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: Assembly.type, id: "assemblyId"})
- * private assemblyModel: AssemblyModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new AssemblyModel instances.
- *
- 
- * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
- *
- * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- * ```typescript
- * const model = Assembly.factory("assemblyId")({
- *   // Add option data
- * });
- * ```
- 
-
- *
- * ## predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a AssemblyModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (Assembly.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to AssemblyModel
- *    // and the compiler will know that the model has the AssemblyModel interface
- *    model.updateAvailability(false);
- * }
- * ```
- *
- * ## registration
- *
- * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
- * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
- *
- *
- * @example
- *
- * In an application registration file you can declare the model registration as follows:
- *
- * **registration.ts**
- * ```typescript
- * import { Assembly } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...Assembly.registration,
- * };
+ * @kosDependency({ modelType: Assembly.type })
+ * private assembly!: AssemblyModel;
  * ```
- *
- * ## registration.singleton
- * The assembly model is a singleton model.  This means that each time the factory function the same instance of the model will be returned.
- * */
+ */
 export declare const Assembly: Readonly<SingletonKosModelRegistrationBean<AssemblyModel, AssemblyOptions>>;
 //# sourceMappingURL=assembly-registration.d.ts.map

package/models/models/assembly/assembly-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assembly-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/assembly/assembly-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAGjF,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2EK;AACL,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAC7B,iCAAiC,CAAC,aAAa,EAAE,eAAe,CAAC,CAWlE,CAAC"}
+{"version":3,"file":"assembly-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/assembly/assembly-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAGjF,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAC7B,iCAAiC,CAAC,aAAa,EAAE,eAAe,CAAC,CAWlE,CAAC"}

package/models/models/availability/availability-model.d.ts

@@ -1,88 +1,22 @@
 import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
 import { AvailabilityModel, AvailabilityOptions } from './types';
 /**
- * # Availability
+ * Registration bean for {@link AvailabilityModel}.
  *
- * The registration bean includes convenience methods for creating and working with AvailabilityModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `Availability.factory(id)(options)`. Returns the existing model when the id is already in use and ignores the options.
+ * - `predicate`: type guard that narrows an `IKosDataModel` to `AvailabilityModel`.
+ * - `registration`: registry entry that can be spread into an `IKosRegistry["models"]` map.
  *
- * ## type
- * The type property is a string that identifies the model type.
- * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
- * used when declaring dependencies on models.
+ * Availability is not a singleton: each id has its own instance. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: Availability.type, id: "beverageId"})
- * private beverageModel: AvailabilityModel;
- * ```
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new AvailabilityModel instances.
- *
- * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
- *
- * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- *
- * ```typescript
- * const cherryFlavor = Availability.factory("beverageId")({
- *  groupId: "flavor",
- *  rawId: "cherry",
- *  altId: "cherry",
- *  available: true,
- *  visible: true,
- *  // this data is added via extension point
- *  data: {
- *    name: "Cherry",
- *    description: "Cherry flavor",
- *   },
- *  });
- * ```
- *
- * @param predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a AvailabilityModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (Availability.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to AvailabilityModel
- *    // and the compiler will know that the model has the AvailabilityModel interface
- *    model.updateAvailability(false);
- * }
- * ```
- *
- * ## registration
- *
- * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
- * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
- *
- *
- * @example
- *
- * In an application registration file you can declare the model registration as follows:
- *
- * **registration.ts**
- * ```typescript
- * import { Availability } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...Availability.registration,
- * };
+ * @kosDependency({ modelType: Availability.type, id: "availabilityId" })
+ * private availability!: AvailabilityModel;
  * ```
  *
- * ## registration.singleton
- *
- * The beverage model is not a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
- * If the factory function is called with an ID that already exists, the existing model will be returned.
- * */
+ * @param predicate Type guard that narrows an `IKosDataModel` to `AvailabilityModel`.
+ */
 export declare const Availability: Readonly<KosModelRegistrationBean<AvailabilityModel, AvailabilityOptions>>;
 //# sourceMappingURL=availability-model.d.ts.map

package/models/models/availability/availability-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"availability-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/availability/availability-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,wBAAwB,EAC9B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAoEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmFK;AACL,eAAO,MAAM,YAAY,EAAE,QAAQ,CACjC,wBAAwB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAgBjE,CAAC"}
+{"version":3,"file":"availability-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/availability/availability-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,wBAAwB,EAC9B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAoEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CACjC,wBAAwB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAgBjE,CAAC"}

package/models/models/availability/types/index.d.ts

@@ -32,20 +32,11 @@ export interface AvailabilityOptions<
   properties?: Properties;
 }
 /**
- *
- *
  * Represents the nodes of the Beverage Availability graph for a nozzle.
  *
- * @typeParam AdditionalData - Any additional data that is added to a node at the application layer.
- *
- * @example The base GraphNode from the backend will have an id, type, available and visible properties.  However,
- * a given implementation might extend the Beverage Graph node to include additional data, such as the beverage name or
- * an image url.  This additional data would be added to the node and would be represented by the AdditionalData type parameter.
- * ```typescript
- * const model: AvailabilityModel<{icon: string}> = ...;
- * ```
- * would allow for visibility of all the base properties as well as the additional data (icon) that might be on the message payload from
- * the backend.
+ * @typeParam AdditionalData - Application data added to a node by the
+ * {@link ExtensionType.AvailabilityMapper} extension point, such as a beverage name or image url.
+ * It is exposed on `data`, so `AvailabilityModel<{ icon: string }>` types `model.data.icon`.
  *
  * @category Model
  */

package/models/models/board/board-container-registration.d.ts

@@ -2,85 +2,20 @@ import { SingletonKosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
 import { BoardContainerModel } from './board-container-model';
 import { BoardContainerOptions } from './types';
 /**
- * # BoardContainer
+ * Registration bean for {@link BoardContainerModel}.
  *
- * The registration bean includes convenience methods for creating and working with BoardContainerModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `BoardContainer.factory(options)` returns the single instance, creating it on the first call.
+ * - `predicate`: type guard that narrows an `IKosDataModel` to `BoardContainerModel`.
+ * - `registration`: registry entry that can be spread into an `IKosRegistry["models"]` map.
  *
- * ## type
- * The type property is a string that identifies the model type.
- * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
- * used when declaring dependencies on models.
+ * BoardContainer is a singleton. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: BoardContainer.type, id: "boardContainerId"})
- * private boardContainerModel: BoardContainerModel;
+ * @kosDependency({ modelType: BoardContainer.type })
+ * private boardContainer!: BoardContainerModel;
  * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new BoardContainerModel instances.
- *
- 
- * As this is a singleton model, the factory function accepts the model options as its argument.
- *
- * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- * ```typescript
- * const model = BoardContainer.factory({
- *   // Add option data
- * });
- * ```
- 
-
- *
- * ## predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a BoardContainerModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (BoardContainer.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to BoardContainerModel
- *    // and the compiler will know that the model has the BoardContainerModel interface
- *    model.updateAvailability(false);
- * }
- * ```
- *
- * ## registration
- *
- * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
- * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
- *
- *
- * @example
- *
- * In an application registration file you can declare the model registration as follows:
- *
- * **registration.ts**
- * ```typescript
- * import { BoardContainer } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...BoardContainer.registration,
- * };
- * ```
- *
- * ## registration.singleton
- 
- * The boardContainer model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
- * If the model does not yet exist, it will be created passing in the provided options to initialize it.
- *
- * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
- 
- * */
+ */
 export declare const BoardContainer: Readonly<SingletonKosModelRegistrationBean<BoardContainerModel, BoardContainerOptions>>;
 //# sourceMappingURL=board-container-registration.d.ts.map

package/models/models/board/board-container-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"board-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/board/board-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAEjF,OAAO,EAAE,mBAAmB,EAAc,MAAM,yBAAyB,CAAC;AAE1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,cAAc,EAAE,QAAQ,CACnC,iCAAiC,CAAC,mBAAmB,EAAE,qBAAqB,CAAC,CAc9E,CAAC"}
+{"version":3,"file":"board-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/board/board-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAEjF,OAAO,EAAE,mBAAmB,EAAc,MAAM,yBAAyB,CAAC;AAE1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CACnC,iCAAiC,CAAC,mBAAmB,EAAE,qBAAqB,CAAC,CAc9E,CAAC"}