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

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,14 @@
+export * from './assembly';
+export * from './availability';
+export * from './board';
+export * from './device-assembly';
+export * from './generic-pour';
+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,gBAAgB,CAAC;AAC/B,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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ingredient-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/ingredient-container/ingredient-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,iCAAiC,EAClC,MAAM,yBAAyB,CAAC;AAajC,OAAO,KAAK,EACV,wBAAwB,EACxB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAoFjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EO;AACP,eAAO,MAAM,mBAAmB,EAAE,iCAAiC,CACjE,wBAAwB,EACxB,0BAA0B,CAc3B,CAAC"}

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

@@ -0,0 +1,67 @@
+import { IngredientModel } from '../../ingredient/types';
+import { IKosDataModel, IKosModelContainer } from '@kosdev-code/kos-ui-sdk';
+
+
+export interface IngredientContainerOptions {}
+
+/**
+ * The IngredientContainer represents the collection of {@link IngredientModel} entities that are considered as part of the KOS Beverage Graph.
+ *
+ * Its primary purpose is expose the set of ingredients that can be used to compose a pourable beverage.  The presence or absence
+ * of an ingredient in the container will determine if the ingredient is available for use in the beverage graph.
+ *
+ * The ingredient container will index all of the underlying ingredients by the `type` property of the ingredient. This allows for
+ * the grouping and filtering of ingredients based on the `type` property.  For example, to get the ingredients that are used for flavor shots,
+ * you would call {@link IngredientContainer.getIngredientsByType} with the `type` of the flavor shot.
+ *
+ * The Ingredient is a {@link IKosDataModel} and is registered with the model registry using the {@link IngredientContainer} type.
+ *
+ *
+ * @see {@link IngredientServices.getIngredients} - The ingredient service will retrieve the set of ingredients.
+ *
+ * ## Lifecycle
+ *
+ * ### Load
+ *
+ * During the `load` phase of the model lifecycle, the set of {@link IngredientModel} models will be retrieved and processed.  The nodes will be indexed based on
+ * the defined `type` for the node.  The `type` is defined as part of the backend Ingredient model.
+ *
+ * #### Extension Points
+ *
+ * The `load` lifecycle hook will call into the {@link ExtensionType.IngredientLoader} extension point in order to establish the context
+ * that will be used to populate the ingredients nodes.  Use of this extension point is optional.
+ *
+ * The `load` lifecycle hook will  call into the {@link ExtensionType.IngredientMapper} for each ingredient node that is retrieved from the backend.
+ * The extension point will be called with the Ingredient context data and the {@link IngredientServices.IngredientResponse} for the ingredient node and will
+ * map the results into the {@link IngredientModel} as part of the `data` property.
+ *
+ * The `load` lifecycle hook will call into the {@link ExtensionType.IngredientTypeMapper} for each ingredient node that is retrieved from the backend.
+ * The extension point will be called with the Ingredient context data and the {@link IngredientServices.IngredientResponse} for the ingredient node. The results will
+ * be mapped into the {@link IngredientModel} as the `type` property.
+ *
+ *
+ * @see {@link IngredientContainer}
+ *
+ * @category Model
+ */
+export interface IngredientContainerModel<AdditionalData extends object = {}>
+  extends IngredientContainerOptions,
+    IKosDataModel,
+    AdditionalData {
+  id: string;
+  /**
+   * The set of ingredients that are available for use in the beverage graph.
+   * @readonly
+   * */
+  ingredients: IKosModelContainer<IngredientModel>;
+
+  /**
+   * Utility method to retrieve the ingredients that are associated with the specified type.
+   * @param type The type of the ingredient to retrieve.
+   * @returns The set of ingredients that are associated with the specified type.
+   * */
+  getIngredientsByType(type: string): IngredientModel<AdditionalData>[];
+
+  /** @internal */
+  updateModel(options: IngredientContainerOptions): void;
+}

package/models/models/nozzle/index.d.ts

@@ -0,0 +1,5 @@
+export { Nozzle, type NozzleModel } from './nozzle-model';
+export type { NozzleOptions, SelectedPourable } from './types';
+/** @category KOS Services */
+export * as NozzleServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/nozzle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1D,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE/D,6BAA6B;AAC7B,OAAO,KAAK,cAAc,MAAM,YAAY,CAAC"}