@kosdev-code/kos-dispense-sdk 3.0.26 → 3.0.28

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

@@ -1,79 +1,20 @@
 import { SingletonKosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
 import { IngredientContainerModel, IngredientContainerOptions } from './types';
 /**
- * # IngredientContainer
+ * Registration bean for {@link IngredientContainerModel}.
  *
- * The registration bean includes convenience methods for creating and working with IngredientContainerModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `IngredientContainer.factory(options)` returns the single instance, creating it on the first call.
+ * - `predicate`: type guard that narrows an `IKosDataModel` to `IngredientContainerModel`.
+ * - `registration`: registry entry that can be spread into an `IKosRegistry["models"]` map.
  *
- * ## 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.
+ * IngredientContainer is a singleton. `KosModelRegistry.dispense.models()` registers it.
  *
  * @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({ });
+ * @kosDependency({ modelType: IngredientContainer.type })
+ * private ingredientContainer!: IngredientContainerModel;
  * ```
- *
- * ## 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

@@ -1 +1 @@
-{"version":3,"file":"ingredient-container-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/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;AAwFjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EO;AACP,eAAO,MAAM,mBAAmB,EAAE,iCAAiC,CACjE,wBAAwB,EACxB,0BAA0B,CAc3B,CAAC"}
+{"version":3,"file":"ingredient-container-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/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;AAwFjB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,EAAE,iCAAiC,CACjE,wBAAwB,EACxB,0BAA0B,CAc3B,CAAC"}

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

@@ -192,85 +192,23 @@ declare class NozzleModelImpl implements PourStrategyAware {
  */
 export type NozzleModel = PublicModelInterface<NozzleModelImpl>;
 /**
+ * Registration bean for {@link NozzleModel}.
  *
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `Nozzle.factory(id)(options)`. Returns the existing model when the id is already in use and ignores the options.
+ * - `predicate`: type guard that narrows an `IKosDataModel` to `NozzleModel`.
+ * - `registration`: registry entry that can be spread into an `IKosRegistry["models"]` map.
  *
- * # Nozzle
- *
- * The registration bean includes convenience methods for creating and working with NozzleModel 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.
+ * Nozzle is not a singleton: each id has its own instance. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: Nozzle.type, id: "nozzleId"})
- * private nozzleModel: NozzleModel;
+ * @kosDependency({ modelType: Nozzle.type, id: "nozzleId" })
+ * private nozzle!: NozzleModel;
  * ```
  *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new NozzleModel 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 = Nozzle.factory("S1")({
- *    path: "core.assemby.nozzle.nozzle1",
- *  });
- * ```
- *
- * ## 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 NozzleModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (Nozzle.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to NozzleModel
- *    // and the compiler will know that the model has the NozzleModel interface
- *    model.pour();
- * }
- * ```
- *
- * ## 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 { Nozzle } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...Nozzle.registration,
- * };
- * ```
- *
- * ## registration.singleton
- *
- * The nozzle 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.
- *
- *  @category KOS Model Registration
- * */
+ * @category KOS Model Registration
+ */
 export declare const Nozzle: Readonly<KosModelRegistrationBean<NozzleModel, NozzleOptions>>;
 export {};
 //# sourceMappingURL=nozzle-model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nozzle-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/nozzle/nozzle-model.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"nozzle-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/nozzle/nozzle-model.ts"],"names":[],"mappings":"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"}

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

@@ -60,31 +60,21 @@ export interface AvailabilityResponse {
  *
  * Initiates a pour for the specified nozzle.
  *
- * Uses the KOS endpoint [POST] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/pour`
+ * Uses the KOS endpoint [POST] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/pour/selected/maxVolume`
  *
  * @param nozzleId - the nozzle id to pour from.
  * @param tracker - the tracker to use for the pour.  It will be returned in the future to allow consumers
  * to track the pour.
  * @category Service
- *
- * @example
- * ```typescript
- * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
- * ...
- *
- * await NozzleServices.pourPourable("nozzle-1", "my-tracker");
- * ```
  * @see {@link FutureManager.initiateFuture}
- * @returns - a Future that encapsulates the pour including its status and progress.
+ * @returns - the service response. Its data is the future that tracks the pour, which is registered with the {@link FutureManager}.
  **/
 export declare const pourPourable: (nozzleId: string, tracker: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
 /**
  *
  * Initiates a fixed named pour for the specified nozzle.
  *
- * Typically used for cases where a named cup size is to be poured where the volume of the pour is
- * dictated by the name.
- *
+ * Typically used for a named cup size, where the name determines the volume of the pour.
  *
  * Uses the KOS endpoint [POST] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/fixed/${name}`
  *
@@ -93,37 +83,18 @@ export declare const pourPourable: (nozzleId: string, tracker: string) => Promis
  * @param tracker - the tracker to use for the pour.  It will be returned in the future to allow consumers
  * to track the pour.
  * @category Service
- *
- * @example
- * ```typescript
- * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
- * ...
- *
- * await NozzleServices.pourPourable("nozzle-1", "my-tracker");
- * ```
  * @see {@link FutureManager.initiateFuture}
- * @returns - a Future that encapsulates the pour including its status and progress.
+ * @returns - the service response. Its data is the future that tracks the pour, which is registered with the {@link FutureManager}.
  **/
 export declare const pourNamedPourable: (name: string, nozzleId: string, tracker: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
 /**
  * Retrieves the availability nodes for a specified nozzle.
  *
- * Uses the KOS endpoint [GET] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/availability`
+ * Uses the KOS endpoint [GET] `${URL}${urlPrefix}/pipeline/beverage/availability`
  *
- * @param nozzleId - the nozzle id to retrieve availability for.
+ * @param urlPrefix - the nozzle's URL prefix (the `urlPrefix` of the {@link NozzleModel}).
  * @returns - the availability nodes for the specified nozzle.
  * @category Service
- *
- *  @example
- * ```typescript
- * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
- * ...
- *
- * const availability = await NozzleServices.getAvailability("nozzle-1");
- * if (availability?.status !== 200) {
- *     throw new Error("Failed to load nozzle availability");
- *  }
- * ```
  */
 export declare const getAvailability: (urlPrefix: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<AvailabilityResponse> | undefined>;
 /**
@@ -131,29 +102,17 @@ export declare const getAvailability: (urlPrefix: string) => Promise<import('@ko
  *
  * Uses the KOS endpoint [POST] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/select`
  *
- *
  * @param nozzleId - the nozzle id to select a pourable for.
  * @param payload - the payload to send to the endpoint.  The shape of the payload is determined by the
  * {@link ExtensionType.SelectedPourableMapper} extension.
  * @category Service
  * @see {@link ExtensionType.SelectedPourableMapper}
- * @returns - an emtpy response.
+ * @returns - an empty response.
  *
- *  @example
+ * @example
  * ```typescript
- * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * try {
- *    const response = await NozzleServices.selectPourable("nozzle-1", {
- *      beverage: "beverage-1",
- *      additional: ["flavor-1"],
- *    });
- *    if (response?.status !== 200) {
- *     throw new Error("Failed to select pourable");
- *    }
- * } catch (e) {
- *   console.error(e);
- * }
+ * // the default payload when no SelectedPourableMapper is registered
+ * await NozzleServices.selectPourable("nozzle-1", { bevId: "beverage-1" });
  * ```
  * */
 export declare const selectPourable: (nozzleId: string, payload: object) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
@@ -163,20 +122,7 @@ export declare const selectPourable: (nozzleId: string, payload: object) => Prom
  *
  * @param nozzleId - the nozzle id to clear the selected pourable for.
  * @category Service
- * @returns - an emtpy response.
- *  @example
- * ```typescript
- * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * try {
- *    const response = await NozzleServices.clearPourable("nozzle-1");
- *    if (response?.status !== 200) {
- *     throw new Error("Failed to clear pourable");
- *    }
- * } catch (e) {
- *   console.error(e);
- * }
- * ```
+ * @returns - an empty response.
  * */
 export declare const clearPourable: (nozzleId: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
 //# sourceMappingURL=nozzle-services.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nozzle-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/kos-dispense-sdk/src/models/models/nozzle/services/nozzle-services.ts"],"names":[],"mappings":"AAUA;;KAEK;AACL,MAAM,WAAW,gBAAgB,CAC/B,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAE5D;;SAEK;IACL,SAAS,EAAE,OAAO,CAAC;IACnB;;;;SAIK;IACL,KAAK,EAAE,MAAM,CAAC;IACd;;SAEK;IACL,OAAO,EAAE,OAAO,CAAC;IAEjB;;SAEK;IACL,EAAE,EAAE,MAAM,CAAC;IAEX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED;;KAEK;AACL,MAAM,WAAW,oBAAoB;IACnC;;;SAGK;IACL,OAAO,EAAE,OAAO,CAAC;IAEjB;;SAEK;IACL,MAAM,EAAE;QACN;;aAEK;QACL,SAAS,EAAE,gBAAgB,EAAE,CAAC;QAC9B;;aAEK;QACL,OAAO,EAAE,gBAAgB,EAAE,CAAC;QAE5B;;aAEK;QACL,MAAM,EAAE,gBAAgB,EAAE,CAAC;QAE3B;;aAEK;QACL,CAAC,CAAC,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAAC;KACjC,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;IAoBI;AACJ,eAAO,MAAM,YAAY,GAAU,UAAU,MAAM,EAAE,SAAS,MAAM,mFAWnE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;IAyBI;AACJ,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,EACZ,UAAU,MAAM,EAChB,SAAS,MAAM,mFAYhB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe,GAAU,WAAW,MAAM,oGAKtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BK;AACL,eAAO,MAAM,cAAc,GAAU,UAAU,MAAM,EAAE,SAAS,MAAM,mFAMrE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;KAoBK;AACL,eAAO,MAAM,aAAa,GAAU,UAAU,MAAM,uFAOnD,CAAC"}
+{"version":3,"file":"nozzle-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/kos-dispense-sdk/src/models/models/nozzle/services/nozzle-services.ts"],"names":[],"mappings":"AAUA;;KAEK;AACL,MAAM,WAAW,gBAAgB,CAC/B,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAE5D;;SAEK;IACL,SAAS,EAAE,OAAO,CAAC;IACnB;;;;SAIK;IACL,KAAK,EAAE,MAAM,CAAC;IACd;;SAEK;IACL,OAAO,EAAE,OAAO,CAAC;IAEjB;;SAEK;IACL,EAAE,EAAE,MAAM,CAAC;IAEX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED;;KAEK;AACL,MAAM,WAAW,oBAAoB;IACnC;;;SAGK;IACL,OAAO,EAAE,OAAO,CAAC;IAEjB;;SAEK;IACL,MAAM,EAAE;QACN;;aAEK;QACL,SAAS,EAAE,gBAAgB,EAAE,CAAC;QAC9B;;aAEK;QACL,OAAO,EAAE,gBAAgB,EAAE,CAAC;QAE5B;;aAEK;QACL,MAAM,EAAE,gBAAgB,EAAE,CAAC;QAE3B;;aAEK;QACL,CAAC,CAAC,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAAC;KACjC,CAAC;CACH;AAED;;;;;;;;;;;;IAYI;AACJ,eAAO,MAAM,YAAY,GAAU,UAAU,MAAM,EAAE,SAAS,MAAM,mFAWnE,CAAC;AAEF;;;;;;;;;;;;;;;IAeI;AACJ,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,EACZ,UAAU,MAAM,EAChB,SAAS,MAAM,mFAYhB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAU,WAAW,MAAM,oGAKtD,CAAC;AAEF;;;;;;;;;;;;;;;;;KAiBK;AACL,eAAO,MAAM,cAAc,GAAU,UAAU,MAAM,EAAE,SAAS,MAAM,mFAMrE,CAAC;AAEF;;;;;;;KAOK;AACL,eAAO,MAAM,aAAa,GAAU,UAAU,MAAM,uFAOnD,CAAC"}

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

@@ -1,90 +1,20 @@
 import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
 import { PumpModel, PumpOptions } from './types';
 /**
- * # Pump
+ * Registration bean for {@link PumpModel}.
  *
- * The registration bean includes convenience methods for creating and working with PumpModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `Pump.factory(id)(options)`. Returns the existing model when the id is already in use and ignores the options.
+ * - `predicate`: type guard that narrows an `IKosDataModel` to `PumpModel`.
+ * - `registration`: registry entry that can be spread into an `IKosRegistry["models"]` map.
  *
- * ## 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.
+ * Pump is not a singleton: each id has its own instance. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: Pump.type, id: "pumpId"})
- * private pumpModel: PumpModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new PumpModel 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 = Pump.factory("S1")({
- *    name: "S1",
- *    path: "core.assembly.pump.S1",
- *    beveragePour: true,
- *    type: "syrup",
- *    ingredientId: "1234532",
- *    holderPath: "core.dispenser.holder.s1",
- *    boardPath: "core.dispenser.board.s1",
- *    nozzlePath: "core.dispenser.nozzle.s1",
- *    inserted: true,
- *    category: "flavor",
- *    prevIngredientId: "1234567",
- *  });
- * ```
- *
- * ## 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 PumpModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (Pump.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to PumpModel
- *    // and the compiler will know that the model has the PumpModel interface
- *    model.updateAvailability(false);
- * }
+ * @kosDependency({ modelType: Pump.type, id: "pumpId" })
+ * private pump!: PumpModel;
  * ```
- *
- * ## 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 { Pump } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...Pump.registration,
- * };
- * ```
- *
- * ## registration.singleton
- *
- * The pump 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 Pump: Readonly<KosModelRegistrationBean<PumpModel, PumpOptions>>;
 //# sourceMappingURL=pump-model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pump-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/pump/pump-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,wBAAwB,EAEzB,MAAM,yBAAyB,CAAC;AAYjC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA8LtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqFK;AACL,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,wBAAwB,CAAC,SAAS,EAAE,WAAW,CAAC,CAWzE,CAAC"}
+{"version":3,"file":"pump-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/pump/pump-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,wBAAwB,EAEzB,MAAM,yBAAyB,CAAC;AAYjC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA8LtD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,wBAAwB,CAAC,SAAS,EAAE,WAAW,CAAC,CAWzE,CAAC"}

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

@@ -6,79 +6,20 @@ export declare enum PumpIndex {
     byNozzle = "byNozzle"
 }
 /**
- * # PumpContainer
+ * Registration bean for {@link PumpContainerModel}.
  *
- * The registration bean includes convenience methods for creating and working with PumpContainerModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `PumpContainer.factory(options)` returns the single instance, creating it on the first call.
+ * - `predicate`: type guard that narrows an `IKosDataModel` to `PumpContainerModel`.
+ * - `registration`: registry entry that can be spread into an `IKosRegistry["models"]` map.
  *
- * ## 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.
+ * PumpContainer is a singleton. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: PumpContainer.type})
- * private holderContainerModel: PumpContainerModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory function that can be used to create new PumpContainerModel 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 = PumpContainer.factory({ });
+ * @kosDependency({ modelType: PumpContainer.type })
+ * private pumpContainer!: PumpContainerModel;
  * ```
- *
- * ## 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 PumpContainerModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (PumpContainer.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to PumpContainerModel
- *    // and the compiler will know that the model has the PumpContainerModel 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 { PumpContainer } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...PumpContainer.registration,
- * };
- * ```
- *
- * ## registration.singleton
- * The PumpContainer 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 PumpContainer: SingletonKosModelRegistrationBean<PumpContainerModel, PumpContainerOptions>;
 //# sourceMappingURL=pump-container-model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pump-container-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/pump-container/pump-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iCAAiC,EAClC,MAAM,yBAAyB,CAAC;AASjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAQxE,oBAAY,SAAS;IACnB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,QAAQ,aAAa;CACtB;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EO;AACP,eAAO,MAAM,aAAa,EAAE,iCAAiC,CAC3D,kBAAkB,EAClB,oBAAoB,CAarB,CAAC"}
+{"version":3,"file":"pump-container-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/pump-container/pump-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iCAAiC,EAClC,MAAM,yBAAyB,CAAC;AASjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAQxE,oBAAY,SAAS;IACnB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,QAAQ,aAAa;CACtB;AAqED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,EAAE,iCAAiC,CAC3D,kBAAkB,EAClB,oBAAoB,CAarB,CAAC"}

package/models/models/types/intent.d.ts

@@ -16,36 +16,13 @@ export interface IntentAware extends IKosIdentifiable {
     performIntent(props: IntentAwareProps | string): Promise<FutureResponse | undefined>;
 }
 /**
- * Interface for models that can resolve intent volumes for various operations.
- *
- * This interface extends intent-aware models with the ability to calculate
- * appropriate volumes for specific intents (e.g., CALIBRATE, PRIME, FLUSH).
- * Typically implemented by holder and pump models that have ingredient assignments
- * and need to determine operation-specific volumes based on ingredient type,
- * pump configuration, or operational requirements.
- *
- * Use this interface in combination with {@link IntentAware} to create models
- * that can both determine appropriate volumes and execute the operations.
- *
- * @example
- * Using IntentContainer for calibration:
- * ```typescript
- * async function calibratePump(holder: HolderModel & IntentContainer) {
- *   // Resolve appropriate calibration volume
- *   const result = await holder.resolveIntentVolume("CALIBRATE");
- *   console.log(`Calibration requires ${result.volume} oz`);
- *
- *   // Execute calibration with resolved volume
- *   await holder.performIntent("CALIBRATE");
- * }
- * ```
+ * A model that can resolve the volume an intent (such as CALIBRATE, PRIME or FLUSH) will dispense.
+ * Holder and pump models implement it alongside {@link IntentAware}, which performs the intent.
  *
  * @example
- * Checking for ingredient assignment:
  * ```typescript
- * function canResolveVolume(model: IntentContainer): boolean {
- *   return model.ingredientId !== undefined;
- * }
+ * const { volume } = await holder.resolveIntentVolume("CALIBRATE");
+ * await holder.performIntent("CALIBRATE");
  * ```
  *
  * @category Model Interfaces
@@ -53,63 +30,19 @@ export interface IntentAware extends IKosIdentifiable {
  */
 export interface IntentContainer {
     /**
-     * Resolves the appropriate volume for a given intent operation.
+     * Resolves the volume the backend reports for an intent on the assigned ingredient.
      *
-     * Different intents require different volumes based on operational requirements:
-     * - **CALIBRATE**: Standard calibration volume based on ingredient type and pump configuration
-     * - **PRIME**: Volume needed to prime the line from reservoir to dispense point
-     * - **FLUSH**: Cleaning volume to flush contaminants from the system
-     * - **PURGE**: Volume to completely clear the line
-     *
-     * The resolved volume is calculated based on:
-     * - Ingredient type and properties
-     * - Pump hardware configuration (line length, diameter)
-     * - Operational parameters (flow rates, pressure)
-     * - Device-specific calibration data
-     *
-     * @param intent - The intent string identifier (e.g., "CALIBRATE", "PRIME", "FLUSH")
-     * @returns Promise resolving to object with `volume` property in ounces (oz)
-     *
-     * @throws May reject if ingredient is not assigned or volume cannot be determined
-     *
-     * @example
-     * Resolving calibration volume:
-     * ```typescript
-     * const result = await holder.resolveIntentVolume("CALIBRATE");
-     * console.log(`Calibration: ${result.volume} oz`);
-     * ```
-     *
-     * @example
-     * Handling volume resolution errors:
-     * ```typescript
-     * try {
-     *   const result = await holder.resolveIntentVolume("PRIME");
-     *   displayVolume(result.volume);
-     * } catch (error) {
-     *   console.error("Cannot resolve volume - ingredient may not be assigned");
-     * }
-     * ```
+     * @param intent - The intent identifier (e.g., "CALIBRATE", "PRIME", "FLUSH")
+     * @returns Promise resolving to an object with a `volume` property in ounces, or `-1` when no
+     *   volume is available
+     * @throws Rejects when the volume request to the backend fails
      */
     resolveIntentVolume(intent: string): Promise<{
         volume: number;
     }>;
     /**
-     * Optional ingredient identifier for the assigned ingredient.
-     *
-     * When undefined, no ingredient is assigned to this holder/pump and volume
-     * resolution operations may fail or return default values. Check this property
-     * before calling {@link resolveIntentVolume} to ensure an ingredient is assigned.
-     *
-     * @example
-     * Checking for assignment before resolving volume:
-     * ```typescript
-     * if (holder.ingredientId) {
-     *   const volume = await holder.resolveIntentVolume("CALIBRATE");
-     *   // Use volume...
-     * } else {
-     *   console.log("No ingredient assigned - cannot calibrate");
-     * }
-     * ```
+     * Id of the assigned ingredient, or undefined when none is assigned. Volume resolution needs an
+     * assigned ingredient.
      */
     ingredientId?: string;
 }