@kosdev-code/kos-dispense-sdk 2.0.2

package/models/constants/constants.d.ts

@@ -0,0 +1,229 @@
+/**
+ * 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"
+}
+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;CAC7B;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,40 @@
+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 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;AAYjC,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,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;IAEzC,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;IAIL,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAyE/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,4 @@
+export { Assembly } from './assembly-registration';
+export type * from './types';
+export * as AssemblyServices from './services';
+//# 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,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,gBAAgB,MAAM,YAAY,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"}

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

@@ -0,0 +1,64 @@
+import { HolderModel } from '../../holder/types';
+import { BoardModel } from '../../board/types';
+import { IKosDataModel } from '@kosdev-code/kos-ui-sdk';
+
+export interface AssemblyOptions {}
+
+/**
+ *
+ *
+ * Represents the union of device assemblies including all of the boards, holders, pumps and nozzles defined
+ * on the device.
+ *
+ *
+ * @category Model
+ */
+export interface AssemblyModel<
+  AssemblyExt extends object = any,
+  HolderExt extends object = any
+> extends AdditionalData,
+    AssemblyExt,
+    IKosDataModel {
+  id: string;
+
+  /** The unique list of holder group names */
+  readonly holderGroups: string[];
+
+  readonly boards: BoardModel<any>[];
+  /**
+   * The list of all nozzle paths defined on the device.  This is useful as a means to discover
+   * which nozzles are available on dispensers with multiple nozzles.
+   */
+  readonly nozzlePaths: string[];
+
+  /**
+   * The list of all holders defined on the device, regardless of group
+   */
+  readonly allHolders: HolderModel<HolderExt>[];
+
+  /**
+   * Get the holders for a named group.
+   * @param group - the group name to filter the holders by.
+   */
+  getHoldersByGroup(group: string): HolderModel<HolderExt>[];
+
+  /**
+   * Get the holders mapped to a given nozzle.
+   * @param nozzlePath - the nozzle path to filter the holders by.
+   */
+  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
+   *
+   */
+  readonly pumpsByNozzle: Record<string, PumpModel<any>[]>;
+
+  /**
+   * Returns a list of all fo the pumps paths across the entire assembly.
+   */
+  readonly pumpPaths: string[];
+  updateModel(options: AssemblyOptions): void;
+}

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

@@ -0,0 +1,89 @@
+import { AvailabilityModel, AvailabilityOptions } from './types';
+import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # Availability
+ *
+ * The registration bean includes convenience methods for creating and working with AvailabilityModel 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: 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,
+ * };
+ * ```
+ *
+ * ## 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.
+ * */
+export declare const Availability: Readonly<KosModelRegistrationBean<AvailabilityModel, AvailabilityOptions>>;
+//# sourceMappingURL=availability-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"availability-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/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;AA4DtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmFK;AACL,eAAO,MAAM,YAAY,EAAE,QAAQ,CACjC,wBAAwB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAgBjE,CAAC"}

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

@@ -0,0 +1,3 @@
+export { Availability } from './availability-model';
+export type { AvailabilityModel, AvailabilityOptions } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/availability/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC"}