@kosdev-code/kos-dispense-sdk 2.0.2

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

@@ -0,0 +1,71 @@
+import { IKosDataModel, KosParentAware, NoteAware } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * Options for creating an AvailabilityModel.
+ */
+export interface AvailabilityOptions<AdditionalData extends object = any>
+  extends KosParentAware,
+    NoteAware {
+  /**is the node available as calculated by the Pour Engine */
+  available: boolean;
+  /**
+   * Return the alternate id for the node. The alternate id can be used
+   * to store correlation id's to link nodes to other data in the event
+   * that node id's can't be used due to potentially id collisions.
+   */
+  altId: string;
+
+  /**
+   * The raw id for the node.  The raw id will generally be the beverage id
+   * in the scope of its group.
+   */
+  rawId: string;
+  groupId: string;
+  /** is the node visible as calculated by the Pour Engine. */
+  visible: boolean;
+  /** the type of the node */
+  type: string;
+  taggedIds?: string[];
+  note?: string;
+  data: AdditionalData;
+}
+/**
+ *
+ *
+ * Represents the nodes of the Beverage Availability graph for a nozzle.
+ *
+ * @typeParam AdditionalData - Any additional data that is added to a node at the application layer.
+ *
+ * @example The base GraphNode from the backend will have an id, type, available and visible properties.  However,
+ * a given implementation might extend the Beverage Graph node to include additional data, such as the beverage name or
+ * an image url.  This additional data would be added to the node and would be represented by the AdditionalData type parameter.
+ * ```typescript
+ * const model: AvailabilityModel<{icon: string}> = ...;
+ * ```
+ * would allow for visibility of all the base properties as well as the additional data (icon) that might be on the message payload from
+ * the backend.
+ *
+ * @category Model
+ */
+export interface AvailabilityModel<AdditionalData extends object = any>
+  extends Omit<AvailabilityOptions, "data" | keyof KosParentAware>,
+    IKosDataModel,
+    NoteAware {
+  /** unique identifier of the Availability model */
+  id: string;
+  data: AdditionalData;
+  taggedIds: string[];
+  parentId?: string;
+  /**
+   * Convenience method to update the model with new availability options.
+   * @param options - the availability options to update the model with.
+   */
+  updateModel(options: AvailabilityOptions): void;
+
+  /**
+   * Updates node availability state.
+   *
+   * @param available - the new availability value to set on the model.
+   */
+  updateAvailability(available: boolean): void;
+}

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

@@ -0,0 +1,23 @@
+import { BoardLinkEvent } from './types/services';
+import { BoardContainerOptions, BoardModel } from './types';
+import { IKosDataModel, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "board-container-model";
+export declare const TOPIC_BOARD_LINKED = "/kos/hardware/board/linked";
+export declare const TOPIC_BOARD_UNLINKED = "/kos/hardware/board/unlinked";
+export declare class BoardContainerModel implements IKosDataModel {
+    id: string;
+    private logger;
+    private models;
+    constructor(modelId: string, options: BoardContainerOptions, context: KosCreationContext);
+    get boardList(): BoardModel<{}>[];
+    updateModel(): void;
+    addModel(model: BoardModel): void;
+    removeModel(id: string): void;
+    updateBoard(boardLinkEvent: BoardLinkEvent): void;
+    handleBoardLinkEvent(boardLinkEvent: BoardLinkEvent): void;
+    handleBoardUnlinkEvent(boardLinkEvent: BoardLinkEvent): void;
+}
+export interface BoardContainerModel {
+}
+//# sourceMappingURL=board-container-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"board-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/board/board-container-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EAGb,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AASjC,OAAO,KAAK,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,eAAO,MAAM,UAAU,0BAA0B,CAAC;AAClD,eAAO,MAAM,kBAAkB,+BAA+B,CAAC;AAC/D,eAAO,MAAM,oBAAoB,iCAAiC,CAAC;AAEnE,qBACa,mBAAoB,YAAW,aAAa;IACvD,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACvB,OAAO,CAAC,MAAM,CAAiC;gBAEvD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,kBAAkB;IAa7B,IAAI,SAAS,qBAEZ;IAED,WAAW,IAAI,IAAI;IAInB,QAAQ,CAAC,KAAK,EAAE,UAAU;IAI1B,WAAW,CAAC,EAAE,EAAE,MAAM;IAItB,WAAW,CAAC,cAAc,EAAE,cAAc;IAiB1C,oBAAoB,CAAC,cAAc,EAAE,cAAc;IAenD,sBAAsB,CAAC,cAAc,EAAE,cAAc;CAWtD;AAED,MAAM,WAAW,mBAAmB;CAAG"}

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { BoardModel, BoardOptions } from './types';
+import { IKosDataModel, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "board-model";
+export declare class BoardModelImpl<AdditionalData extends object = {}> implements IKosDataModel, BoardModel<AdditionalData> {
+    id: string;
+    type: string;
+    name: string;
+    path: string;
+    linked: boolean;
+    instanceId?: string;
+    private logger;
+    constructor(modelId: string, options: BoardOptions, context: KosCreationContext);
+    updateModel(options: BoardOptions): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=board-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"board-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/board/board-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAOjC,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAIxD,eAAO,MAAM,UAAU,gBAAgB,CAAC;AAwBxC,qBACa,cAAc,CAAC,cAAc,SAAS,MAAM,GAAG,EAAE,CAC5D,YAAW,aAAa,EAAE,UAAU,CAAC,cAAc,CAAC;IAEpD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAG,MAAM,CAAC;IACd,IAAI,EAAG,MAAM,CAAC;IACd,IAAI,EAAG,MAAM,CAAC;IACd,MAAM,EAAG,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,MAAM,CAAmB;gBAE/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,kBAAkB;IAQ7B,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAMlC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

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

@@ -0,0 +1,84 @@
+import { BoardModel, BoardOptions } from './types';
+import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # Board
+ *
+ * The registration bean includes convenience methods for creating and working with BoardModel 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: Board.type, id: "boardId"})
+ * private boardModel: BoardModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new BoardModel 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 = Board.factory("boardId")({
+ *   // 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 BoardModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Board.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to BoardModel
+ *    // and the compiler will know that the model has the BoardModel 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 { Board } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Board.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The board 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 Board: Readonly<KosModelRegistrationBean<BoardModel, BoardOptions>>;
+//# sourceMappingURL=board-registration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"board-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/board/board-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAGxE,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,KAAK,EAAE,QAAQ,CAC1B,wBAAwB,CAAC,UAAU,EAAE,YAAY,CAAC,CAWnD,CAAC"}

package/models/models/board/index.d.ts

@@ -0,0 +1,5 @@
+export { BoardContainerModel, TOPIC_BOARD_LINKED, TOPIC_BOARD_UNLINKED, } from './board-container-model';
+export { BoardContainer } from './board-container-registration';
+export { Board } from './board-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/board/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE7C,mBAAmB,SAAS,CAAC"}

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

@@ -0,0 +1,36 @@
+import { IKosDataModel } from '@kosdev-code/kos-ui-sdk';
+
+
+// ---------------  Board ---------------
+
+export interface LinkType {
+  linkType: string;
+  serialNum: string;
+  revision?: string;
+  firmwareVersions?: string[];
+  [k: string]: string;
+}
+export interface BoardOptions<AdditionalData extends object = any> {
+  type: string;
+  name: string;
+  path: string;
+  linked: boolean;
+  link?: LinkType;
+  instanceId?: string;
+  [key: keyof AdditionalData]: AdditionalData[key];
+}
+
+// ---------------  BoardContainer ---------------
+export interface BoardContainerOptions {}
+
+export interface BoardModel<AdditionalData extends object = {}>
+  extends AdditionalData,
+    IKosDataModel {
+  type: string;
+  name: string;
+  path: string;
+  linked: boolean;
+  link?: Readonly<LinkType>;
+  instanceId?: string;
+  updateModel(options: BoardOptions): void;
+}

package/models/models/board/types/services.d.ts

@@ -0,0 +1,12 @@
+export interface BoardLinkEvent {
+    link: {
+        linkType: string;
+        serialNum: string;
+    };
+    instanceId: string;
+    type: string;
+    linked: boolean;
+    name: string;
+    path: string;
+}
+//# sourceMappingURL=services.d.ts.map

package/models/models/board/types/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/board/types/services.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd"}

package/models/models/board/utils/board-trouble-data-mapper.d.ts

@@ -0,0 +1,7 @@
+import { BoardTroubleData } from './board-trouble-resolver';
+import { TroubleModel } from '@kosdev-code/kos-ui-sdk';
+
+export declare const boardTroubleDataMapper: (trouble: TroubleModel<BoardTroubleData>) => Promise<{
+    boardName: string;
+}>;
+//# sourceMappingURL=board-trouble-data-mapper.d.ts.map

package/models/models/board/utils/board-trouble-data-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-trouble-data-mapper.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/board/utils/board-trouble-data-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,eAAO,MAAM,sBAAsB,YACxB,aAAa,gBAAgB,CAAC;;EAOxC,CAAC"}

package/models/models/board/utils/board-trouble-resolver.d.ts

@@ -0,0 +1,7 @@
+import { TroubleModel } from '@kosdev-code/kos-ui-sdk';
+
+export interface BoardTroubleData {
+    boardPath: string;
+}
+export declare const boardTroubleResolver: (trouble: TroubleModel<BoardTroubleData>) => Promise<string[]>;
+//# sourceMappingURL=board-trouble-resolver.d.ts.map

package/models/models/board/utils/board-trouble-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-trouble-resolver.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/board/utils/board-trouble-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAQzE,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,oBAAoB,YACtB,aAAa,gBAAgB,CAAC,sBA0BxC,CAAC"}

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

@@ -0,0 +1,17 @@
+import { DeviceAssemblyOptions } from './types';
+import { NozzleModel } from '../nozzle';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "device-assembly-model";
+export type DeviceAssemblyModel = PublicModelInterface<DeviceAssemblyModelImpl>;
+export declare class DeviceAssemblyModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private deviceNozzles;
+    private logger;
+    constructor(modelId: string, _options: DeviceAssemblyOptions, context: KosCreationContext);
+    init(): Promise<void>;
+    getNozzle(path: string): NozzleModel | undefined;
+    get nozzlePaths(): string[];
+    load(): Promise<void>;
+}
+//# sourceMappingURL=device-assembly-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device-assembly-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/device-assembly/device-assembly-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAGhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAU,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD,eAAO,MAAM,UAAU,0BAA0B,CAAC;AAElD,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,CAAC,uBAAuB,CAAC,CAAC;AAEhF,qBACa,uBACX,YAAW,aAAa,EAAE,gBAAgB;IAE1C,EAAE,EAAE,MAAM,CAAC;IACD,OAAO,CAAC,aAAa,CAAkC;IACjE,OAAO,CAAC,MAAM,CAAmB;gBAE/B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE,kBAAkB;IASvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIhD,IAAI,WAAW,IAAI,MAAM,EAAE,CAE1B;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAwB5B"}

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

@@ -0,0 +1,89 @@
+import { DeviceAssemblyOptions } from './types';
+import { DeviceAssemblyModel } from './device-assembly-model';
+import { SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # DeviceAssembly
+ *
+ * The registration bean includes convenience methods for creating and working with DeviceAssemblyModel 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: DeviceAssembly.type, id: "deviceAssemblyId"})
+ * private deviceAssemblyModel: DeviceAssemblyModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new DeviceAssemblyModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = DeviceAssembly.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a DeviceAssemblyModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (DeviceAssembly.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to DeviceAssemblyModel
+ *    // and the compiler will know that the model has the DeviceAssemblyModel 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 { DeviceAssembly } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(DeviceAssembly);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The deviceAssembly model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const DeviceAssembly: SingletonKosModelRegistrationFactory<DeviceAssemblyModel, DeviceAssemblyOptions>;
+//# sourceMappingURL=device-assembly-registration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device-assembly-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/device-assembly/device-assembly-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,cAAc,kFAMzB,CAAC"}

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

@@ -0,0 +1,4 @@
+export { DeviceAssembly } from './device-assembly-registration';
+export type * from './types';
+export type { DeviceAssemblyModel } from './device-assembly-model';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/device-assembly/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

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

@@ -0,0 +1 @@
+export interface DeviceAssemblyOptions {}

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

@@ -0,0 +1,93 @@
+import { HolderModel, HolderOptions } from './types';
+import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+export interface HolderTroubleData {
+    holderPaths: string[];
+    holderNames: string[];
+}
+export interface ContainerTroubleData {
+    ingredients: string[];
+    unknonwnIngredientId?: string;
+}
+/**
+ * # Holder
+ *
+ * The registration bean includes convenience methods for creating and working with HolderModel 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: Holder.type, id: "holderId"})
+ * private holderModel: HolderModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new HolderModel 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 = Holder.factory("S1")({
+ *  path: "core.dispenser.holder.s1",
+ *  name: "S1",
+ *  ingredientId: "1234532",
+ *  assemblyName: "",
+ *  type: "syrup",
+ *  });
+ * ```
+ *
+ * ## 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 HolderModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Holder.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to HolderModel
+ *    // and the compiler will know that the model has the HolderModel 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 { Holder } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Holder.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ *
+ * The holder 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 Holder: Readonly<KosModelRegistrationBean<HolderModel, HolderOptions>>;
+//# sourceMappingURL=holder-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"holder-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/holder-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,wBAAwB,EAGzB,MAAM,yBAAyB,CAAC;AAkCjC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAM1D,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAyZD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+EK;AACL,eAAO,MAAM,MAAM,EAAE,QAAQ,CAC3B,wBAAwB,CAAC,WAAW,EAAE,aAAa,CAAC,CAWrD,CAAC"}

package/models/models/holder/index.d.ts

@@ -0,0 +1,5 @@
+export { Holder, type HolderTroubleData } from './holder-model';
+export * as HolderServices from './services';
+export type * from './types';
+export * from './utils/holder-utils';
+//# sourceMappingURL=index.d.ts.map

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

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

package/models/models/holder/services/assignment-services.d.ts

@@ -0,0 +1,25 @@
+export interface Assignment {
+    ingredientId: string;
+    holderPath: string;
+    containerId?: string;
+    fuelGauge?: number;
+}
+export interface AssignmentFactoryJson {
+    stickerId: string;
+    stickerCode: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial dispenser data.
+ */
+export declare const getAssignments: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<Assignment[]> | undefined>;
+export type AssignmentErrorType = "errIdLen" | "errCodeLen" | "errIdFormat" | "errCodeFormat" | "errVerify" | "errBadJson" | "unknownError";
+type AssignmentResponse = [
+    AssignmentErrorType | undefined,
+    Assignment | undefined
+];
+export declare const sendRfidOverride: (holderPath: string, overrides: any) => Promise<AssignmentResponse>;
+export declare const addAssignment: (assignment: Assignment) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+export declare const deleteAssignment: (id: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
+export {};
+//# sourceMappingURL=assignment-services.d.ts.map