@kosdev-code/kos-dispense-sdk 3.0.25 → 3.0.27

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

@@ -1,83 +1,20 @@
 import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
 import { BoardModel, BoardOptions } from './types';
 /**
- * # Board
+ * Registration bean for {@link BoardModel}.
  *
- * The registration bean includes convenience methods for creating and working with BoardModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `Board.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 `BoardModel`.
+ * - `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.
+ * Board is not a singleton: each id has its own instance. `KosModelRegistry.dispense.models()` registers it.
  *
  * @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,
- * };
+ * @kosDependency({ modelType: Board.type, id: "boardId" })
+ * private board!: BoardModel;
  * ```
- *
- * ## 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

@@ -1 +1 @@
-{"version":3,"file":"board-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/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"}
+{"version":3,"file":"board-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/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;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,KAAK,EAAE,QAAQ,CAC1B,wBAAwB,CAAC,UAAU,EAAE,YAAY,CAAC,CAWnD,CAAC"}

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

@@ -2,87 +2,21 @@ import { SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { DeviceAssemblyModel } from './device-assembly-model';
 import { DeviceAssemblyOptions } from './types';
 /**
- * # DeviceAssembly
+ * Registration bean for {@link DeviceAssemblyModel}.
  *
- * The registration bean includes convenience methods for creating and working with DeviceAssemblyModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `DeviceAssembly.factory(options)` returns the single instance, creating it on the first call.
+ * - `guard`: type guard that narrows an `IKosDataModel` to `DeviceAssemblyModel`.
+ * - `instance()`: reads the model, or builds it from options.
+ * - `register()`: registers the model, and any related models, with the model registry.
  *
- * ## 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.
+ * DeviceAssembly is a singleton. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: DeviceAssembly.type, id: "deviceAssemblyId"})
- * private deviceAssemblyModel: DeviceAssemblyModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new DeviceAssemblyModel instances.
- *
- 
- * As this is a singleton model, the factory function accepts the model options as its argument.
- *
- * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- * ```typescript
- * const model = DeviceAssembly.factory({
- *   // Add option data
- * });
+ * @kosDependency({ modelType: DeviceAssembly.type })
+ * private deviceAssembly!: DeviceAssemblyModel;
  * ```
- 
-
- *
- * ## predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a DeviceAssemblyModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (DeviceAssembly.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to DeviceAssemblyModel
- *    // and the compiler will know that the model has the DeviceAssemblyModel interface
- *    model.updateAvailability(false);
- * }
- * ```
- *
- * ## registration
- *
- * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
- * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
- *
- *
- * @example
- *
- * In an application registration file you can declare the model registration as follows:
- *
- * **registration.ts**
- * ```typescript
- * import { DeviceAssembly } from "@kos-ui/project-models";
- * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
- *
- * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
- *
- * KosModelRegistry.dispense
- * .models()
- * .model(DeviceAssembly);
- * ```
- *
- * ## registration.singleton
- 
- * The deviceAssembly model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
- * If the model does not yet exist, it will be created passing in the provided options to initialize it.
- *
- * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
- 
- * */
+ */
 export declare const DeviceAssembly: SingletonKosModelRegistrationFactory<DeviceAssemblyModel, DeviceAssemblyOptions>;
 //# sourceMappingURL=device-assembly-registration.d.ts.map

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

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

package/models/models/generic-pour/generic-pour-registration.d.ts

@@ -2,85 +2,22 @@ import { KosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { GenericPourOptions } from './types';
 import { GenericPourModel } from './generic-pour-model';
 /**
- * # GenericPour
+ * Registration bean for {@link GenericPourModel}.
  *
- * The registration bean includes convenience methods for creating and working with GenericPourModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `GenericPour.factory(id)(options)`. Returns the existing model when the id is already in use and ignores the options.
+ * - `guard`: type guard that narrows an `IKosDataModel` to `GenericPourModel`.
+ * - `instance(id)`: reads the model, or builds it from options.
+ * - `register()`: registers the model, and any related models, with the model registry.
  *
- * ## 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.
+ * GenericPour is not a singleton: each id has its own instance.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: GenericPour.type, id: "genericPourId"})
- * private genericPourModel: GenericPourModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new GenericPourModel 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 = GenericPour.factory("genericPourId")({
- *   // 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 GenericPourModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (GenericPour.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to GenericPourModel
- *    // and the compiler will know that the model has the GenericPourModel 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 { GenericPour } from "@kos-ui/project-models";
  * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
  *
- * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
- *
- * KosModelRegistry.dispense
- * .models()
- * .model(GenericPour);
+ * KosModelRegistry.dispense.models().model(GenericPour);
  * ```
- *
- * ## registration.singleton
- 
- * The genericPour 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 GenericPour: KosModelRegistrationFactory<GenericPourModel, GenericPourOptions>;
 //# sourceMappingURL=generic-pour-registration.d.ts.map

package/models/models/generic-pour/generic-pour-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generic-pour-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/generic-pour/generic-pour-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,WAAW,mEAMtB,CAAC"}
+{"version":3,"file":"generic-pour-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-dispense-sdk/src/models/models/generic-pour/generic-pour-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,mEAMtB,CAAC"}

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

@@ -9,84 +9,20 @@ export interface ContainerTroubleData {
     unknonwnIngredientId?: string;
 }
 /**
- * # Holder
+ * Registration bean for {@link HolderModel}.
  *
- * The registration bean includes convenience methods for creating and working with HolderModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `Holder.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 `HolderModel`.
+ * - `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.
+ * Holder is not a singleton: each id has its own instance. `KosModelRegistry.dispense.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: Holder.type, id: "holderId"})
- * private holderModel: HolderModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new HolderModel instances.
- *
- * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
- *
- * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
- * in this case and the existing model will be returned in its current state.
- *
- * @example
- *
- * ```typescript
- * const model = Holder.factory("S1")({
- *  path: "core.dispenser.holder.s1",
- *  name: "S1",
- *  ingredientId: "1234532",
- *  assemblyName: "",
- *  type: "syrup",
- *  });
- * ```
- *
- * ## predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a HolderModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (Holder.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to HolderModel
- *    // and the compiler will know that the model has the HolderModel interface
- *    model.updateAvailability(false);
- * }
+ * @kosDependency({ modelType: Holder.type, id: "holderId" })
+ * private holder!: HolderModel;
  * ```
- *
- * ## registration
- *
- * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
- * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
- *
- *
- * @example
- *
- * In an application registration file you can declare the model registration as follows:
- *
- * **registration.ts**
- * ```typescript
- * import { Holder } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...Holder.registration,
- * };
- * ```
- *
- * ## registration.singleton
- *
- * The holder model is not a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
- * If the factory function is called with an ID that already exists, the existing model will be returned.
- * */
+ */
 export declare const Holder: Readonly<KosModelRegistrationBean<HolderModel, HolderOptions>>;
 //# sourceMappingURL=holder-model.d.ts.map

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"holder-container-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/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;AA4HjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EO;AACP,eAAO,MAAM,eAAe,EAAE,iCAAiC,CAC7D,oBAAoB,EACpB,sBAAsB,CAavB,CAAC"}
+{"version":3,"file":"holder-container-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/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;AA4HjB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,EAAE,iCAAiC,CAC7D,oBAAoB,EACpB,sBAAsB,CAavB,CAAC"}

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

@@ -1,85 +1,20 @@
 import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
 import { IngredientModel, IngredientOptions } from './types';
 /**
- * # Ingredient
+ * Registration bean for {@link IngredientModel}.
  *
- * The registration bean includes convenience methods for creating and working with IngredientModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `Ingredient.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 `IngredientModel`.
+ * - `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.
+ * Ingredient is not a singleton: each id has its own instance. `KosModelRegistry.dispense.models()` registers it.
  *
  * @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);
- * }
+ * @kosDependency({ modelType: Ingredient.type, id: "ingredientId" })
+ * private ingredient!: IngredientModel;
  * ```
- *
- * ## 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

@@ -1 +1 @@
-{"version":3,"file":"ingredient-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/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;AAuDlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,UAAU,EAAE,QAAQ,CAC/B,wBAAwB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAW7D,CAAC"}
+{"version":3,"file":"ingredient-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/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;AAuDlE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,EAAE,QAAQ,CAC/B,wBAAwB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAW7D,CAAC"}

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

@@ -25,16 +25,9 @@ export interface IngredientOptions<AdditionalData extends object = any> {
  *
  * 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.
+ * @typeParam AdditionalData - Application data added to an ingredient by the
+ * {@link ExtensionType.IngredientMapper} extension point, such as an image url. It is exposed on
+ * `data`, so `IngredientModel<{ icon: string }>` types `model.data.icon`.
  *
  * @category Model
  */