@kosdev-code/kos-ddk-models 0.1.0-dev.10

package/lib/trouble-action/trouble-action-model.d.ts

@@ -0,0 +1,279 @@
+import { IKosDataModel, IKosIdentifiable, KosData, KosLoggerAware, PublicModelInterface, SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
+import { TroubleActionOptions } from './types';
+/**
+ * Model type identifier for the TroubleAction singleton model.
+ *
+ * This constant is used for model registration and identification within
+ * the KOS framework. As a singleton model, only one instance exists per
+ * application lifecycle.
+ *
+ * @category Model Configuration
+ */
+export declare const MODEL_TYPE = "trouble-action-model";
+/**
+ * Public interface type for the TroubleActionModel.
+ *
+ * This type represents the publicly accessible interface of the TroubleActionModel,
+ * exposing only the methods and properties intended for external consumption.
+ * Use this type when declaring dependencies on the TroubleActionModel.
+ *
+ * @category Model Types
+ * @see {@link TroubleActionModelImpl} for the implementation details
+ */
+export type TroubleActionModel = PublicModelInterface<TroubleActionModelImpl>;
+/**
+ * Interface definition for TroubleActionModel implementation.
+ *
+ * Manages trouble action state by monitoring active troubles and mapping them
+ * to configurable state key-value pairs. This singleton model acts as a centralized
+ * coordinator between the trouble system and UI state management.
+ *
+ * @author Mark Pomerant (mark@matrica.ca)
+ * @version 2.1.1
+ * @category Model Interface
+ */
+export interface TroubleActionModelImpl extends KosLoggerAware {
+}
+/**
+ * Singleton model that manages trouble action state for beverage dispensing systems.
+ *
+ * The TroubleActionModel monitors active troubles in the system and maintains a
+ * reactive state object that maps trouble types to configured state values. This
+ * enables UI components to respond to trouble conditions without directly coupling
+ * to the trouble system.
+ *
+ * **Key Features:**
+ * - Singleton model ensuring single source of truth for trouble action state
+ * - Automatic synchronization with TroubleContainer changes
+ * - Configurable mapping between trouble types and state representations
+ * - Reactive state updates via KosData observables
+ * - Support for custom state keys and values per trouble type
+ *
+ * **Architecture:**
+ * - Depends on TroubleContainerModel for trouble data
+ * - Uses @kosModelEffect for reactive trouble monitoring
+ * - Maintains internal mapping of trouble definitions to state values
+ *
+ * @example
+ * ```typescript
+ * // Register and create the singleton TroubleActionModel
+ * import { TroubleAction } from '@kosdev-code/kos-ddk-models';
+ *
+ * const troubleActionModel = TroubleAction.instance().options({
+ *   definitions: [
+ *     {
+ *       troubleType: 'InsufficientAgitationTrouble',
+ *       stateKey: 'agitationRequired',
+ *       stateValue: 'true'
+ *     },
+ *     {
+ *       troubleType: 'CartridgeEmptyTrouble',
+ *       stateKey: 'cartridgeStatus',
+ *       stateValue: 'empty'
+ *     }
+ *   ]
+ * }).build();
+ *
+ * // Access state in React components
+ * const agitationRequired = troubleActionModel.state.agitationRequired;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Monitor active trouble in a React component
+ * import { useKosModel } from '@kosdev-code/kos-ui-sdk';
+ * import { TroubleAction } from '@kosdev-code/kos-ddk-models';
+ *
+ * function TroubleIndicator() {
+ *   const troubleAction = useKosModel(TroubleAction);
+ *   const activeTroubleType = troubleAction.activeTroubleType;
+ *
+ *   if (!activeTroubleType) {
+ *     return <div>No active troubles</div>;
+ *   }
+ *
+ *   return <div>Active: {activeTroubleType}</div>;
+ * }
+ * ```
+ *
+ * @category DDK Models
+ * @see {@link TroubleContainerModel} for the underlying trouble data source
+ * @see {@link TroubleActionOptions} for configuration options
+ * @see {@link TroubleActionData} for trouble definition structure
+ *
+ * @kosService ddk.trouble-action
+ * @kosApiLevel 1
+ */
+export declare class TroubleActionModelImpl implements IKosDataModel, IKosIdentifiable {
+    /**
+     * Registration factory for creating TroubleActionModel instances.
+     *
+     * This static property is automatically populated by the @kosModel decorator
+     * and provides the registration interface for creating and configuring the
+     * singleton TroubleActionModel instance.
+     *
+     * @example
+     * ```typescript
+     * const troubleAction = TroubleActionModelImpl.Registration
+     *   .instance()
+     *   .options({ definitions: [...] })
+     *   .build();
+     * ```
+     *
+     * @category Model Registration
+     */
+    static Registration: SingletonKosModelRegistrationFactory<TroubleActionModel, TroubleActionOptions>;
+    /**
+     * Unique identifier for this model instance.
+     *
+     * Set during construction and used for model lifecycle management
+     * and debugging purposes.
+     *
+     * @category Model Properties
+     */
+    id: string;
+    /**
+     * Dependency on the TroubleContainer singleton model.
+     *
+     * Provides access to the system's active troubles collection. Changes to
+     * the trouble container automatically trigger state updates via the
+     * handleTroubleActions effect.
+     *
+     * @category Dependencies
+     * @see {@link TroubleContainerModel}
+     */
+    private troubleContainer;
+    /**
+     * Observable state object mapping trouble state keys to values.
+     *
+     * This reactive state object is automatically updated when troubles are
+     * added or removed from the system. Keys and values are determined by
+     * the trouble action definitions provided during model initialization.
+     *
+     * State keys that no longer have associated active troubles are set to
+     * undefined.
+     *
+     * @example
+     * ```typescript
+     * // Access state values
+     * const isAgitationRequired = troubleActionModel.state.agitationRequired;
+     *
+     * // State is reactive - updates automatically propagate to React components
+     * ```
+     *
+     * @category Model State
+     */
+    state: KosData<Record<string, string | undefined>>;
+    /**
+     * Internal mapping of trouble types to their action definitions.
+     *
+     * Built from the definitions array provided in TroubleActionOptions during
+     * construction. Used for efficient lookup when processing trouble changes.
+     *
+     * @category Internal State
+     */
+    private troubleActionData;
+    /**
+     * Creates a new TroubleActionModel instance.
+     *
+     * Initializes the model with trouble action definitions that map trouble
+     * types to state key-value pairs. The model begins monitoring the trouble
+     * container immediately upon creation.
+     *
+     * @param modelId - Unique identifier for this model instance
+     * @param options - Configuration options containing trouble action definitions
+     * @param context - KOS creation context providing logger and framework services
+     *
+     * @category Lifecycle
+     */
+    constructor(modelId: string, options: TroubleActionOptions);
+    /**
+     * Gets the first active trouble that has an associated action definition.
+     *
+     * Returns the first trouble found that matches any of the configured trouble
+     * action definitions. If multiple troubles are active, priority is determined
+     * by the order of trouble type keys in the troubleActionData object.
+     *
+     * @returns The active trouble model, or undefined if no matching troubles exist
+     *
+     * @example
+     * ```typescript
+     * const trouble = troubleActionModel.activeTrouble;
+     * if (trouble) {
+     *   console.log(`Active trouble: ${trouble.type}`);
+     *   console.log(`Resolvable: ${trouble.resolvable}`);
+     * }
+     * ```
+     *
+     * @category Trouble Access
+     * @see {@link TroubleContainerModel} for trouble data structure
+     */
+    get activeTrouble(): import('@kosdev-code/kos-ui-sdk').TroubleModel<any> | undefined;
+    /**
+     * Gets the type of the first active trouble with an associated action definition.
+     *
+     * Convenience getter that extracts the trouble type from the active trouble.
+     * Commonly used for conditional UI rendering based on trouble type.
+     *
+     * @returns The active trouble type string, or undefined if no troubles are active
+     *
+     * @example
+     * ```typescript
+     * const troubleType = troubleActionModel.activeTroubleType;
+     * if (troubleType === 'InsufficientAgitationTrouble') {
+     *   // Show agitation required UI
+     * }
+     * ```
+     *
+     * @category Trouble Access
+     */
+    get activeTroubleType(): string | undefined;
+    /**
+     * Reactive effect that synchronizes trouble action state with active troubles.
+     *
+     * Automatically called when the trouble container's data changes. Updates the
+     * model's state object to reflect current trouble conditions:
+     * - Adds state entries for newly active troubles
+     * - Removes state entries (sets to undefined) for resolved troubles
+     * - Uses configured stateKey and stateValue from trouble definitions
+     *
+     * The effect dependencies ensure this method runs whenever troubles are added
+     * or removed from the system.
+     *
+     * @remarks
+     * This method is decorated with @kosModelEffect to establish reactive dependencies
+     * on the trouble container's data. It should not be called directly.
+     *
+     * @category Effects
+     * @see {@link kosModelEffect} for reactive effect pattern documentation
+     */
+    handleTroubleActions(): void;
+}
+/**
+ * Singleton registration factory for the TroubleActionModel.
+ *
+ * Use this export to create and configure the TroubleAction singleton model
+ * in your application. The factory provides a fluent interface for instance
+ * creation and configuration.
+ *
+ * @example
+ * ```typescript
+ * import { TroubleAction } from '@kosdev-code/kos-ddk-models';
+ *
+ * const troubleAction = TroubleAction.instance().options({
+ *   definitions: [
+ *     {
+ *       troubleType: 'InsufficientAgitationTrouble',
+ *       stateKey: 'agitationRequired',
+ *       stateValue: 'true'
+ *     }
+ *   ]
+ * }).build();
+ * ```
+ *
+ * @category Model Registration
+ * @see {@link TroubleActionModel} for the model interface
+ * @see {@link TroubleActionOptions} for configuration options
+ */
+export declare const TroubleAction: SingletonKosModelRegistrationFactory<TroubleActionModel, TroubleActionOptions>;
+//# sourceMappingURL=trouble-action-model.d.ts.map

package/lib/trouble-action/trouble-action-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-action-model.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/trouble-action/trouble-action-model.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,OAAO,EACP,cAAc,EACd,oBAAoB,EACpB,oCAAoC,EAErC,MAAM,yBAAyB,CAAC;AASjC,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEvE;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,yBAAyB,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAE9E;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;CAAG;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,qBAEa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,YAAY,EAAE,oCAAoC,CACvD,kBAAkB,EAClB,oBAAoB,CACrB,CAAC;IAEF;;;;;;;OAOG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;;;;;OASG;IAEH,OAAO,CAAC,gBAAgB,CAAyB;IAEjD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAEnD;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB,CAAoC;IAE7D;;;;;;;;;;;;OAYG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,oBAAoB;IAW1D;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,aAAa,oEAgBhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,iBAAiB,uBAEpB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IAIH,oBAAoB;CAsBrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,aAAa,gFAAsC,CAAC"}

package/lib/trouble-action/types/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Definition for a single trouble action mapping.
+ *
+ * Describes how a specific trouble type should be represented in the
+ * TroubleActionModel's state object. Each definition maps a trouble type
+ * to a state key-value pair that UI components can observe.
+ *
+ * @example
+ * ```typescript
+ * const agitationTroubleAction: TroubleActionData = {
+ *   troubleType: 'InsufficientAgitationTrouble',
+ *   stateKey: 'agitationRequired',
+ *   stateValue: 'true'
+ * };
+ * ```
+ *
+ * @category Trouble Configuration
+ * @see {@link TroubleActionOptions} for how definitions are provided to the model
+ */
+export interface TroubleActionData {
+  /**
+   * The trouble type identifier to monitor.
+   *
+   * Must match the type property of trouble objects in the TroubleContainer.
+   * When a trouble of this type becomes active, the associated state entry
+   * will be created.
+   *
+   * @example "InsufficientAgitationTrouble"
+   * @example "CartridgeEmptyTrouble"
+   */
+  troubleType: string;
+
+  /**
+   * The key to use in the state object for this trouble.
+   *
+   * Defines the property name in the TroubleActionModel's state object.
+   * UI components will observe this key to react to the trouble condition.
+   *
+   * @example "agitationRequired"
+   * @example "cartridgeStatus"
+   */
+  stateKey: string;
+
+  /**
+   * The value to set in the state object when this trouble is active.
+   *
+   * When the trouble becomes active, this value is assigned to the stateKey.
+   * When the trouble is resolved, the stateKey is set to undefined.
+   *
+   * @example "true"
+   * @example "empty"
+   * @example "maintenance_required"
+   */
+  stateValue: string;
+}
+
+/**
+ * Configuration options for the TroubleActionModel.
+ *
+ * Provides the trouble action definitions that configure how the model
+ * maps active troubles to state values. These definitions are processed
+ * during model initialization to establish the trouble monitoring behavior.
+ *
+ * @example
+ * ```typescript
+ * const options: TroubleActionOptions = {
+ *   definitions: [
+ *     {
+ *       troubleType: 'InsufficientAgitationTrouble',
+ *       stateKey: 'agitationRequired',
+ *       stateValue: 'true'
+ *     },
+ *     {
+ *       troubleType: 'CartridgeEmptyTrouble',
+ *       stateKey: 'cartridgeStatus',
+ *       stateValue: 'empty'
+ *     },
+ *     {
+ *       troubleType: 'MaintenanceRequiredTrouble',
+ *       stateKey: 'systemStatus',
+ *       stateValue: 'maintenance'
+ *     }
+ *   ]
+ * };
+ * ```
+ *
+ * @category Model Configuration
+ * @see {@link TroubleActionData} for individual definition structure
+ * @see {@link TroubleActionModel} for how options are used during initialization
+ */
+export interface TroubleActionOptions {
+  /**
+   * Array of trouble action definitions to monitor.
+   *
+   * Each definition maps a specific trouble type to a state representation.
+   * The model will monitor all defined trouble types and update its state
+   * object accordingly when troubles become active or are resolved.
+   *
+   * The order of definitions affects priority when accessing the activeTrouble
+   * getter - the first matching trouble in the array will be returned.
+   */
+  definitions: TroubleActionData[];
+}

package/lib/utilities/index.d.ts

@@ -0,0 +1,5 @@
+export { UtilitiesContainer } from './utilities-container-registration';
+export { Utilities } from './utilities-registration';
+export type * from './types';
+export * as UtilitiesServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/lib/utilities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/utilities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,iBAAiB,MAAM,YAAY,CAAC"}

package/lib/utilities/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utilities-services';
+//# sourceMappingURL=index.d.ts.map

package/lib/utilities/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-ddk-models/src/lib/utilities/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/lib/utilities/services/utilities-services.d.ts

@@ -0,0 +1,13 @@
+export interface UtilityResponse {
+    name: string;
+    options: Map<string, object>;
+    roles?: string[];
+}
+type UtilityColumnsResponse = UtilityResponse[];
+/**
+ * @category Service
+ * Retrieves the initial utilities data.
+ */
+export declare const getUtilities: () => Promise<UtilityColumnsResponse[]>;
+export {};
+//# sourceMappingURL=utilities-services.d.ts.map

package/lib/utilities/services/utilities-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities-services.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-ddk-models/src/lib/utilities/services/utilities-services.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,KAAK,sBAAsB,GAAG,eAAe,EAAE,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,YAAY,yCAwBxB,CAAC"}

package/lib/utilities/types/index.d.ts

@@ -0,0 +1,30 @@
+import { IKosIdentifiable, IKosModelHolder } from '@kosdev-code/kos-ui-sdk';
+// ---------------  Utilities ---------------
+export interface UtilitiesOptions {
+  columnId: string;
+  name: string;
+  options: Map<string, object>;
+  roles?: string[] | undefined;
+}
+
+export interface UtilitiesModel extends IKosDataModel {
+  id: string;
+  columnId: string;
+  name: string;
+  options: Map<string, object>;
+  updateModel: (options: UtilitiesOptions) => void;
+}
+
+export type UtilityColumn = UtilitiesModel[];
+
+// ---------------  UtilitiesContainer ---------------
+export interface UtilitiesContainerOptions {}
+
+export interface UtilitiesContainerModel
+  extends IKosIdentifiable,
+    IKosModelHolder<UtilitiesModel> {
+  columns: string[];
+  getUtilitiesByColumn(id: string): UtilitiesModel[];
+}
+
+export type IdentifiableUtility = UtilitiesOptions & IKosIdentifiable;

package/lib/utilities/utilities-container-model.d.ts

@@ -0,0 +1,22 @@
+import { KosCreationContext, IKosModelContainer, IKosDataModel } from '@kosdev-code/kos-ui-sdk';
+import { UtilitiesModel, UtilitiesContainerModel, UtilitiesContainerOptions } from './types';
+export declare const MODEL_TYPE = "utilities-container-model";
+/**
+ * @kosService ddk.utilities
+ * @kosApiLevel 1
+ */
+export declare class UtilitiesContainerModelImpl implements UtilitiesContainerModel, IKosDataModel {
+    id: string;
+    private logger;
+    private _models;
+    constructor(modelId: string, _options: UtilitiesContainerOptions, context: KosCreationContext);
+    get data(): UtilitiesModel[];
+    get models(): IKosModelContainer<UtilitiesModel>;
+    get columns(): string[];
+    addModel(model: UtilitiesModel): void;
+    removeModel(id: string): void;
+    getModel(id: string): UtilitiesModel | undefined;
+    getUtilitiesByColumn(id: string): UtilitiesModel[];
+    load(): Promise<void>;
+}
+//# sourceMappingURL=utilities-container-model.d.ts.map

package/lib/utilities/utilities-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities-container-model.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/utilities/utilities-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACd,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EACV,cAAc,EACd,uBAAuB,EACvB,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAIjB,eAAO,MAAM,UAAU,8BAA8B,CAAC;AAEtD;;;GAGG;AACH,qBACa,2BACX,YAAW,uBAAuB,EAAE,aAAa;IAEjD,EAAE,EAAE,MAAM,CAAC;IAEX,OAAO,CAAC,MAAM,CAAmB;IAEvB,OAAO,CAAC,OAAO,CAAqC;gBAE5D,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,yBAAyB,EACnC,OAAO,EAAE,kBAAkB;IAc7B,IAAI,IAAI,qBAEP;IAED,IAAI,MAAM,uCAET;IAED,IAAI,OAAO,IAAI,MAAM,EAAE,CAItB;IAED,QAAQ,CAAC,KAAK,EAAE,cAAc;IAI9B,WAAW,CAAC,EAAE,EAAE,MAAM;IAItB,QAAQ,CAAC,EAAE,EAAE,MAAM;IAInB,oBAAoB,CAAC,EAAE,EAAE,MAAM;IAMzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAoB5B"}

package/lib/utilities/utilities-container-registration.d.ts

@@ -0,0 +1,85 @@
+import { SingletonKosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+import { UtilitiesContainerModel, UtilitiesContainerOptions } from './types';
+/**
+ * # UtilitiesContainer
+ *
+ * The registration bean includes convenience methods for creating and working with UtilitiesContainerModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: UtilitiesContainer.type, id: "utilitiesContainerId"})
+ * private utilitiesContainerModel: UtilitiesContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new UtilitiesContainerModel 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 = UtilitiesContainer.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 UtilitiesContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (UtilitiesContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to UtilitiesContainerModel
+ *    // and the compiler will know that the model has the UtilitiesContainerModel 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 { UtilitiesContainer } from "@kos-ui/kos-dispenser-model";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...UtilitiesContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The utilitiesContainer 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 UtilitiesContainer: Readonly<SingletonKosModelRegistrationBean<UtilitiesContainerModel, UtilitiesContainerOptions>>;
+//# sourceMappingURL=utilities-container-registration.d.ts.map

package/lib/utilities/utilities-container-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities-container-registration.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/utilities/utilities-container-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAEjF,OAAO,KAAK,EACV,uBAAuB,EACvB,yBAAyB,EAC1B,MAAM,SAAS,CAAC;AAMjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CACvC,iCAAiC,CAC/B,uBAAuB,EACvB,yBAAyB,CAC1B,CAeF,CAAC"}

package/lib/utilities/utilities-model.d.ts

@@ -0,0 +1,22 @@
+import { IKosDataModel, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
+import { UtilitiesModel, UtilitiesOptions } from './types';
+export declare const MODEL_TYPE = "utilities-model";
+/**
+ * @kosService ddk.utilities
+ * @kosApiLevel 1
+ */
+export declare class UtilitiesModelImpl implements UtilitiesModel, IKosDataModel {
+    id: string;
+    name: string;
+    options: Map<string, object>;
+    roles?: string[];
+    columnId: string;
+    private logger;
+    constructor(modelId: string, options: UtilitiesOptions, context: KosCreationContext);
+    updateModel(options: UtilitiesOptions): void;
+    get titleKey(): string;
+    get bodyKey(): string;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=utilities-model.d.ts.map

package/lib/utilities/utilities-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities-model.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/utilities/utilities-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhE,eAAO,MAAM,UAAU,oBAAoB,CAAC;AAE5C;;;GAGG;AACH,qBACa,kBAAmB,YAAW,cAAc,EAAE,aAAa;IACtE,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,CAAC,MAAM,CAAmB;gBAG/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,kBAAkB;IAU7B,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAM5C,IAAI,QAAQ,WAEX;IAED,IAAI,OAAO,WAEV;IAIK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}