@kosdev-code/kos-ddk-models 2.0.0

package/lib/dispenser/dispenser-registration.d.ts

@@ -0,0 +1,86 @@
+import { DispenserModel, DispenserOptions } from './types';
+import { SingletonKosModelRegistrationBean } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+/**
+ * # Dispenser
+ *
+ * The registration bean includes convenience methods for creating and working with DispenserModel 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: Dispenser.type, id: "dispenserId"})
+ * private dispenserModel: DispenserModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new DispenserModel 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 = Dispenser.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 DispenserModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Dispenser.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to DispenserModel
+ *    // and the compiler will know that the model has the DispenserModel 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 { Dispenser } from "@kos-ui/kos-dispenser-model";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Dispenser.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The dispenser 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 Dispenser: Readonly<SingletonKosModelRegistrationBean<DispenserModel, DispenserOptions>>;
+//# sourceMappingURL=dispenser-registration.d.ts.map

package/lib/dispenser/dispenser-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispenser-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/dispenser/dispenser-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAGjF,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,SAAS,EAAE,QAAQ,CAC9B,iCAAiC,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAWpE,CAAC"}

package/lib/dispenser/index.d.ts

@@ -0,0 +1,4 @@
+export { Dispenser } from './dispenser-registration';
+export type * from './types';
+export * as DispenserServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+interface DispenserResponse {
+    id: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial dispenser data.
+ */
+export declare const getDispensers: () => Promise<import('../../../../../../sdk/kos-ui-sdk/src/index.ts').KosServiceResponse<DispenserResponse[]> | undefined>;
+export {};
+//# sourceMappingURL=dispenser-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispenser-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/dispenser/services/dispenser-services.ts"],"names":[],"mappings":"AAcA,UAAU,iBAAiB;IACzB,EAAE,EAAE,MAAM,CAAC;CACZ;AACD;;;GAGG;AACH,eAAO,MAAM,aAAa,sGAIzB,CAAC"}

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { IKosDataModel } from '../../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+
+export interface DispenserOptions {}
+
+export interface DispenserModel extends DispenserOptions, IKosDataModel {
+  id: string;
+  updateModel(options: DispenserOptions): void;
+}

package/lib/dispenser-info/dispenser-info-model.d.ts

@@ -0,0 +1,13 @@
+import { DispenserInfoModel, DispenserInfoOptions } from './types';
+import { IKosDataModel, KosConfigProperty, KosCreationContext } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+export declare const MODEL_TYPE = "dispenser-info-model";
+export declare class DispenserInfoModelImpl implements DispenserInfoModel, IKosDataModel {
+    private logger;
+    id: string;
+    name: KosConfigProperty<string>;
+    constructor(modelId: string, _options: DispenserInfoOptions, context: KosCreationContext);
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=dispenser-info-model.d.ts.map

package/lib/dispenser-info/dispenser-info-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispenser-info-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/dispenser-info/dispenser-info-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EAEjB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAExE,eAAO,MAAM,UAAU,yBAAyB,CAAC;AAEjD,qBACa,sBACX,YAAW,kBAAkB,EAAE,aAAa;IAE5C,OAAO,CAAC,MAAM,CAAmB;IAEjC,EAAE,EAAE,MAAM,CAAC;IAMX,IAAI,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;gBAG/B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,EAAE,kBAAkB;IAQvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/lib/dispenser-info/dispenser-info-registration.d.ts

@@ -0,0 +1,84 @@
+import { DispenserInfoModel, DispenserInfoOptions } from './types';
+import { KosModelRegistrationBean } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+/**
+ * # DispenserInfo
+ *
+ * The registration bean includes convenience methods for creating and working with DispenserInfoModel 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: DispenserInfo.type, id: "dispenserInfoId"})
+ * private dispenserInfoModel: DispenserInfoModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new DispenserInfoModel 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 = DispenserInfo.factory("dispenserInfoId")({
+ *   // 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 DispenserInfoModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (DispenserInfo.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to DispenserInfoModel
+ *    // and the compiler will know that the model has the DispenserInfoModel 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 { DispenserInfo } from "@kos-ui/kos-dispenser-model";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...DispenserInfo.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The dispenserInfo 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 DispenserInfo: Readonly<KosModelRegistrationBean<DispenserInfoModel, DispenserInfoOptions>>;
+//# sourceMappingURL=dispenser-info-registration.d.ts.map

package/lib/dispenser-info/dispenser-info-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispenser-info-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/dispenser-info/dispenser-info-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,aAAa,EAAE,QAAQ,CAClC,wBAAwB,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAanE,CAAC"}

package/lib/dispenser-info/index.d.ts

@@ -0,0 +1,4 @@
+export { DispenserInfo } from './dispenser-info-registration';
+export type * from './types';
+export * as DispenserInfoServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/lib/dispenser-info/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/dispenser-info/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,qBAAqB,MAAM,YAAY,CAAC"}

package/lib/dispenser-info/services/dispenser-info-services.d.ts

@@ -0,0 +1,10 @@
+interface DispenserInfoResponse {
+    id: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial dispenser-info data.
+ */
+export declare const getDispenserInfos: () => Promise<import('../../../../../../sdk/kos-ui-sdk/src/index.ts').KosServiceResponse<DispenserInfoResponse[]> | undefined>;
+export {};
+//# sourceMappingURL=dispenser-info-services.d.ts.map

package/lib/dispenser-info/services/dispenser-info-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispenser-info-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/dispenser-info/services/dispenser-info-services.ts"],"names":[],"mappings":"AAcA,UAAU,qBAAqB;IAC7B,EAAE,EAAE,MAAM,CAAC;CACZ;AACD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,0GAI7B,CAAC"}

package/lib/dispenser-info/services/index.d.ts

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

package/lib/dispenser-info/services/index.d.ts.map

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

package/lib/dispenser-info/types/index.d.ts

@@ -0,0 +1,10 @@
+import { IKosDataModel, KosConfigProperty } from '../../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+
+export interface DispenserInfoOptions {}
+
+export interface DispenserInfoModel
+  extends DispenserInfoOptions,
+    IKosDataModel {
+  name: KosConfigProperty<string>;
+}

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

@@ -0,0 +1,20 @@
+import { DoorOptions } from './types';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+export declare const MODEL_TYPE = "door-model";
+export type DoorModel = PublicModelInterface<DoorModelImpl>;
+export declare enum DoorState {
+    OPEN = "OPEN",
+    CLOSED = "CLOSED",
+    UNKNOWN = "UNKNOWN"
+}
+export declare class DoorModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    readonly doorPath: string;
+    private open;
+    constructor(modelId: string, options: DoorOptions, context: KosCreationContext);
+    get currentState(): DoorState;
+    get isOpen(): boolean;
+}
+//# sourceMappingURL=door-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"door-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/door/door-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAElB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,UAAU,eAAe,CAAC;AAEvC,MAAM,MAAM,SAAS,GAAG,oBAAoB,CAAC,aAAa,CAAC,CAAC;AAI5D,oBAAY,SAAS;IACnB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AACD,qBACa,aAAc,YAAW,aAAa,EAAE,gBAAgB;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAG1B,OAAO,CAAC,IAAI,CAAyB;gBAGnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,kBAAkB;IAQ7B,IAAI,YAAY,IAAI,SAAS,CAM5B;IAED,IAAI,MAAM,IAAI,OAAO,CAIpB;CACF"}

package/lib/door/door-registration.d.ts

@@ -0,0 +1,87 @@
+import { DoorModel } from './door-model';
+import { DoorOptions } from './types';
+import { KosModelRegistrationFactory } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+/**
+ * # Door
+ *
+ * The registration bean includes convenience methods for creating and working with DoorModel 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: Door.type, id: "doorId"})
+ * private doorModel: DoorModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new DoorModel 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 = Door.factory("doorId")({
+ *   // 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 DoorModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Door.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to DoorModel
+ *    // and the compiler will know that the model has the DoorModel 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 { Door } 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(Door);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The door 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 Door: KosModelRegistrationFactory<DoorModel, DoorOptions>;
+//# sourceMappingURL=door-registration.d.ts.map

package/lib/door/door-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/door/door-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,IAAI,qDAGf,CAAC"}

package/lib/door/index.d.ts

@@ -0,0 +1,4 @@
+export type { DoorModel, DoorState } from './door-model';
+export { Door } from './door-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/door/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,mBAAmB,SAAS,CAAC"}

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

@@ -0,0 +1,3 @@
+export interface DoorOptions {
+  doorPath: string;
+}

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

@@ -0,0 +1,14 @@
+import { EnrollmentModel, EnrollmentOptions } from './types';
+import { IKosModelLogger, KosContextLogger, KosCreationContext } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+export declare const MODEL_TYPE = "enrollment-model";
+export declare class EnrollmentModelImpl implements EnrollmentModel, IKosModelLogger {
+    id: string;
+    logger: KosContextLogger;
+    enrolled: boolean;
+    constructor(modelId: string, _options: EnrollmentOptions, context: KosCreationContext);
+    updateModel(options: EnrollmentOptions): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=enrollment-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enrollment-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/enrollment/enrollment-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAElE,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAE7C,qBACa,mBAAoB,YAAW,eAAe,EAAE,eAAe;IAC1E,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;gBAGhB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,kBAAkB;IAO7B,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAMvC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/lib/enrollment/enrollment-registration.d.ts

@@ -0,0 +1,84 @@
+import { EnrollmentModel, EnrollmentOptions } from './types';
+import { SingletonKosModelRegistrationBean } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+/**
+ * # Enrollment
+ *
+ * The registration bean includes convenience methods for creating and working with EnrollmentModel 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: Enrollment.type, id: "enrollmentId"})
+ * private enrollmentModel: EnrollmentModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new EnrollmentModel 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 = Enrollment.factory("enrollmentId")({
+ *   // 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 EnrollmentModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Enrollment.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to EnrollmentModel
+ *    // and the compiler will know that the model has the EnrollmentModel 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 { Enrollment } from "@kos-ui/kos-dispenser-model";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Enrollment.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The enrollment 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 Enrollment: Readonly<SingletonKosModelRegistrationBean<EnrollmentModel, EnrollmentOptions>>;
+//# sourceMappingURL=enrollment-registration.d.ts.map

package/lib/enrollment/enrollment-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrollment-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/enrollment/enrollment-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAGjF,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,UAAU,EAAE,QAAQ,CAC/B,iCAAiC,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAWtE,CAAC"}

package/lib/enrollment/index.d.ts

@@ -0,0 +1,4 @@
+export { Enrollment } from './enrollment-registration';
+export type * from './types';
+export * as EnrollmentServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/enrollment/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,kBAAkB,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,10 @@
+interface EnrollmentResponse {
+    id: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial enrollment data.
+ */
+export declare const getEnrollments: () => Promise<import('../../../../../../sdk/kos-ui-sdk/src/index.ts').KosServiceResponse<EnrollmentResponse[]> | undefined>;
+export {};
+//# sourceMappingURL=enrollment-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enrollment-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/enrollment/services/enrollment-services.ts"],"names":[],"mappings":"AAcA,UAAU,kBAAkB;IAC1B,EAAE,EAAE,MAAM,CAAC;CACZ;AACD;;;GAGG;AACH,eAAO,MAAM,cAAc,uGAI1B,CAAC"}

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { IKosDataModel } from '../../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+
+export interface EnrollmentOptions {}
+
+export interface EnrollmentModel extends EnrollmentOptions, IKosDataModel {
+  id: string;
+  enrolled: boolean;
+  updateModel(options: EnrollmentOptions): void;
+}

package/lib/extension/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

package/lib/fcm-pump/fcm-pump-model.d.ts

@@ -0,0 +1,28 @@
+import { FcmPumpOptions } from './types';
+import { FutureAwareContainer, FutureContainer, FutureResponse, IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+import { IntentAware, IntentAwareProps } from '../../../../../sdk/kos-dispense-sdk/src/index.ts';
+
+export declare const MODEL_TYPE = "fcm-pump-model";
+export type FcmPumpModel = PublicModelInterface<FcmPumpModelImpl>;
+export declare class FcmPumpModelImpl implements IKosDataModel, IKosIdentifiable, IntentAware, FutureContainer {
+    id: string;
+    private logger;
+    private pumpModel;
+    futureHandler: FutureAwareContainer;
+    constructor(modelId: string, options: FcmPumpOptions, context: KosCreationContext);
+    get future(): import('../../../../../sdk/kos-ui-sdk/src/index.ts').IFutureModel<Record<string, unknown>> | undefined;
+    get name(): string;
+    get canPour(): boolean;
+    get isPouring(): boolean;
+    cancelPour(): Promise<void>;
+    performIntent(props: IntentAwareProps | string): Promise<FutureResponse | undefined>;
+    performElectricalTest(): Promise<import('./services').ElectricalTestData>;
+    getChildren(): import('../../../../../sdk/kos-ui-sdk/src/index.ts').IFutureModel<Record<string, unknown>>[];
+    performPreCalibrate(tracker?: string): Promise<FutureResponse>;
+    performCalibrate(tracker?: string): Promise<FutureResponse>;
+    performVerify(volume: string, tracker?: string): Promise<FutureResponse>;
+    performComplete(volume1: string, volume2: string): Promise<any>;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=fcm-pump-model.d.ts.map

package/lib/fcm-pump/fcm-pump-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fcm-pump-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/fcm-pump/fcm-pump-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAEjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EACf,cAAc,EACd,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAcjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,UAAU,mBAAmB,CAAC;AAI3C,MAAM,MAAM,YAAY,GAAG,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;AAElE,qBACa,gBACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,eAAe;IAExE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,SAAS,CAAY;IAC7B,aAAa,EAAE,oBAAoB,CAAC;gBAElC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,kBAAkB;IAQ7B,IAAI,MAAM,wFAET;IAED,IAAI,IAAI,WAEP;IAED,IAAI,OAAO,YAEV;IAED,IAAI,SAAS,YAEZ;IAEK,UAAU;IAIhB,aAAa,CACX,KAAK,EAAE,gBAAgB,GAAG,MAAM,GAC/B,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAIhC,qBAAqB;IAS3B,WAAW;IAML,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM;IAKpC,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM;IAKjC,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAMhD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}