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

package/models/models/cartridge-agitator/cartridge-agitator-container-registration.d.ts

@@ -2,85 +2,21 @@ import { SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { CartridgeAgitatorContainerModel } from './cartridge-agitator-container-model';
 import { CartridgeAgitatorContainerOptions } from './types';
 /**
- * # CartridgeAgitatorContainer
+ * Registration bean for {@link CartridgeAgitatorContainerModel}.
  *
- * The registration bean includes convenience methods for creating and working with CartridgeAgitatorContainerModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `CartridgeAgitatorContainer.factory(options)` returns the single instance, creating it on the first call.
+ * - `guard`: type guard that narrows an `IKosDataModel` to `CartridgeAgitatorContainerModel`.
+ * - `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.
+ * CartridgeAgitatorContainer is a singleton. `KosModelRegistry.freestyle.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: CartridgeAgitatorContainer.type, id: "cartridgeAgitatorContainerId"})
- * private cartridgeAgitatorContainerModel: CartridgeAgitatorContainerModel;
+ * @kosDependency({ modelType: CartridgeAgitatorContainer.type })
+ * private cartridgeAgitatorContainer!: CartridgeAgitatorContainerModel;
  * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new CartridgeAgitatorContainerModel 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 = CartridgeAgitatorContainer.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 CartridgeAgitatorContainerModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (CartridgeAgitatorContainer.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to CartridgeAgitatorContainerModel
- *    // and the compiler will know that the model has the CartridgeAgitatorContainerModel 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 { CartridgeAgitatorContainer } from "@kosdev-code/kos-dispense-sdk";
- * ...
- * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
- * export const kosModels: IKosRegistry["models"] = {
- *  ...CartridgeAgitatorContainer.registration,
- * };
- * ```
- *
- * ## registration.singleton
- 
- * The cartridgeAgitatorContainer 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 CartridgeAgitatorContainer: SingletonKosModelRegistrationFactory<CartridgeAgitatorContainerModel, CartridgeAgitatorContainerOptions>;
 //# sourceMappingURL=cartridge-agitator-container-registration.d.ts.map

package/models/models/cartridge-agitator/cartridge-agitator-container-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cartridge-agitator-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/cartridge-agitator/cartridge-agitator-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AAM5F,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,SAAS,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,0BAA0B,0GAOnC,CAAC"}
+{"version":3,"file":"cartridge-agitator-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/cartridge-agitator/cartridge-agitator-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AAM5F,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,SAAS,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,0BAA0B,0GAOnC,CAAC"}

package/models/models/cartridge-agitator/cartridge-agitator-registration.d.ts

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

package/models/models/cartridge-agitator/cartridge-agitator-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cartridge-agitator-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/cartridge-agitator/cartridge-agitator-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EACL,sBAAsB,EAGvB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,iBAAiB,+EAM5B,CAAC"}
+{"version":3,"file":"cartridge-agitator-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/cartridge-agitator/cartridge-agitator-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EACL,sBAAsB,EAGvB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,+EAM5B,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"fcm-pump-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/fcm-pump/fcm-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":"fcm-pump-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/fcm-pump/fcm-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/models/freestyle-assembly/freestyle-assembly-registration.d.ts

@@ -2,87 +2,21 @@ import { SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
 import { FreestyleAssemblyModel } from './freestyle-assembly-model';
 import { FreestyleAssemblyOptions } from './types';
 /**
- * # FreestyleAssembly
+ * Registration bean for {@link FreestyleAssemblyModel}.
  *
- * The registration bean includes convenience methods for creating and working with FreestyleAssemblyModel instances.
+ * - `type`: the model type, used by the model registry and in `@kosDependency` declarations.
+ * - `factory`: `FreestyleAssembly.factory(options)` returns the single instance, creating it on the first call.
+ * - `guard`: type guard that narrows an `IKosDataModel` to `FreestyleAssemblyModel`.
+ * - `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.
+ * FreestyleAssembly is a singleton. `KosModelRegistry.freestyle.models()` registers it.
  *
  * @example
  * ```typescript
- *
- * @kosDependency({modelType: FreestyleAssembly.type, id: "freestyleAssemblyId"})
- * private freestyleAssemblyModel: FreestyleAssemblyModel;
- * ```
- *
- *
- * ## factory
- *
- * The factory method creates a factory function that can be used to create new FreestyleAssemblyModel 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 = FreestyleAssembly.factory({
- *   // Add option data
- * });
+ * @kosDependency({ modelType: FreestyleAssembly.type })
+ * private freestyleAssembly!: FreestyleAssemblyModel;
  * ```
- 
-
- *
- * ## 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 FreestyleAssemblyModel.
- *
- * @example
- * ```typescript
- *
- * const model: IKosDataModel = ...; // some model
- *
- * if (FreestyleAssembly.predicate(model)) {
- *    // if the function evaluates to true, the model is narrowed down to FreestyleAssemblyModel
- *    // and the compiler will know that the model has the FreestyleAssemblyModel 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 { FreestyleAssembly } 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(FreestyleAssembly);
- * ```
- *
- * ## registration.singleton
- 
- * The freestyleAssembly 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 FreestyleAssembly: SingletonKosModelRegistrationFactory<FreestyleAssemblyModel, FreestyleAssemblyOptions>;
 //# sourceMappingURL=freestyle-assembly-registration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"freestyle-assembly-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-assembly/freestyle-assembly-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAKzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,iBAAiB,wFAM5B,CAAC"}
+{"version":3,"file":"freestyle-assembly-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-assembly/freestyle-assembly-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAKzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,wFAM5B,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"freestyle-holder-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-holder/freestyle-holder-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,eAAe,2EAM1B,CAAC"}
+{"version":3,"file":"freestyle-holder-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-holder/freestyle-holder-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,2EAM1B,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"freestyle-nozzle-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-nozzle/freestyle-nozzle-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,eAAe,2EAM1B,CAAC"}
+{"version":3,"file":"freestyle-nozzle-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-freestyle-sdk/src/models/models/freestyle-nozzle/freestyle-nozzle-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,2EAM1B,CAAC"}