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

package/models/models/freestyle-pump/freestyle-pump-registration.d.ts

@@ -2,85 +2,21 @@ import { KosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { FreestylePumpModel } from './freestyle-pump-model';
 import { FreestylePumpOptions } from './types';
 /**
- * # FreestylePump
+ * Registration bean for {@link FreestylePumpModel}.
  *
- * The registration bean includes convenience methods for creating and working with FreestylePumpModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `FreestylePump.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 `FreestylePumpModel`.
+ * - `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.
+ * FreestylePump is not a singleton: each id has its own instance. `KosModelRegistry.freestyle.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: FreestylePump.type, id: "freestylePumpId"})
- * private freestylePumpModel: FreestylePumpModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new FreestylePumpModel 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 = FreestylePump.factory("freestylePumpId")({
- *   // 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 FreestylePumpModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (FreestylePump.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to FreestylePumpModel
- *    // and the compiler will know that the model has the FreestylePumpModel interface
- *    model.updateAvailability(false);
- * }
+ * @kosDependency({ modelType: FreestylePump.type, id: "freestylePumpId" })
+ * private freestylePump!: FreestylePumpModel;
  * ```
- *
- * ## 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 { FreestylePump } 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(FreestylePump);
- * ```
- *
- * ## registration.singleton
- 
- * The freestylePump 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 FreestylePump: KosModelRegistrationFactory<FreestylePumpModel, FreestylePumpOptions>;
 //# sourceMappingURL=freestyle-pump-registration.d.ts.map

package/models/models/freestyle-pump/freestyle-pump-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"freestyle-pump-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-pump/freestyle-pump-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,aAAa,uEAMxB,CAAC"}
+{"version":3,"file":"freestyle-pump-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-pump/freestyle-pump-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,uEAMxB,CAAC"}

package/models/models/remote-tray/remote-tray-container-registration.d.ts

@@ -2,85 +2,21 @@ import { SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { RemoteTrayContainerOptions } from './types';
 import { RemoteTrayContainerModel } from './remote-tray-container-model';
 /**
- * # RemoteTrayContainer
+ * Registration bean for {@link RemoteTrayContainerModel}.
  *
- * The registration bean includes convenience methods for creating and working with RemoteTrayContainerModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `RemoteTrayContainer.factory(options)` returns the single instance, creating it on the first call.
+ * - `guard`: type guard that narrows an `IKosDataModel` to `RemoteTrayContainerModel`.
+ * - `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.
+ * RemoteTrayContainer is a singleton. `KosModelRegistry.freestyle.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: RemoteTrayContainer.type, id: "remoteTrayContainerId"})
- * private remoteTrayContainerModel: RemoteTrayContainerModel;
+ * @kosDependency({ modelType: RemoteTrayContainer.type })
+ * private remoteTrayContainer!: RemoteTrayContainerModel;
  * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new RemoteTrayContainerModel 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 = RemoteTrayContainer.factory({
- *   // Add option data
- * });
- * ```
- 
-
- *
- * ## predicate
- *
- * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a RemoteTrayContainerModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (RemoteTrayContainer.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to RemoteTrayContainerModel
- *    // and the compiler will know that the model has the RemoteTrayContainerModel 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 { RemoteTrayContainer } from "@kosdev-code/kos-freestyle-sdk";
- * ...
- * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...RemoteTrayContainer.registration,
- * };
- * ```
- *
- * ## registration.singleton
- 
- * The remoteTrayContainer 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 RemoteTrayContainer: SingletonKosModelRegistrationFactory<RemoteTrayContainerModel, RemoteTrayContainerOptions>;
 //# sourceMappingURL=remote-tray-container-registration.d.ts.map

package/models/models/remote-tray/remote-tray-container-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-tray-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/remote-tray/remote-tray-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAM1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,mBAAmB,4FAM9B,CAAC"}
+{"version":3,"file":"remote-tray-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/remote-tray/remote-tray-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAM1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,4FAM9B,CAAC"}

package/models/models/remote-tray/remote-tray-model.d.ts

@@ -4,85 +4,12 @@ import { ActiveAware } from '../types/assembly';
 import { RemoteTrayOptions } from './types';
 export declare const MODEL_TYPE = "remote-tray-model";
 /**
- * Model for managing remote tray configurations in the KOS Freestyle system.
- *
- * A remote tray represents a physical or virtual tray that can be enabled/disabled
- * remotely and is associated with a holder in the dispensing system. This model
- * manages the tray's configuration, activation state, and trouble propagation
- * from its associated holder.
- *
- * ## Key Features
- * - Remote enable/disable capability through configuration properties
- * - Automatic trouble propagation from associated holder
- * - Active state management based on configuration
- * - Integration with the KOS dispensing system through holder references
- *
- * ## Properties
- * - `id` - Unique identifier for the remote tray
- * - `name` - Display name of the tray
- * - `holderPath` - Path reference to the associated holder model
- * - `configPath` - Configuration path for tray settings
- * - `remoteTrayEnabled` - Configuration property controlling tray activation
- * - `active` - Computed property indicating if the tray is currently active
- * - `holder` - Reference to the associated holder model
- * - `troubles` - Propagated troubles from the associated holder
- *
- * ## Methods
- * - `updateModel(options)` - Updates the model with new configuration options
- * - `init()` - Initializes the remote tray model
- * - `load()` - Loads the remote tray configuration and data
- *
- * @example
- * ```typescript
- * // Create a new remote tray instance
- * const remoteTray = RemoteTray.instance('tray-1')
- *   .options({
- *     name: 'Remote Tray 1',
- *     holderPath: '/holders/holder-1',
- *     configPath: '/config/trays/tray-1'
- *   })
- *   .build();
- *
- * // Check if tray is active
- * if (remoteTray.active) {
- *   console.log(`${remoteTray.name} is enabled`);
- * }
- *
- * // Access associated holder
- * const holder = remoteTray.holder;
- * console.log(`Holder status: ${holder?.status}`);
- * ```
- *
- * @example
- * ```typescript
- * // Monitor trouble states
- * const TrayStatus = ({ tray }: { tray: RemoteTrayModel }) => {
- *   const troubles = tray.troubles;
- *   const isEnabled = tray.remoteTrayEnabled.value;
- *
- *   return (
- *     <div>
- *       <h3>{tray.name}</h3>
- *       <p>Status: {isEnabled ? 'Enabled' : 'Disabled'}</p>
- *       {troubles.length > 0 && (
- *         <Alert severity="warning">
- *           {troubles.length} issue(s) detected
- *         </Alert>
- *       )}
- *     </div>
- *   );
- * };
- * ```
+ * A tray that can be enabled or disabled remotely and is associated with a holder. The tray is
+ * active when its `enabled` config property is set, and it reports its holder's troubles as its own.
  *
  * @example
  * ```typescript
- * // Programmatically enable/disable tray
- * async function toggleRemoteTray(tray: RemoteTrayModel) {
- *   const currentState = tray.remoteTrayEnabled.value;
- *   await tray.remoteTrayEnabled.setValue(!currentState);
- *
- *   console.log(`Tray ${tray.name} is now ${!currentState ? 'enabled' : 'disabled'}`);
- * }
+ * tray.remoteTrayEnabled.updateProperty(!tray.active);
  * ```
  *
  * @category KOS Model
@@ -121,8 +48,7 @@ export declare class RemoteTrayModelImpl implements IKosDataModel, IKosIdentifia
      */
     get troubles(): TroubleModel<any>[];
     /**
-     * Gets the highest priority trouble status.
-     * Currently returns empty string as troubles are managed by the holder.
+     * Always an empty string; trouble status is reported by the holder.
      *
      * @returns Empty string (trouble status handled by holder)
      */
@@ -134,38 +60,31 @@ export declare class RemoteTrayModelImpl implements IKosDataModel, IKosIdentifia
      */
     get troublesByType(): Record<string, TroubleModel<any>[]>;
     /**
-     * Updates the model with new configuration options.
-     * Can be used to modify the holder path, config path, or name after initialization.
+     * Accepts updated options. The tray keeps its original holder path, config path and name.
      *
      * @param _options - New configuration options for the remote tray
      */
     updateModel(_options: RemoteTrayOptions): void;
     /**
-     * Gets the associated holder model for this remote tray.
-     * Uses synchronous model lookup to retrieve the holder by path.
+     * The holder model referenced by `holderPath`.
      *
      * @returns The HolderModel instance referenced by holderPath, or undefined if not found
      */
     get holder(): HolderModel<any>;
     /**
-     * Determines if the remote tray is currently active.
-     * Active state is based on the remoteTrayEnabled configuration property.
+     * Whether the tray is enabled, from the `remoteTrayEnabled` config property.
      *
      * @returns true if the tray is enabled, false otherwise
      */
     get active(): boolean;
     /**
      * Initializes the remote tray model.
-     * Called during the model lifecycle initialization phase.
-     * Sets up initial state and prepares the model for use.
      *
      * @returns Promise that resolves when initialization is complete
      */
     init(): Promise<void>;
     /**
-     * Loads the remote tray configuration and associated data.
-     * Called during the model lifecycle load phase.
-     * Typically loads configuration settings and establishes holder references.
+     * Loads the remote tray model.
      *
      * @returns Promise that resolves when loading is complete
      */

package/models/models/remote-tray/remote-tray-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-tray-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/remote-tray/remote-tray-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EAEjB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACb,MAAM,yBAAyB,CAAC;AAQjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,eAAO,MAAM,UAAU,sBAAsB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AACH,MAAM,MAAM,eAAe,GAAG,oBAAoB,CAAC,mBAAmB,CAAC,CAAC;AAKxE;;;;;;GAMG;AACH,qBACa,mBACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY;IAErE,qDAAqD;IACrD,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAEjC,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAKhF,iBAAiB,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;gBAG7C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,kBAAkB;IAU7B;;;;;OAKG;IACH,IAAI,QAAQ,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAElC;IAED;;;;;OAKG;IACH,IAAI,aAAa,WAEhB;IAED;;;;OAIG;IACH,IAAI,cAAc,wCAEjB;IAED;;;;;OAKG;IACH,WAAW,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAI9C;;;;;OAKG;IACH,IAAI,MAAM,qBAET;IAED;;;;;OAKG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAID;;;;;;OAMG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;;;OAMG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}
+{"version":3,"file":"remote-tray-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/remote-tray/remote-tray-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EAEjB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACb,MAAM,yBAAyB,CAAC;AAQjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,eAAO,MAAM,UAAU,sBAAsB,CAAC;AAE9C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,eAAe,GAAG,oBAAoB,CAAC,mBAAmB,CAAC,CAAC;AAKxE;;;;;;GAMG;AACH,qBACa,mBACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY;IAErE,qDAAqD;IACrD,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAEjC,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAKhF,iBAAiB,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;gBAG7C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,kBAAkB;IAU7B;;;;;OAKG;IACH,IAAI,QAAQ,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAElC;IAED;;;;OAIG;IACH,IAAI,aAAa,WAEhB;IAED;;;;OAIG;IACH,IAAI,cAAc,wCAEjB;IAED;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAI9C;;;;OAIG;IACH,IAAI,MAAM,qBAET;IAED;;;;OAIG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAID;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/models/models/remote-tray/remote-tray-registration.d.ts

@@ -2,88 +2,21 @@ import { KosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { RemoteTrayOptions } from './types';
 import { RemoteTrayModel } from './remote-tray-model';
 /**
- * # RemoteTray
+ * Registration bean for {@link RemoteTrayModel}.
  *
- * The registration bean includes convenience methods for creating and working with RemoteTrayModel instances.
-
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `RemoteTray.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 `RemoteTrayModel`.
+ * - `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.
+ * RemoteTray is not a singleton: each id has its own instance. `KosModelRegistry.freestyle.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: RemoteTray.type, id: "remoteTrayId"})
- * private remoteTrayModel: RemoteTrayModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new RemoteTrayModel 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 = RemoteTray.factory("remoteTrayId")({
- *   // 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 RemoteTrayModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (RemoteTray.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to RemoteTrayModel
- *    // and the compiler will know that the model has the RemoteTrayModel interface
- *    model.updateAvailability(false);
-
- * }
+ * @kosDependency({ modelType: RemoteTray.type, id: "remoteTrayId" })
+ * private remoteTray!: RemoteTrayModel;
  * ```
- *
- * ## 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 { RemoteTray } 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(RemoteTray);
- * ```
- *
- * ## registration.singleton
- 
- * The remoteTray 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 RemoteTray: KosModelRegistrationFactory<RemoteTrayModel, RemoteTrayOptions>;
 //# sourceMappingURL=remote-tray-registration.d.ts.map

package/models/models/remote-tray/remote-tray-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-tray-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/remote-tray/remote-tray-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAGL,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmFK;AACL,eAAO,MAAM,UAAU,iEAMrB,CAAC"}
+{"version":3,"file":"remote-tray-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/remote-tray/remote-tray-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAGL,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,iEAMrB,CAAC"}

package/models/models/spm-pump/spm-pump-registration.d.ts

@@ -2,85 +2,21 @@ import { KosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { SpmPumpOptions } from './types';
 import { SpmPumpModel } from './spm-pump-model';
 /**
- * # SpmPump
+ * Registration bean for {@link SpmPumpModel}.
  *
- * The registration bean includes convenience methods for creating and working with SpmPumpModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: curried factory, `SpmPump.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 `SpmPumpModel`.
+ * - `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.
+ * SpmPump is not a singleton: each id has its own instance. `KosModelRegistry.freestyle.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: SpmPump.type, id: "spmPumpId"})
- * private spmPumpModel: SpmPumpModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new SpmPumpModel 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 = SpmPump.factory("spmPumpId")({
- *   // 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 SpmPumpModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (SpmPump.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to SpmPumpModel
- *    // and the compiler will know that the model has the SpmPumpModel interface
- *    model.updateAvailability(false);
- * }
+ * @kosDependency({ modelType: SpmPump.type, id: "spmPumpId" })
+ * private spmPump!: SpmPumpModel;
  * ```
- *
- * ## 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 { SpmPump } 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(SpmPump);
- * ```
- *
- * ## registration.singleton
- 
- * The spmPump 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 SpmPump: KosModelRegistrationFactory<SpmPumpModel, SpmPumpOptions>;
 //# sourceMappingURL=spm-pump-registration.d.ts.map

package/models/models/spm-pump/spm-pump-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spm-pump-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/spm-pump/spm-pump-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,OAAO,2DAMlB,CAAC"}
+{"version":3,"file":"spm-pump-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/spm-pump/spm-pump-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,OAAO,2DAMlB,CAAC"}

package/models/utils/extensions/assembly/types.d.ts

@@ -4,39 +4,8 @@ import { IceAgitatorModel } from '../../../models/ice-agitator';
 export type AgitatorModel = CarbAgitatorModel | IceAgitatorModel;
 export type AgitatorTypes = "iceAgitator" | "carbAgitator";
 /**
- * extension to the base assembly returned from the backend.  These are additional properties that are not
- * on the base assembly but added as part of an application.
- *
- * @example
- * ```json
- * {
-      "assemblies": [
-          {
-              "boards": [
-                 ...
-              ],
-              "holders": {
-                 ...
-              },
-              "nozzles": [
-                 ...
-              ],
-              "core": true,
-              "name": "core",
-              "path": "assembly.core",
-              // extra properties added to the assembly
-              "carbAgitator": {
-                  "name": "carbAgitator",
-                  "path": "assembly.core.board:ksm.carbAgitator"
-              },
-              "iceAgitator": {
-                  "name": "iceAgitator",
-                  "path": "assembly.core.board:ksm.iceAgitator"
-              },
-          }
-      ]
-  }
-```
+ * Freestyle properties added to each assembly in the backend assembly response: the ice and carb
+ * agitators, cartridge agitators and remote trays.
  */
 export interface FreestyleResponseExt {
     iceAgitator?: {
@@ -69,60 +38,8 @@ export interface FreestyleResponseExt {
 export interface FreestyleNozzleExt {
 }
 /**
-   *  extension to the holder types on the assembly as returned from the backend.  These
-   * are additional properties that are not on the base assembly but added as part of an application.
-   *
-   * @example
-   *
-   * In this example, the maxVolumeML and remainingVolumeML are added to the holder.
-   * ```json
-   * {
-          "assemblies": [
-              {
-                  "boards": [
-                     ...
-                  ],
-                  "holders": {
-                      "carb": [
-                        ...
-                      ],
-                      "ns": [
-                        ...
-                      ],
-                      "micros.0": [
-                          {
-                              "agitated": false,
-                              "ingredientId": "1048588",
-                              "name": "S1",
-                              "maxVolumeML": 680,
-                              "remainingVolumeML": 520,
-                              "path": "assembly.core.holder:S1"
-                          },
-                          {
-                              "agitated": false,
-                              "ingredientId": "1050608",
-                              "name": "S2",
-                              "maxVolumeML": 680,
-                              "remainingVolumeML": 520,
-                              "path": "assembly.core.holder:S2"
-                          },
-                      ...
-                      ],
-                      "micros.1": [
-                          ...
-                 
-                      ],
-                      "water": [
-                         ...
-                      ]
-                  },
-                  "nozzles": [],
-                 ...
-              }
-          ]
-      }
-  ```
-   */
+ * Freestyle properties added to each holder in the backend assembly response.
+ */
 export interface FreestyleHolderExt {
     agitated?: boolean;
 }