@kosdev-code/kos-dispense-sdk 2.0.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"assignment-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/services/assignment-services.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AACD;;;GAGG;AACH,eAAO,MAAM,cAAc,+FAG1B,CAAC;AACF,MAAM,MAAM,mBAAmB,GAC3B,UAAU,GACV,YAAY,GACZ,aAAa,GACb,eAAe,GACf,WAAW,GACX,YAAY,GACZ,cAAc,CAAC;AACnB,KAAK,kBAAkB,GAAG;IACxB,mBAAmB,GAAG,SAAS;IAC/B,UAAU,GAAG,SAAS;CACvB,CAAC;AACF,eAAO,MAAM,gBAAgB,eACf,MAAM,aACP,GAAG,KACb,QAAQ,kBAAkB,CAsB5B,CAAC;AAEF,eAAO,MAAM,aAAa,eAAsB,UAAU,mFAUzD,CAAC;AAEF,eAAO,MAAM,gBAAgB,OAAc,MAAM,uFAGhD,CAAC"}

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

@@ -0,0 +1,28 @@
+export interface Pump {
+    inserted: boolean;
+    beveragePour: boolean;
+    ingredientPour: boolean;
+    type: string;
+    category: string;
+    ingredientId: string;
+    holderPath: string;
+    boardPath: string;
+    nozzlePath: string;
+    name: string;
+    path: string;
+}
+export interface HolderResponse {
+    path: string;
+    name: string;
+    ingType: string;
+    ingSource: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial Holder data.
+ */
+export declare const getHolders: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<HolderResponse[]> | undefined>;
+export declare const assignHolderIngredient: (holderPath: string, ingredientId: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+export declare const unassignHolderIngredient: (holderPath: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
+export declare const replaceLine: (holderPath: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+//# sourceMappingURL=holder-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"holder-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/services/holder-services.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,IAAI;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AACD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AACD;;;GAGG;AACH,eAAO,MAAM,UAAU,mGAGtB,CAAC;AAEF,eAAO,MAAM,sBAAsB,eACrB,MAAM,gBACJ,MAAM,mFAYrB,CAAC;AAEF,eAAO,MAAM,wBAAwB,eAAsB,MAAM,uFAWhE,CAAC;AAEF,eAAO,MAAM,WAAW,eAAsB,MAAM,mFAanD,CAAC"}

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

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

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

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

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

@@ -0,0 +1,163 @@
+import { Assignment } from '../services';
+import { IntentAware } from '../../types/intent';
+import { HolderSlice } from '../../types/assembly';
+import { PumpModel } from '../../pump/types';
+import { IngredientModel } from '../../ingredient';
+import { IKosDataModel, IKosModelContainer, TroubleAware } from '@kosdev-code/kos-ui-sdk';
+
+
+export interface HolderOptions<AdditionalData extends object = any> {
+  path: string;
+  name: string;
+  enjoyByDate?: Date;
+  ingredientId?: string;
+  ingredientType?: string;
+  ingredientSource?: string;
+  group: string;
+  slice: HolderSlice;
+  data: AdditionalData;
+}
+
+/**
+ * Abstraction of how an ingredient cartridge attaches to a pump. In many cases
+ * this is simply a hose that connects a BiB container to a pump, but in more
+ * complex devices this represents a cartridge slot which may have associated
+ * hardware, such as RFID antenna, indicator lights, and so on. This also holds
+ * state about the availability of a pump to pump the connected ingredient.
+ *
+ * @category Model
+ */
+export interface HolderModel<AdditionalData extends object = any>
+  extends IKosDataModel,
+    IntentAware,
+    TroubleAware {
+  id: string;
+  name: string;
+  path: string;
+  ingredientId?: string;
+  ingredientType?: string;
+  ingredientSource?: string;
+  group: string;
+  slice: HolderSlice;
+  enjoyByDate?: Date;
+  hasEnjoyByWarning: boolean;
+  prevIngredientId?: string;
+
+  readonly maxVolume: number;
+  readonly remainingVolume: number;
+  readonly hasMaxVolume: boolean;
+  readonly hasRemainingVolume: boolean;
+  readonly fillPercent: number;
+  readonly hasFuelGuage: boolean;
+  readonly hasEnjoyByDate: boolean;
+
+  removed: boolean;
+  unassigned: boolean;
+  updateModel(options: HolderOptions): void;
+  data: AdditionalData;
+
+  /**
+   * Perform an RFID override on the holder
+   * @param overrides
+   * @throws AssignmentError(errIdLen) if the id length is invalid
+   * @throws AssignmentError(errCodeLen) if the code length is invalid
+   * @throws AssignmentError(errIdFormat) if the id format is invalid
+   * @throws AssignmentError(errCodeFormat) if the code format is invalid
+   * @throws AssignmentError(errVerify) if the verification fails
+   * @throws AssignmentError(errBadJson) if the json is invalid
+   *
+   * @returns
+   */
+  overrideRfidCode<T extends Record<string, any>>(
+    overrides: T
+  ): Promise<Assignment | undefined>;
+  /**
+   * The name of the ingredient assigned to the holder
+   * @readonly
+   */
+  readonly ingredientName: string;
+  /**
+   * The {@link IngredientModel} assigned to the holder
+   */
+  readonly ingredient?: IngredientModel;
+
+  /**
+   * The name of the previous ingredient assigned to the holder
+   * @readonly
+   */
+  readonly previousIngredientName: string;
+  /**
+   * The previous {@link IngredientModel} assigned to the holder
+   */
+  readonly previousIngredient?: IngredientModel;
+
+  /**
+   * The {@link PumpModel} models assigned to the holder.
+   */
+  pumps: IKosModelContainer<PumpModel>;
+
+  /**
+   * The {@link PumpModel} models assigned to the holder sorted by the pump order.
+   */
+  sortedPumps: PumpModel[];
+
+  /**
+   * The paths of the nozzles that are attached to the holder. It is possible
+   * for a holder to be connected to multiple nozzles depending on the number
+   * of pumps it has.  For example, some dispensers might be configured to share
+   * ingredients across nozzles in cases where less frequently used ingredients
+   * are used in smaller quantities.
+   */
+  readonly nozzlePaths: string[];
+
+  /**
+   * A boolean value that indicates if the ingredient in the holder can be poured.
+   * This is derived from the pour status of all of the underlying pumps.
+   */
+  readonly canPour: boolean;
+
+  /**
+   * A boolean value that indicates if the ingredient in the holder is currently
+   * pouring.
+   *
+   * This is derived from the pour status of the underlying pumps indicating if any
+   * of the pumps are currently pouring.
+   */
+  readonly isPouring: boolean;
+
+  readonly pourState: string;
+
+  /**
+   * Assign an ingredient to the holder.
+   *
+   * This method will call into the {@link assignHolderIngredient} service to assign the ingredient to the holder.
+   *
+   * If unassigning the ingredient, the {@link unassignHolderIngredient} service will be called.
+   *
+   * @param ingredientId The id of the ingredient to assign to the holder.  If not specified, the ingredient will be unassigned.
+   */
+  assignIngredient(ingredientId?: string): Promise<void>;
+
+  /**
+   * Update the ingredient id of the holder.
+   *
+   * This method will update the ingredient id of the holder without calling into the {@link assignHolderIngredient} or {@link unassignHolderIngredient} services.
+   *
+   * It is intended to be used when ingredient assignment events are received from the dispenser, such as when an ingredient is
+   * inserted into a holder and the rfid tag is read.  In this case, the assignment will be received via the topic handler and
+   * the ingredient id will be updated on the holder.
+   *
+   * This method should be used to update state as opposed to the {@link assignIngredient} method which should be used to
+   * perform the actual assignment.
+   *
+   * @param ingredientId The id of the ingredient to assign to the holder.  If not specified, the ingredient will be unassigned.
+   */
+  updateIngredient(ingredientId?: string): void;
+
+  resolveIntentVolume(intent: string): Promise<{ volume: number }>;
+
+  /**
+   * Indicate that the lines associated with holder have been replaced.
+   */
+  replaceLine(): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { HolderModel } from '../types';
+
+export declare const getFuelGaugeValue: (holder: HolderModel) => {
+    maxVolume: number;
+    remainingVolume: number;
+    fillPercent: number;
+    hasFuelGuage: boolean;
+};
+//# sourceMappingURL=holder-utils.d.ts.map

package/models/models/holder/utils/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/holder/utils/holder-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,eAAO,MAAM,iBAAiB,WAAY,WAAW;;;;;CA8CpD,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"holder-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder-container/holder-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,iCAAiC,EAClC,MAAM,yBAAyB,CAAC;AAYjC,OAAO,KAAK,EACV,oBAAoB,EACpB,sBAAsB,EAGvB,MAAM,SAAS,CAAC;AAwHjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EO;AACP,eAAO,MAAM,eAAe,EAAE,iCAAiC,CAC7D,oBAAoB,EACpB,sBAAsB,CAavB,CAAC"}

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

@@ -0,0 +1,3 @@
+export { HolderContainer } from './holder-container-model';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder-container/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,mBAAmB,SAAS,CAAC"}

package/models/models/holder-container/types/index.d.ts

@@ -0,0 +1,69 @@
+import { HolderModel } from '../../holder/types';
+import { IKosDataModel, IKosModelContainer } from '@kosdev-code/kos-ui-sdk';
+
+
+export interface HolderContainerOptions {}
+
+export interface PathAware {
+  path: string;
+}
+export interface HolderPathAware extends PathAware {
+  slice: {
+    pos: number;
+    currentVolMl?: number;
+    maxVolMl?: number;
+  };
+  agitated: boolean;
+  container: {
+    enjoyByDate: number;
+  };
+  ingredientId: string;
+  containerId: string;
+  name: string;
+}
+/**
+ * Represents a collection of holders for the dispenser or a specific assembly.
+ *
+ * Provides default indexing to allow for grouping of holders by nozzle.
+ *
+ *
+ * @category Model
+ */
+export interface HolderContainerModel<T extends object = any>
+  extends IKosDataModel {
+  /** the unique identifier for the model */
+  id: string;
+
+  /** the collection of holder models  */
+  holders: IKosModelContainer<HolderModel>;
+
+  /** convenience method to update the holder container based on the options */
+  updateModel(options: HolderContainerOptions): void;
+}
+
+export interface InsertionPump {
+  inserted: boolean;
+  type: string;
+  boardPath: string;
+  ingredientId: string;
+  prevIngredientId?: string;
+  holderPath: string;
+  name: string;
+  path: string;
+}
+export interface InsertionEvent {
+  pumps: InsertionPump[];
+  slice: {
+    pos: number;
+    maxVolMl?: number;
+    currentVolMl?: number;
+  };
+  container: {
+    enjoyByDate: number;
+  };
+  agitated: boolean;
+  ingredientId: string;
+  containerId: string;
+  name: string;
+  path: string;
+}

package/models/models/index.d.ts

@@ -0,0 +1,13 @@
+export * from './assembly';
+export * from './availability';
+export * from './board';
+export * from './device-assembly';
+export * from './holder';
+export * from './holder-container';
+export * from './ingredient';
+export * from './ingredient-container';
+export * from './nozzle';
+export * from './pump';
+export * from './pump-container';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC;AACvC,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC"}

package/models/models/ingredient/index.d.ts

@@ -0,0 +1,4 @@
+export { Ingredient } from './ingredient-model';
+export type * from './types';
+export * as IngredientServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/ingredient/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,kBAAkB,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,86 @@
+import { IngredientModel, IngredientOptions } from './types';
+import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # Ingredient
+ *
+ * The registration bean includes convenience methods for creating and working with IngredientModel 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: Ingredient.type, id: "ingredientId"})
+ * private ingredientModel: IngredientModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new IngredientModel 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 = Ingredient.factory("S1")({
+ *    name: "S1",
+ *    ingredientId: "1234532",
+ *    type: "syrup",
+ *    data: {
+ *      // mapped from an extension point
+ *    }
+ *  });
+ * ```
+ *
+ * ## 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 IngredientModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Ingredient.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to IngredientModel
+ *    // and the compiler will know that the model has the IngredientModel 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 { Ingredient } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Ingredient.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ *
+ * The ingredient 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 Ingredient: Readonly<KosModelRegistrationBean<IngredientModel, IngredientOptions>>;
+//# sourceMappingURL=ingredient-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ingredient-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/ingredient/ingredient-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,wBAAwB,EAGzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAmDlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,UAAU,EAAE,QAAQ,CAC/B,wBAAwB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAW7D,CAAC"}

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

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

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

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

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

@@ -0,0 +1,30 @@
+export interface BrandsetResponse {
+    brandSet: IngredientResponse[];
+}
+/**
+ * Base ingredient response returned by the service.  Most likely this will be augmented by the {@link IngredientMapper} extension point
+ * to allow for additional properties to be added to the ingredient data.
+ * */
+export interface IngredientResponse {
+    /** The ingredient id */
+    id: string;
+    /**
+     * The raw ingredient without considering the source.  This will only be different in cases where there are asymetrical nozzles with
+     * discrete ingredient sources.
+     */
+    ingredientId: string;
+    /** The ingredient name */
+    name: string;
+    /**
+     * The ingredient type as defined by the java application.  This can be any value and is generally used
+     * to classify ingredients into groups. For example, the ingredient type may be used to identify ingredients that are
+     * used for flavor shots.
+     */
+    type: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial Ingredient data.
+ */
+export declare const getIngredients: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<BrandsetResponse> | undefined>;
+//# sourceMappingURL=ingredient-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ingredient-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/ingredient/services/ingredient-services.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,kBAAkB,EAAE,CAAC;CAChC;AACD;;;KAGK;AACL,MAAM,WAAW,kBAAkB;IACjC,wBAAwB;IACxB,EAAE,EAAE,MAAM,CAAC;IAEX;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AACD;;;GAGG;AACH,eAAO,MAAM,cAAc,mGAK1B,CAAC"}

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

@@ -0,0 +1,67 @@
+import { IKosDataModel } from '@kosdev-code/kos-ui-sdk';
+
+
+/**
+ * Represents the options for creating an ingredient.
+ *
+ */
+export interface IngredientOptions<AdditionalData extends object = any> {
+  /**
+   * The name of the ingredient.
+   *  */
+  name: string;
+  /**
+   * The type of the ingredient.
+   * */
+  type: string;
+  /**
+   * The ingredient id.
+   * */
+  ingredientId: string;
+  [key: keyof AdditionalData]: AdditionalData[key];
+  data: AdditionalData;
+}
+
+/**
+ * Represents an ingredient that is composed into beverages and dispensed by the dispenser.
+ *
+ * These will typically be created as part of the overall dispenser lifecycle as part of the Nozzle model.
+ *
+ * @typeParam AdditionalData - Any additional data that is added to an ingredient at the application layer.
+ *
+ *  @example The base Ingredient from the backend will have an id, type and name properties.  However,
+ * a given implementation might extend the Ingredient node to include additional data, such as the image url.
+ * This additional data would be added to the model and would be represented by the AdditionalData type parameter.
+ * ```typescript
+ * const model: IngredientModel<{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 IngredientModel<AdditionalData extends object = any>
+  extends IKosDataModel,
+    AdditionalData {
+  id: string;
+  /**
+   * The name of the ingredient.
+   *  */
+  name: string;
+  /**
+   * The type of the ingredient.
+   * */
+  type: string;
+  /**
+   * The ingredient id.
+   * */
+  ingredientId: string;
+
+  /**
+   * The ingredient data as defined by the {@link ExtensionType.IngredientMapper} extension point.
+   * */
+  data: AdditionalData;
+
+  /** @internal */
+  updateModel(options: IngredientOptions): void;
+}

package/models/models/ingredient-container/index.d.ts

@@ -0,0 +1,3 @@
+export { IngredientContainer } from './ingredient-container-model';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/models/models/ingredient-container/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/ingredient-container/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,mBAAmB,SAAS,CAAC"}