@kosdev-code/kos-dispense-sdk 0.1.0-dev.5873 → 0.1.0-next.1000

package/index.js

@@ -1,119 +1,139 @@
 import { registerApiLevels } from "@kosdev-code/kos-api-levels";
-import { A, b, e, d, B, C, a, p, f, D, o, q, E, G, H, j, I, k, K, N, n, P, l, m, T, c, g, h, i, o as o2, r } from "./dispense-registration-manager-C4XZ_c3x.js";
-import { i as i2, f as f2, D as D2, a as a2, b as b2, c as c2, K as K2, d as d2, e as e2, g as g2 } from "./extension-utils-FxS68Xu9.js";
-import { A as A2, a as a3, d as d3, B as B2, f as f3, C as C2, G as G2, F, J, D as D3, a4, a5, j as j2, H as H2, m as m2, I as I2, N as N2, ab, P as P2, a6, a7, a8, i as i3, q as q2, u, r as r2, b as b3, z, t, x, e as e3, c as c3, E as E2, K as K3, O, L, R, g as g3, M, Q, a9, T as T2, V, k as k2, h as h2, X, _, n as n2, l as l2, Y, a0, o as o3, a2 as a22, a3 as a32, p as p2, w, s, v, y, S, aa, U, W, Z, $, a1 } from "./pump-provider-9rUgev7q.js";
-import "@kosdev-code/kos-ui-plugin/utilities";
-import "@kosdev-code/kos-ui-sdk";
-import "react";
-import "@emotion/react/jsx-runtime";
-registerApiLevels({ "kos-dispense-sdk": 16 });
+import { createExtensionSchema, extensionPointId, defineExtensionPoint, createViewAwareTransform, validateWithSchema } from "@kosdev-code/kos-ui-plugin/utilities";
+import { A, a, B, b, c, C, d, e, D, f, q, E, G, H, g, I, h, K, N, P, i, j, k, l, T, m, n, o, p, q as q2, r, s } from "./dispense-registration-manager-DtN0T_JG.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-BoXtjU5_.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, T as T2, k as k2, l as l2, m as m2, u, n as n2, o as o2, p as p2, q as q3, r as r2, s as s2, 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 } from "./pump-provider-CPUsLke5.js";
+const ControlPourSchema = createExtensionSchema({}, { rankable: false });
+const EXTENSION_ID = extensionPointId("cui", "control", "pour");
+const ControlPourExtension = defineExtensionPoint({
+  id: EXTENSION_ID,
+  contributionKey: "controlPour",
+  displayName: "Control Pour",
+  description: "Extension point for controlled pour plugin configurations with view support",
+  hasView: true,
+  isRankable: false,
+  schema: ControlPourSchema,
+  metadata: {
+    exportName: "ControlPourExtension",
+    category: "Dispense",
+    tags: ["pour", "control", "beverage"]
+  },
+  validate: (data, context) => {
+    validateWithSchema(ControlPourSchema, data, context);
+  },
+  transform: createViewAwareTransform()
+});
+const EXTENSION_POINT_CONTROL_POUR = EXTENSION_ID;
+registerApiLevels({ "kos-dispense-sdk": 17 });
 export {
   A as Assembly,
   A2 as AssemblyProvider,
   i2 as AssemblyServices,
-  f2 as AssemblyTypes,
-  b as Availability,
+  a2 as AssemblyTypes,
+  a as Availability,
   a3 as AvailabilityProvider,
-  e as Board,
-  d as BoardContainer,
-  B as BoardContainerModel,
-  d3 as BoardContainerProvider,
-  B2 as BoardProvider,
+  B as Board,
+  b as BoardContainer,
+  c as BoardContainerModel,
+  B2 as BoardContainerProvider,
+  b3 as BoardProvider,
   C as CONTEXT_ASSEMBLY_DATA,
-  a as CONTEXT_ASSEMBLY_RAW_DATA,
-  p as ControlPourExtension,
-  f3 as CuiKit,
-  C2 as CuiKitWrapper,
-  G2 as DISPENSE_GROUP_BEVERAGE,
-  F as DISPENSE_GROUP_BRAND,
-  J as DISPENSE_GROUP_FLAVOR,
-  f as DeviceAssembly,
-  D3 as DeviceAssemblyProvider,
+  d as CONTEXT_ASSEMBLY_RAW_DATA,
+  ControlPourExtension,
+  C2 as CuiKit,
+  e as CuiKitState,
+  c3 as CuiKitWrapper,
+  D3 as DISPENSE_GROUP_BEVERAGE,
+  d3 as DISPENSE_GROUP_BRAND,
+  e3 as DISPENSE_GROUP_FLAVOR,
+  D as DeviceAssembly,
+  f3 as DeviceAssemblyProvider,
   D2 as DispenseExtensionManager,
-  D as DispenseModelType,
-  o as DispenserModels,
-  q as EXTENSION_POINT_CONTROL_POUR,
+  f as DispenseModelType,
+  q as DispenserModels,
+  EXTENSION_POINT_CONTROL_POUR,
   E as ExtensionType,
   G as GenericPour,
-  a2 as GenericPourServices,
-  a4 as HoldToPourIntentStrategy,
-  a5 as HoldToPourStrategy,
+  b2 as GenericPourServices,
+  H2 as HoldToPourIntentStrategy,
+  g3 as HoldToPourStrategy,
   H as Holder,
-  j as HolderContainer,
-  j2 as HolderContainerProvider,
-  H2 as HolderProvider,
-  b2 as HolderServices,
+  g as HolderContainer,
+  h2 as HolderContainerProvider,
+  i3 as HolderProvider,
+  c2 as HolderServices,
   I as Ingredient,
-  k as IngredientContainer,
-  m2 as IngredientContainerProvider,
-  I2 as IngredientProvider,
-  c2 as IngredientServices,
+  h as IngredientContainer,
+  I2 as IngredientContainerProvider,
+  j2 as IngredientProvider,
+  d2 as IngredientServices,
   K2 as KosExtensionManager,
   K as KosModelRegistry,
   N as Nozzle,
   N2 as NozzleProvider,
-  d2 as NozzleServices,
-  ab as PourContext,
-  n as PourState,
-  P as Pump,
-  l as PumpContainer,
-  m as PumpIndex,
+  e2 as NozzleServices,
+  P as PourContext,
+  i as PourState,
+  j as Pump,
+  k as PumpContainer,
+  l as PumpIndex,
   P2 as PumpProvider,
-  e2 as PumpServices,
+  f2 as PumpServices,
   T as TOPIC_BOARD_LINKED,
-  c as TOPIC_BOARD_UNLINKED,
-  g as TOPIC_GENERIC_POUR_CANCEL,
-  h as TOPIC_GENERIC_POUR_PROGRESS,
-  i as TOPIC_GENERIC_POUR_STARTED,
-  a6 as TapOrHoldIntentStrategy,
-  a7 as TapToPourIntentStrategy,
-  a8 as TapToPourStrategy,
+  m as TOPIC_BOARD_UNLINKED,
+  n as TOPIC_GENERIC_POUR_CANCEL,
+  o as TOPIC_GENERIC_POUR_PROGRESS,
+  p as TOPIC_GENERIC_POUR_STARTED,
+  T2 as TapOrHoldIntentStrategy,
+  k2 as TapToPourIntentStrategy,
+  l2 as TapToPourStrategy,
   g2 as getFuelGaugeValue,
-  i3 as initializeCuiKit,
-  o2 as kosModels,
-  r as registerDispenseModels,
-  q2 as useAssembly,
-  u as useAssemblyContext,
-  r2 as useAvailability,
-  b3 as useAvailabilityContext,
-  z as useBeverages,
-  t as useBoard,
-  x as useBoardContainer,
-  e3 as useBoardContainerContext,
-  c3 as useBoardContext,
-  E2 as useBrands,
-  K3 as useCuiKit,
-  O as useCuiKitTimers,
-  L as useDefaultCuiKitLifecycle,
-  R as useDeviceAssembly,
-  g3 as useDeviceAssemblyContext,
-  M as useDispenseLifecycle,
-  Q as useFlavors,
-  a9 as useGenericPour,
-  T2 as useHolder,
-  V as useHolderContainer,
-  k2 as useHolderContainerContext,
-  h2 as useHolderContext,
-  X as useIngredient,
-  _ as useIngredientContainer,
-  n2 as useIngredientContainerContext,
-  l2 as useIngredientContext,
-  Y as useIngredientPour,
-  a0 as useNozzle,
-  o3 as useNozzleContext,
-  a22 as useNozzlePour,
-  a32 as usePourTarget,
-  p2 as usePumpContext,
-  w as withAssembly,
-  s as withBeverage,
-  v as withBoard,
-  y as withBoardContainer,
-  S as withDeviceAssembly,
-  aa as withGenericPour,
-  U as withHolder,
-  W as withHolderContainer,
-  Z as withIngredient,
-  $ as withIngredientContainer,
-  a1 as withNozzle
+  m2 as initializeCuiKit,
+  q2 as kosModels,
+  r as registerCuiKitModels,
+  s as registerDispenseModels,
+  u as useAssembly,
+  n2 as useAssemblyContext,
+  o2 as useAvailability,
+  p2 as useAvailabilityContext,
+  q3 as useBeverages,
+  r2 as useBoard,
+  s2 as useBoardContainer,
+  t as useBoardContainerContext,
+  v as useBoardContext,
+  w as useBrands,
+  x as useCuiKit,
+  y as useCuiKitTimers,
+  z as useDefaultCuiKitLifecycle,
+  E2 as useDeviceAssembly,
+  F as useDeviceAssemblyContext,
+  G2 as useDispenseLifecycle,
+  J as useFlavors,
+  K3 as useGenericPour,
+  L as useHolder,
+  M as useHolderContainer,
+  O as useHolderContainerContext,
+  Q as useHolderContext,
+  R as useIngredient,
+  S as useIngredientContainer,
+  U as useIngredientContainerContext,
+  V as useIngredientContext,
+  W as useIngredientPour,
+  X as useNozzle,
+  Y as useNozzleContext,
+  Z as useNozzlePour,
+  _ as usePourTarget,
+  $ as usePumpContext,
+  a0 as withAssembly,
+  a1 as withBeverage,
+  a22 as withBoard,
+  a32 as withBoardContainer,
+  a4 as withDeviceAssembly,
+  a5 as withGenericPour,
+  a6 as withHolder,
+  a7 as withHolderContainer,
+  a8 as withIngredient,
+  a9 as withIngredientContainer,
+  aa as withNozzle
 };
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../packages/sdk/kos-dispense-sdk/src/index.ts"],"sourcesContent":["import { registerApiLevels } from \"@kosdev-code/kos-api-levels\";\n\n// Registers the package-level API integer for this SDK.\n// The per-service catalog (which services changed and why) lives in\n// kos-api-levels/generated/api-archaeology-report.md, produced by the archaeology scanner.\nregisterApiLevels({ \"kos-dispense-sdk\": 16 });\n\nexport * from \"./extensions\";\nexport * from \"./models\";\nexport { kosModels as DispenserModels } from \"./models\";\nexport * from \"./models/models/generic-pour\";\nexport * from \"./ui\";\n"],"names":[],"mappings":";;;;;;;;AAKA,kBAAkB,EAAE,oBAAoB,IAAI;"}
+{"version":3,"file":"index.js","sources":["../../../packages/kos-dispense-sdk/src/extensions/control-pour-extension.ts","../../../packages/kos-dispense-sdk/src/index.ts"],"sourcesContent":["// eslint-disable-next-line @nx/enforce-module-boundaries\nimport type { ValidationContext } from \"@kosdev-code/kos-ui-plugin/utilities\";\nimport {\n  createExtensionSchema,\n  extensionPointId,\n  createViewAwareTransform,\n  defineExtensionPoint,\n  validateWithSchema,\n} from \"@kosdev-code/kos-ui-plugin/utilities\";\nimport { z } from \"zod\";\n\n// Define the Zod schema for Control Pour contributions\nconst ControlPourSchema = createExtensionSchema({}, { rankable: false });\n\n// Define the control pour types locally\ntype ControlPourDefinition = z.infer<typeof ControlPourSchema>;\n\nconst EXTENSION_ID = extensionPointId(\"cui\", \"control\", \"pour\");\n\n/**\n * Control Pour extension point for beverage dispensing interfaces\n *\n * Allows plugin developers to contribute controlled pour functionality\n * to CUI applications that register this extension point.\n */\nexport const ControlPourExtension = defineExtensionPoint<\n  ControlPourDefinition,\n  ControlPourDefinition\n>({\n  id: EXTENSION_ID,\n  contributionKey: \"controlPour\",\n  displayName: \"Control Pour\",\n  description:\n    \"Extension point for controlled pour plugin configurations with view support\",\n  hasView: true,\n  isRankable: false,\n\n  schema: ControlPourSchema,\n  metadata: {\n    exportName: \"ControlPourExtension\",\n    category: \"Dispense\",\n    tags: [\"pour\", \"control\", \"beverage\"],\n  },\n\n  validate: (data: ControlPourDefinition, context: ValidationContext) => {\n    // Use Zod validation\n    validateWithSchema(ControlPourSchema, data, context);\n  },\n\n  transform: createViewAwareTransform<ControlPourDefinition>(),\n});\n\n// Export constants for backward compatibility\nexport const EXTENSION_POINT_CONTROL_POUR = EXTENSION_ID;\nexport type { ControlPourDefinition };\n","import { registerApiLevels } from \"@kosdev-code/kos-api-levels\";\n\n// Registers the package-level API integer for this SDK.\n// The per-service catalog (which services changed and why) lives in\n// kos-api-levels/generated/api-archaeology-report.md, produced by the archaeology scanner.\nregisterApiLevels({ \"kos-dispense-sdk\": 17 });\n\nexport * from \"./extensions\";\nexport * from \"./models\";\nexport { kosModels as DispenserModels } from \"./models\";\nexport * from \"./models/models/generic-pour\";\nexport * from \"./ui\";\n"],"names":[],"mappings":";;;;;AAYA,MAAM,oBAAoB,sBAAsB,CAAA,GAAI,EAAE,UAAU,OAAO;AAKvE,MAAM,eAAe,iBAAiB,OAAO,WAAW,MAAM;AAQvD,MAAM,uBAAuB,qBAGlC;AAAA,EACA,IAAI;AAAA,EACJ,iBAAiB;AAAA,EACjB,aAAa;AAAA,EACb,aACE;AAAA,EACF,SAAS;AAAA,EACT,YAAY;AAAA,EAEZ,QAAQ;AAAA,EACR,UAAU;AAAA,IACR,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,MAAM,CAAC,QAAQ,WAAW,UAAU;AAAA,EAAA;AAAA,EAGtC,UAAU,CAAC,MAA6B,YAA+B;AAErE,uBAAmB,mBAAmB,MAAM,OAAO;AAAA,EACrD;AAAA,EAEA,WAAW,yBAAA;AACb,CAAC;AAGM,MAAM,+BAA+B;AChD5C,kBAAkB,EAAE,oBAAoB,IAAI;"}

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/sdk/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/constants/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-dispense-sdk/src/models/constants/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-dispense-sdk/src/models/constants/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/sdk/kos-dispense-sdk/src/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,uCAAuC,CAAC;AACtD,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/kos-dispense-sdk/src/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,uCAAuC,CAAC;AACtD,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}

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

@@ -1,11 +1,18 @@
-import { PumpModel } from '../pump';
-import { HolderModel } from '../holder';
-import { BoardModel } from '../board';
-import { AssemblyModel, AssemblyOptions } from './types';
 import { IKosModelLogger, KosContext, KosContextLogger, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
-
+import { AssemblyModel, AssemblyOptions } from './types';
+import { BoardModel } from '../board';
+import { HolderModel } from '../holder';
+import { PumpModel } from '../pump';
 export declare const MODEL_TYPE = "assembly-model";
+/**
+ * @kosService dispense.assembly
+ * @kosApiLevel 2
+ */
 export declare const CONTEXT_ASSEMBLY_DATA = "assembly-data";
+/**
+ * @kosService dispense.assembly
+ * @kosApiLevel 9
+ */
 export declare const CONTEXT_ASSEMBLY_RAW_DATA = "assembly-raw-data";
 /**
  * @kosService dispense.assembly

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

@@ -1 +1 @@
-{"version":3,"file":"assembly-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/assembly/assembly-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,yBAAyB,CAAC;AAcjC,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG9D,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAK7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAMzC,eAAO,MAAM,UAAU,mBAAmB,CAAC;AAC3C,eAAO,MAAM,qBAAqB,kBAAkB,CAAC;AACrD,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAC7D;;;GAGG;AACH,qBACa,iBAAiB,CAC5B,WAAW,SAAS,MAAM,GAAG,GAAG,EAChC,SAAS,SAAS,MAAM,GAAG,GAAG,CAC9B,YAAW,aAAa,CAAC,WAAW,CAAC,EAAE,eAAe;IAEtD,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,YAAY,CAAqB;IAIzC,OAAO,CAAC,gBAAgB,CAAyB;IAEvC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,aAAa,CAAqB;IACpD,MAAM,EAAE,gBAAgB,CAAC;gBAEvB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,kBAAkB;IAS7B,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAI5C,IAAI,UAAU,IAAI,WAAW,CAAC,SAAS,CAAC,EAAE,CAEzC;IAED,IAAI,YAAY,IAAI,MAAM,EAAE,CAE3B;IAED,IAAI,WAAW,IAAI,MAAM,EAAE,CAE1B;IACD,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,SAAS,CAAC,EAAE;IAI1D,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,CAAC,SAAS,CAAC,EAAE;IAIhE;;;;;OAKG;IACH,IAAI,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAEpD;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAED,IAAI,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAE9B;IAIK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,KAAK;IAQL,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAqF/C"}
+{"version":3,"file":"assembly-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/assembly/assembly-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,yBAAyB,CAAC;AAcjC,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG9D,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAK7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAMzC,eAAO,MAAM,UAAU,mBAAmB,CAAC;AAC3C;;;GAGG;AACH,eAAO,MAAM,qBAAqB,kBAAkB,CAAC;AACrD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAC7D;;;GAGG;AACH,qBACa,iBAAiB,CAC5B,WAAW,SAAS,MAAM,GAAG,GAAG,EAChC,SAAS,SAAS,MAAM,GAAG,GAAG,CAC9B,YAAW,aAAa,CAAC,WAAW,CAAC,EAAE,eAAe;IAEtD,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,YAAY,CAAqB;IAIzC,OAAO,CAAC,gBAAgB,CAAyB;IAEvC,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,aAAa,CAAqB;IACpD,MAAM,EAAE,gBAAgB,CAAC;gBAEvB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,kBAAkB;IAS7B,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAI5C,IAAI,UAAU,IAAI,WAAW,CAAC,SAAS,CAAC,EAAE,CAEzC;IAED,IAAI,YAAY,IAAI,MAAM,EAAE,CAE3B;IAED,IAAI,WAAW,IAAI,MAAM,EAAE,CAE1B;IACD,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,SAAS,CAAC,EAAE;IAI1D,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,CAAC,SAAS,CAAC,EAAE;IAIhE;;;;;OAKG;IACH,IAAI,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAEpD;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAED,IAAI,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAE9B;IAIK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,KAAK;IAQL,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAqF/C"}

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

@@ -1,81 +1,22 @@
-import { AssemblyModel, AssemblyOptions } from './types';
 import { SingletonKosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
-
+import { AssemblyModel, AssemblyOptions } from './types';
 /**
- * # Assembly
- *
- * The registration bean includes convenience methods for creating and working with AssemblyModel instances.
- *
- * ## 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.
- *
- * @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
- * });
- * ```
- 
-
+ * Registration bean for {@link AssemblyModel}.
  *
- * ## predicate
+ * - `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.
  *
- * [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.
+ * Assembly is a singleton. `KosModelRegistry.dispense.models()` registers it.
  *
  * @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);
- * }
+ * @kosDependency({ modelType: Assembly.type })
+ * private assembly!: AssemblyModel;
  * ```
- *
- * ## 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,
- * };
- * ```
- *
- * ## 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.
- * */
+ * @kosService dispense.assembly
+ * @kosApiLevel 2
+ */
 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/sdk/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;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAC7B,iCAAiC,CAAC,aAAa,EAAE,eAAe,CAAC,CAWlE,CAAC"}

package/models/models/assembly/board-utils.d.ts

@@ -1,6 +1,5 @@
-import { AssemblyBoard } from '../types/assembly';
 import { BoardContainerModel } from '../board';
-
+import { AssemblyBoard } from '../types/assembly';
 export declare const mapAssemblyBoardToModel: <AssemblyBoardResponseExt extends object = any, BoardExt extends object = any>(board: AssemblyBoard<AssemblyBoardResponseExt>) => Promise<import('../board').BoardModel<{}>>;
 export declare const assemblyBoardMap: (boardContainer: BoardContainerModel) => (board: AssemblyBoard) => Promise<void>;
 //# sourceMappingURL=board-utils.d.ts.map

package/models/models/assembly/board-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"board-utils.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/assembly/board-utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,KAAK,mBAAmB,EAAqB,MAAM,UAAU,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,eAAO,MAAM,uBAAuB,wFAI3B,cAAc,wBAAwB,CAAC,+CA0B/C,CAAC;AAEF,eAAO,MAAM,gBAAgB,mBACV,mBAAmB,aAAmB,aAAa,kBAInE,CAAC"}
+{"version":3,"file":"board-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/assembly/board-utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,KAAK,mBAAmB,EAAqB,MAAM,UAAU,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAMvD,eAAO,MAAM,uBAAuB,GAClC,wBAAwB,SAAS,MAAM,GAAG,GAAG,EAC7C,QAAQ,SAAS,MAAM,GAAG,GAAG,EAE7B,OAAO,aAAa,CAAC,wBAAwB,CAAC,+CA0B/C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC1B,gBAAgB,mBAAmB,MAAY,OAAO,aAAa,kBAInE,CAAC"}

package/models/models/assembly/holder-utils.d.ts

@@ -1,5 +1,4 @@
-import { AssemblyHolder } from '../types/assembly';
 import { HolderModel } from '../holder/types';
-
+import { AssemblyHolder } from '../types/assembly';
 export declare const mapAssemblyHolderToModel: <AssemblyHolderResponseExt extends object = any, HolderExt extends object = any>(group: string, holderData: AssemblyHolder<AssemblyHolderResponseExt>) => Promise<HolderModel<HolderExt>>;
 //# sourceMappingURL=holder-utils.d.ts.map