@kosdev-code/kos-dispense-sdk 0.1.0-dev.5053

package/index.js

@@ -0,0 +1,133 @@
+import { A as y, b as A, e as I, d as E, B as x, C as S, a as T, f as D, D as N, l as b, E as B, G as h, H as _, g as O, I as f, h as w, K as z, N as H, k as K, P as R, i as G, j as M, T as L, c as U, l as V, r as k } from "./dispense-registration-manager-CB_nSTZw.js";
+import { i as F, f as W, D as Y, a as j, b as q, c as J, K as Q, d as Z, e as $, g as ee } from "./extension-utils-CkYqorcG.js";
+import { A as ae, a as oe, d as re, B as te, f as ie, C as ne, G as ue, F as le, J as de, D as Pe, a4 as Ce, a5 as ce, j as pe, H as me, m as ge, I as ve, N as ye, ab as Ae, P as Ie, a6 as Ee, a7 as xe, a8 as Se, i as Te, q as De, u as Ne, r as be, b as Be, z as he, t as _e, x as Oe, e as fe, c as we, E as ze, K as He, O as Ke, L as Re, R as Ge, g as Me, M as Le, Q as Ue, a9 as Ve, T as ke, V as Xe, k as Fe, h as We, X as Ye, _ as je, n as qe, l as Je, Y as Qe, a0 as Ze, o as $e, a2 as es, a3 as ss, p as as, w as os, s as rs, v as ts, y as is, S as ns, aa as us, U as ls, W as ds, Z as Ps, $ as Cs, a1 as cs } from "./pump-provider-DSyiDoPF.js";
+import { createExtensionSchema as r, extensionPointId as t, defineExtensionPoint as i, createViewAwareTransform as n, validateWithSchema as u } from "@kosdev-code/kos-ui-plugin/utilities";
+import "@kosdev-code/kos-ui-sdk";
+import "react";
+import "@emotion/react/jsx-runtime";
+import "@kosdev-code/kos-dispense-sdk";
+const e = r({}, { rankable: !1 }), s = t("cui", "control", "pour"), p = i({
+  id: s,
+  contributionKey: "controlPour",
+  displayName: "Control Pour",
+  description: "Extension point for controlled pour plugin configurations with view support",
+  hasView: !0,
+  isRankable: !1,
+  schema: e,
+  metadata: {
+    exportName: "ControlPourExtension",
+    category: "Dispense",
+    tags: ["pour", "control", "beverage"]
+  },
+  validate: (a, o) => {
+    u(e, a, o);
+  },
+  transform: n()
+}), m = s;
+export {
+  y as Assembly,
+  ae as AssemblyProvider,
+  F as AssemblyServices,
+  W as AssemblyTypes,
+  A as Availability,
+  oe as AvailabilityProvider,
+  I as Board,
+  E as BoardContainer,
+  x as BoardContainerModel,
+  re as BoardContainerProvider,
+  te as BoardProvider,
+  S as CONTEXT_ASSEMBLY_DATA,
+  T as CONTEXT_ASSEMBLY_RAW_DATA,
+  p as ControlPourExtension,
+  ie as CuiKit,
+  ne as CuiKitWrapper,
+  ue as DISPENSE_GROUP_BEVERAGE,
+  le as DISPENSE_GROUP_BRAND,
+  de as DISPENSE_GROUP_FLAVOR,
+  D as DeviceAssembly,
+  Pe as DeviceAssemblyProvider,
+  Y as DispenseExtensionManager,
+  N as DispenseModelType,
+  b as DispenserModels,
+  m as EXTENSION_POINT_CONTROL_POUR,
+  B as ExtensionType,
+  h as GenericPour,
+  j as GenericPourServices,
+  Ce as HoldToPourIntentStrategy,
+  ce as HoldToPourStrategy,
+  _ as Holder,
+  O as HolderContainer,
+  pe as HolderContainerProvider,
+  me as HolderProvider,
+  q as HolderServices,
+  f as Ingredient,
+  w as IngredientContainer,
+  ge as IngredientContainerProvider,
+  ve as IngredientProvider,
+  J as IngredientServices,
+  Q as KosExtensionManager,
+  z as KosModelRegistry,
+  H as Nozzle,
+  ye as NozzleProvider,
+  Z as NozzleServices,
+  Ae as PourContext,
+  K as PourState,
+  R as Pump,
+  G as PumpContainer,
+  M as PumpIndex,
+  Ie as PumpProvider,
+  $ as PumpServices,
+  L as TOPIC_BOARD_LINKED,
+  U as TOPIC_BOARD_UNLINKED,
+  Ee as TapOrHoldIntentStrategy,
+  xe as TapToPourIntentStrategy,
+  Se as TapToPourStrategy,
+  ee as getFuelGaugeValue,
+  Te as initializeCuiKit,
+  V as kosModels,
+  k as registerDispenseModels,
+  De as useAssembly,
+  Ne as useAssemblyContext,
+  be as useAvailability,
+  Be as useAvailabilityContext,
+  he as useBeverages,
+  _e as useBoard,
+  Oe as useBoardContainer,
+  fe as useBoardContainerContext,
+  we as useBoardContext,
+  ze as useBrands,
+  He as useCuiKit,
+  Ke as useCuiKitTimers,
+  Re as useDefaultCuiKitLifecycle,
+  Ge as useDeviceAssembly,
+  Me as useDeviceAssemblyContext,
+  Le as useDispenseLifecycle,
+  Ue as useFlavors,
+  Ve as useGenericPour,
+  ke as useHolder,
+  Xe as useHolderContainer,
+  Fe as useHolderContainerContext,
+  We as useHolderContext,
+  Ye as useIngredient,
+  je as useIngredientContainer,
+  qe as useIngredientContainerContext,
+  Je as useIngredientContext,
+  Qe as useIngredientPour,
+  Ze as useNozzle,
+  $e as useNozzleContext,
+  es as useNozzlePour,
+  ss as usePourTarget,
+  as as usePumpContext,
+  os as withAssembly,
+  rs as withBeverage,
+  ts as withBoard,
+  is as withBoardContainer,
+  ns as withDeviceAssembly,
+  us as withGenericPour,
+  ls as withHolder,
+  ds as withHolderContainer,
+  Ps as withIngredient,
+  Cs as withIngredientContainer,
+  cs as withNozzle
+};
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../packages/sdk/kos-dispense-sdk/src/extensions/control-pour-extension.ts"],"sourcesContent":["// eslint-disable-next-line @nx/enforce-module-boundaries\nimport {\n  createExtensionSchema,\n  createViewAwareTransform,\n  defineExtensionPoint,\n  extensionPointId,\n  validateWithSchema,\n  type ValidationContext,\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"],"names":["ControlPourSchema","createExtensionSchema","EXTENSION_ID","extensionPointId","ControlPourExtension","defineExtensionPoint","data","context","validateWithSchema","createViewAwareTransform","EXTENSION_POINT_CONTROL_POUR"],"mappings":";;;;;;;;AAYA,MAAMA,IAAoBC,EAAsB,CAAA,GAAI,EAAE,UAAU,IAAO,GAKjEC,IAAeC,EAAiB,OAAO,WAAW,MAAM,GAQjDC,IAAuBC,EAGlC;AAAA,EACA,IAAIH;AAAA,EACJ,iBAAiB;AAAA,EACjB,aAAa;AAAA,EACb,aACE;AAAA,EACF,SAAS;AAAA,EACT,YAAY;AAAA,EAEZ,QAAQF;AAAA,EACR,UAAU;AAAA,IACR,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,MAAM,CAAC,QAAQ,WAAW,UAAU;AAAA,EAAA;AAAA,EAGtC,UAAU,CAACM,GAA6BC,MAA+B;AAErE,IAAAC,EAAmBR,GAAmBM,GAAMC,CAAO;AAAA,EACrD;AAAA,EAEA,WAAWE,EAAA;AACb,CAAC,GAGYC,IAA+BR;"}

package/models/constants/constants.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Extension point exposed by the KOS Dispense SDK models
+ * */
+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;
+     *  };
+     * ```
+     * */
+    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,
+     *  }
+     * }
+     * ```
+     * */
+    IngredientMapper = "kos.ingredient.mapper",
+    IngredientIndex = "kos.ingredient.index",
+    /**
+     * Maps the type property of the ingredient into the {@link IngredientModel}
+     * */
+    IngredientTypeMapper = "kos.ingredient.type.mapper",
+    /**
+     * Maps the type property of the holder into the {@link HolderModel}
+     * */
+    HolderTypeMapper = "kos.holder.type.mapper",
+    HolderMapper = "kos.holder.mapper",
+    HolderIndex = "kos.holder.index",
+    /**
+     * Maps the ingredientId property of the holder into the {@link HolderModel}.
+     * If not provided, the ingredientId will assume that the value is mapped from the
+     * ingredientId property of the service response.
+     * */
+    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 };
+     * };
+     * ```
+     * */
+    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;
+     *  };
+     * ```
+     * */
+    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;
+     *  };
+     *```
+     */
+    AssemblyMapper = "kos.assembly.mapper",
+    BoardMapper = "kos.board.mapper",
+    BoardIndex = "kos.board.index",
+    PumpIndex = "kos.pump.index",
+    AssemblyFeatureFlags = "kos.assembly.feature.flags"
+}
+export declare enum DispenseModelType {
+    Nozzle = "nozzle-model",
+    Availability = "availability-model",
+    Holder = "holder-model",
+    HolderContainer = "holder-container-model",
+    IngredientContainer = "ingredient-container-model",
+    Ingredient = "ingredient-model",
+    Pump = "pump-model",
+    PumpContainer = "pump-container-model"
+}
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +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"}

package/models/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/models/index.d.ts

@@ -0,0 +1,6 @@
+export * from './constants';
+export * from './models';
+export * from './utils/dispense-registration-manager';
+export * from './utils/extension-utils';
+export * from './utils/registration';
+//# sourceMappingURL=index.d.ts.map

package/models/index.d.ts.map

@@ -0,0 +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"}

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

@@ -0,0 +1,41 @@
+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';
+
+export declare const MODEL_TYPE = "assembly-model";
+export declare const CONTEXT_ASSEMBLY_DATA = "assembly-data";
+export declare const CONTEXT_ASSEMBLY_RAW_DATA = "assembly-raw-data";
+export declare class AssemblyModelImpl<AssemblyExt extends object = any, HolderExt extends object = any> implements AssemblyModel<AssemblyExt>, IKosModelLogger {
+    id: string;
+    private _nozzlePaths;
+    private troubleContainer;
+    private holderContainer;
+    private boardContainer;
+    private pumpContainer;
+    logger: KosContextLogger;
+    constructor(modelId: string, _options: AssemblyOptions, context: KosCreationContext);
+    updateModel(_options: AssemblyOptions): void;
+    get allHolders(): HolderModel<HolderExt>[];
+    get holderGroups(): string[];
+    get nozzlePaths(): string[];
+    getHoldersByGroup(group: string): HolderModel<HolderExt>[];
+    getHoldersByNozzle(nozzlePath: string): HolderModel<HolderExt>[];
+    /**
+     * Returns a map of the pumps associated with each nozzle
+     *
+     * Can be used in conjunction with the nozzlePaths to get the pumps associated with each nozzle
+     * @returns Record<string, PumpModel[]>
+     */
+    get pumpsByNozzle(): Record<string, PumpModel<any>[]>;
+    /**
+     * Returns a list of all fo the pumps paths across the entire assembly.
+     */
+    get pumpPaths(): string[];
+    get boards(): BoardModel<any>[];
+    init(): Promise<void>;
+    ready(): Promise<void>;
+    load(context: KosContext): Promise<void>;
+}
+//# sourceMappingURL=assembly-model.d.ts.map

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

@@ -0,0 +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,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;CA6E/C"}

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

@@ -0,0 +1,81 @@
+import { AssemblyModel, AssemblyOptions } from './types';
+import { SingletonKosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # 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
+ * });
+ * ```
+ 
+
+ *
+ * ## 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,
+ * };
+ * ```
+ *
+ * ## 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

@@ -0,0 +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"}

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

@@ -0,0 +1,6 @@
+import { AssemblyBoard } from '../types/assembly';
+import { BoardContainerModel } from '../board';
+
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,5 @@
+import { AssemblyHolder } from '../types/assembly';
+import { HolderModel } from '../holder/types';
+
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"holder-utils.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/assembly/holder-utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAiB,MAAM,iBAAiB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,eAAO,MAAM,wBAAwB,0FAI5B,MAAM,cACD,eAAe,yBAAyB,CAAC,oCA2CtD,CAAC"}

package/models/models/assembly/index.d.ts

@@ -0,0 +1,5 @@
+export { CONTEXT_ASSEMBLY_DATA, CONTEXT_ASSEMBLY_RAW_DATA, } from './assembly-model';
+export { Assembly } from './assembly-registration';
+export * as AssemblyServices from './services';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/models/models/assembly/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/assembly/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,KAAK,gBAAgB,MAAM,YAAY,CAAC;AAC/C,mBAAmB,SAAS,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"nozzle-utils.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/assembly/nozzle-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,KAAK,mBAAmB,EAAqB,MAAM,UAAU,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,eAAO,MAAM,uBAAuB,UAAW,aAAa,sCAc3D,CAAC;AAEF,eAAO,MAAM,gBAAgB,mBACV,mBAAmB,aAAa,aAAa,SAI7D,CAAC"}

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

@@ -0,0 +1,7 @@
+import { AssemblyNozzle, AssemblyPump } from '../types/assembly';
+import { PumpContainerModel } from '../pump-container';
+import { HolderContainerModel } from '../holder-container';
+
+export declare const mapAssemblyPumpToModel: (nozzlePath: string, pump: AssemblyPump) => import('../pump').PumpModel<any>;
+export declare const assemblyPumpMap: (pumpContainer: PumpContainerModel) => (holderContainer: HolderContainerModel) => (nozzle: AssemblyNozzle) => (assemblyPump: AssemblyPump) => void;
+//# sourceMappingURL=pump-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pump-utils.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/assembly/pump-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtE,eAAO,MAAM,sBAAsB,eACrB,MAAM,QACZ,YAAY,qCAqBnB,CAAC;AAEF,eAAO,MAAM,eAAe,kBACV,kBAAkB,uBAChB,oBAAoB,cAC7B,cAAc,oBACR,YAAY,SAqB1B,CAAC"}

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

@@ -0,0 +1,8 @@
+import { AssemblyResponse } from '../../types/assembly';
+
+/**
+ * @category Service
+ * Retrieves the initial assembly data.
+ */
+export declare const getAssembly: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<AssemblyResponse<{}>> | undefined>;
+//# sourceMappingURL=assembly-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assembly-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/assembly/services/assembly-services.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAW7D;;;GAGG;AACH,eAAO,MAAM,WAAW,uGAIvB,CAAC"}

package/models/models/assembly/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './assembly-services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/assembly/services/index.d.ts.map

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