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

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;AAgEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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

@@ -0,0 +1,79 @@
+import { IKosDataModel, KosParentAware, NoteAware } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * Options for creating an AvailabilityModel.
+ */
+export interface AvailabilityOptions<
+  AdditionalData extends object = any,
+  Properties extends Record<string, any> = Record<string, 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;
+  properties?: Properties;
+}
+/**
+ *
+ *
+ * Represents the nodes of the Beverage Availability graph for a nozzle.
+ *
+ * @typeParam AdditionalData - Any additional data that is added to a node at the application layer.
+ *
+ * @example The base GraphNode from the backend will have an id, type, available and visible properties.  However,
+ * a given implementation might extend the Beverage Graph node to include additional data, such as the beverage name or
+ * an image url.  This additional data would be added to the node and would be represented by the AdditionalData type parameter.
+ * ```typescript
+ * const model: AvailabilityModel<{icon: string}> = ...;
+ * ```
+ * would allow for visibility of all the base properties as well as the additional data (icon) that might be on the message payload from
+ * the backend.
+ *
+ * @category Model
+ */
+export interface AvailabilityModel<
+  AdditionalData extends object = any,
+  Properties extends Record<string, any> = Record<string, any>
+> extends Omit<
+      AvailabilityOptions<AdditionalData, Properties>,
+      "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"}