@kosdev-code/kos-freestyle-sdk 0.1.0-dev.5053

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

@@ -0,0 +1,87 @@
+import { FreestyleHolderOptions } from './types';
+import { FreestyleHolderModel } from './freestyle-holder-model';
+import { KosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # FreestyleHolder
+ *
+ * The registration bean includes convenience methods for creating and working with FreestyleHolderModel 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: 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);
+ * }
+ * ```
+ *
+ * ## 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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-holder-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/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"}

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

@@ -0,0 +1,4 @@
+export { FreestyleHolder } from './freestyle-holder-registration';
+export type * from './types';
+export type { FreestyleHolderModel } from './freestyle-holder-model';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-holder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC"}

package/models/models/freestyle-holder/types/index.d.ts

@@ -0,0 +1,8 @@
+import { IKosCompanionOptions } from '@kosdev-code/kos-ui-sdk';
+import { HolderModel, HolderOptions } from '@kosdev-code/kos-dispense-sdk';
+
+
+export type FreestyleHolderOptions = IKosCompanionOptions<
+  HolderModel,
+  HolderOptions
+>;

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

@@ -0,0 +1,25 @@
+import { FreestyleNozzleOptions } from './types';
+import { FreestyleNutritionInfoResponse } from './services';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "freestyle-nozzle-model";
+export type FreestyleNozzleModel = PublicModelInterface<FreestyleNozzleModelImpl>;
+export declare class FreestyleNozzleModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    private nozzleModel;
+    private _cupSizes;
+    private _nutritionInfo?;
+    constructor(modelId: string, options: FreestyleNozzleOptions, context: KosCreationContext);
+    set cupSizes(cupSizes: number[]);
+    get nutritionInfo(): FreestyleNutritionInfoResponse | undefined;
+    get selectedPourable(): {
+        beverage: import('@kosdev-code/kos-dispense-sdk').AvailabilityModel<any, Record<string, any>> | undefined;
+        additional: import('@kosdev-code/kos-dispense-sdk').AvailabilityModel<any, Record<string, any>>[] | undefined;
+    };
+    handleBeverageSelection(): Promise<void>;
+    init(): Promise<void>;
+    unload(): void;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=freestyle-nozzle-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-nozzle-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-nozzle/freestyle-nozzle-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAQjC,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD,eAAO,MAAM,UAAU,2BAA2B,CAAC;AAEnD,MAAM,MAAM,oBAAoB,GAC9B,oBAAoB,CAAC,wBAAwB,CAAC,CAAC;AAEjD,qBAEa,wBACX,YAAW,aAAa,EAAE,gBAAgB;IAE1C,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,cAAc,CAAC,CAAiC;gBAEtD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,kBAAkB;IAQ7B,IAAI,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,EAE9B;IACD,IAAI,aAAa,+CAEhB;IAED,IAAI,gBAAgB;;;MAEnB;IAOK,uBAAuB;IA0BvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,IAAI,IAAI;IAGR,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

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

@@ -0,0 +1,87 @@
+import { FreestyleNozzleOptions } from './types';
+import { FreestyleNozzleModel } from './freestyle-nozzle-model';
+import { KosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # FreestyleNozzle
+ *
+ * The registration bean includes convenience methods for creating and working with FreestyleNozzleModel 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: 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);
+ * }
+ * ```
+ *
+ * ## 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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-nozzle-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/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"}

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

@@ -0,0 +1,5 @@
+export { FreestyleNozzle } from './freestyle-nozzle-registration';
+export type * from './types';
+export type { FreestyleNozzleModel } from './freestyle-nozzle-model';
+export * as FreestyleNozzleServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-nozzle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,uBAAuB,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,32 @@
+interface NutritionValue {
+    displayValue: string;
+    units: string;
+    type: string;
+}
+interface NutritionVolume {
+    volume: number;
+    values: NutritionValue[];
+}
+export interface FreestyleNutritionInfoResponse {
+    labels?: {
+        allergens: string;
+        legalDescriptor: string;
+        ingredients: string;
+        ingredientsHeading: string;
+    };
+    volumes: NutritionVolume[];
+    error?: string;
+}
+export declare class NutritionInfoError extends Error {
+    constructor(message: string);
+}
+export declare class InvalidRequestError extends Error {
+    constructor(message: string);
+}
+/**
+ * @category Service
+ * Retrieves the initial freestyle-nozzle data.
+ */
+export declare const getFreestyleNutritionInfo: (nozzleUrlPrefix: string, beverageId: string, volumes: number[], baseUrl?: string) => Promise<FreestyleNutritionInfoResponse>;
+export {};
+//# sourceMappingURL=freestyle-nozzle-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-nozzle-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-nozzle/services/freestyle-nozzle-services.ts"],"names":[],"mappings":"AAeA,UAAU,cAAc;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AACD,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AACD,MAAM,WAAW,8BAA8B;IAC7C,MAAM,CAAC,EAAE;QACP,SAAS,EAAE,MAAM,CAAC;QAClB,eAAe,EAAE,MAAM,CAAC;QACxB,WAAW,EAAE,MAAM,CAAC;QACpB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AACD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,oBACnB,MAAM,cACX,MAAM,WACT,MAAM,EAAE,8DA8BlB,CAAC"}

package/models/models/freestyle-nozzle/services/index.d.ts

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

package/models/models/freestyle-nozzle/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-nozzle/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/models/models/freestyle-nozzle/types/index.d.ts

@@ -0,0 +1,8 @@
+import { IKosCompanionOptions } from '@kosdev-code/kos-ui-sdk';
+import { NozzleModel, NozzleOptions } from '@kosdev-code/kos-dispense-sdk';
+
+
+export type FreestyleNozzleOptions = IKosCompanionOptions<
+  NozzleModel,
+  NozzleOptions
+>;

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

@@ -0,0 +1,14 @@
+import { ReplacePumpData, ReplacePumpErrorType } from './services';
+import { FreestylePumpOptions } from './types';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "freestyle-pump-model";
+export type FreestylePumpModel = PublicModelInterface<FreestylePumpModelImpl>;
+export declare class FreestylePumpModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    private pump;
+    constructor(modelId: string, options: FreestylePumpOptions, context: KosCreationContext);
+    replacePump(code: string): Promise<[ReplacePumpErrorType, ReplacePumpData]>;
+}
+//# sourceMappingURL=freestyle-pump-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-pump-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-pump/freestyle-pump-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGpD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,UAAU,yBAAyB,CAAC;AAEjD,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAE9E,qBACa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,IAAI,CAAY;gBAEtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,kBAAkB;IASvB,WAAW,CACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,oBAAoB,EAAE,eAAe,CAAC,CAAC;CAQpD"}

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

@@ -0,0 +1,87 @@
+import { FreestylePumpOptions } from './types';
+import { FreestylePumpModel } from './freestyle-pump-model';
+import { KosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # FreestylePump
+ *
+ * The registration bean includes convenience methods for creating and working with FreestylePumpModel 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: 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);
+ * }
+ * ```
+ *
+ * ## 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

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

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

@@ -0,0 +1,5 @@
+export { FreestylePump } from './freestyle-pump-registration';
+export type * from './types';
+export type { FreestylePumpModel } from './freestyle-pump-model';
+export * as FreestylePumpServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+export type ReplacePumpErrorType = "unknownError" | undefined;
+export type ReplacePumpData = {
+    error?: ReplacePumpErrorType;
+};
+export type ReplacePumpResponse = [
+    ReplacePumpErrorType | undefined,
+    ReplacePumpData
+];
+export declare const replacePump: (pumpId: string, code: string) => Promise<ReplacePumpResponse>;
+//# sourceMappingURL=freestyle-pump-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-pump-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-pump/services/freestyle-pump-services.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,oBAAoB,GAAG,cAAc,GAAG,SAAS,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,oBAAoB,CAAC;CAC9B,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG;IAChC,oBAAoB,GAAG,SAAS;IAChC,eAAe;CAChB,CAAC;AACF,eAAO,MAAM,WAAW,WACd,MAAM,QACR,MAAM,KACX,QAAQ,mBAAmB,CAoC7B,CAAC"}

package/models/models/freestyle-pump/services/index.d.ts

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

package/models/models/freestyle-pump/services/index.d.ts.map

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

package/models/models/freestyle-pump/types/index.d.ts

@@ -0,0 +1,5 @@
+import { IKosCompanionOptions } from '@kosdev-code/kos-ui-sdk';
+import { PumpModel, PumpOptions } from '@kosdev-code/kos-dispense-sdk';
+
+
+export type FreestylePumpOptions = IKosCompanionOptions<PumpModel, PumpOptions>;

package/models/models/ice-agitator/ice-agitator-model.d.ts

@@ -0,0 +1,65 @@
+import { IceAgitatorOptions } from './types';
+import { PourState } from '@kosdev-code/kos-dispense-sdk';
+import { IKosDataModel, KosConfigProperty, KosCreationContext, KosMultipleFutureAwareFull, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export type IceAgitatorModel = PublicModelInterface<IceAgitatorModelImpl>;
+export declare class IceAgitatorEvents {
+    static TOPIC_AGITATION_STARTED: string;
+    static TOPIC_AGITATION_ENDED: string;
+}
+export declare const MODEL_TYPE = "ice-agitator-model";
+type IceAgitatorModelType = KosMultipleFutureAwareFull<"pour" | "agitate" | "gate">;
+export interface IceAgitatorModelImpl extends IceAgitatorModelType {
+}
+export declare class IceAgitatorModelImpl implements IKosDataModel {
+    id: string;
+    name: string;
+    path: string;
+    volWithoutIceMl: KosConfigProperty<number>;
+    durationSec: KosConfigProperty<number>;
+    enableIceChuteClear: KosConfigProperty<boolean>;
+    iceChuteClearDurationMs: KosConfigProperty<number>;
+    iceChuteClearIntervalSec: KosConfigProperty<number>;
+    iceChuteClearRetryIntervalSec: KosConfigProperty<number>;
+    maxDispenseSec: KosConfigProperty<number>;
+    type: KosConfigProperty<string>;
+    dilutionOffset: KosConfigProperty<number>;
+    inactivitySec: KosConfigProperty<number>;
+    private agitating;
+    private iceChuteOpen;
+    statePath: string;
+    private _allIceTypes;
+    private logger;
+    currentState: PourState;
+    constructor(modelId: string, options: IceAgitatorOptions, context: KosCreationContext);
+    get iceTypes(): string[];
+    get isAgitating(): boolean;
+    get isIceChuteOpen(): boolean;
+    /**
+     * A derived value that indicates if the nozzle is currently pouring a beverage.
+     * @readonly
+     */
+    get isPouring(): boolean;
+    /**
+     * A derived value that indicates if it is possible to dispense ice.
+     *
+     * The value is observable and will change as the current dispense state changes
+     * @readonly
+     * */
+    get canPour(): boolean;
+    private updateIfCurrent;
+    pourIce(tracker?: string): Promise<void>;
+    /**
+     * An action that will cancel the ice dispense if it is currently in progress.
+     * */
+    cancelIceDispense(): Promise<void>;
+    testAgitate(tracker?: string): Promise<import('@kosdev-code/kos-ui-sdk').FutureResponse>;
+    testGate(tracker?: string): Promise<import('@kosdev-code/kos-ui-sdk').FutureResponse>;
+    handleAgitationChange(): void;
+    updateIceType(type: string): Promise<void>;
+    resetDefaultValues: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown[]> | undefined>;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=ice-agitator-model.d.ts.map

package/models/models/ice-agitator/ice-agitator-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ice-agitator-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/ice-agitator/ice-agitator-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EAEjB,kBAAkB,EAClB,0BAA0B,EAE1B,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAcjC,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAS1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;AAE1E,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,uBAAuB,SAA2C;IACzE,MAAM,CAAC,qBAAqB,SAAyC;CACtE;AAED,eAAO,MAAM,UAAU,uBAAuB,CAAC;AAI/C,KAAK,oBAAoB,GAAG,0BAA0B,CACpD,MAAM,GAAG,SAAS,GAAG,MAAM,CAC5B,CAAC;AAGF,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;CAAG;AAErE,qBAEa,oBAAqB,YAAW,aAAa;IACxD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IAOb,eAAe,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAS5C,WAAW,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAMxC,mBAAmB,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAMjD,uBAAuB,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAMpD,wBAAwB,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAMrD,6BAA6B,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAM1D,cAAc,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAM3C,IAAI,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAMjC,cAAc,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAS3C,aAAa,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAE1C,OAAO,CAAC,SAAS,CAAyB;IAG1C,OAAO,CAAC,YAAY,CAAyB;IAE7C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,MAAM,CAAmB;IACjC,YAAY,EAAE,SAAS,CAAkB;gBAEvC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,kBAAkB;IAW7B,IAAI,QAAQ,IAAI,MAAM,EAAE,CAEvB;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,cAAc,IAAI,OAAO,CAE5B;IAID;;;OAGG;IACH,IAAI,SAAS,YAOZ;IAED;;;;;SAKK;IACL,IAAI,OAAO,YAEV;IACD,OAAO,CAAC,eAAe;IAQV,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM;IAyBrC;;SAEK;IACQ,iBAAiB;IAkBxB,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM;IAc5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM;IAa/B,qBAAqB;IAaf,aAAa,CAAC,IAAI,EAAE,MAAM;IAIhC,kBAAkB,6FAGhB;IAEI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAS5B"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ice-agitator-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/ice-agitator/ice-agitator-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AAEL,eAAO,MAAM,WAAW,mEAMtB,CAAC"}

package/models/models/ice-agitator/index.d.ts

@@ -0,0 +1,4 @@
+export { IceAgitatorEvents, type IceAgitatorModel } from './ice-agitator-model';
+export { IceAgitator } from './ice-agitator-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/models/models/ice-agitator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/ice-agitator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,mBAAmB,SAAS,CAAC"}

package/models/models/ice-agitator/services/ice-agitator-services.d.ts

@@ -0,0 +1,13 @@
+import { FutureResponse, KosServiceResponse } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * @category Service
+ * Retrieves the initial dispenser data.
+ */
+export declare const getIceTypes: (path: string) => Promise<KosServiceResponse<string[]> | undefined>;
+export declare const updateIceType: (agitator: string, type: string) => Promise<KosServiceResponse<any> | undefined>;
+export declare const resetIceSetting: (path: string) => Promise<KosServiceResponse<unknown[]> | undefined>;
+export declare const pour: (path: string, tracker: string) => Promise<FutureResponse>;
+export declare const agitate: (path: string, tracker: string) => Promise<FutureResponse>;
+export declare const testGate: (path: string, tracker: string) => Promise<FutureResponse>;
+//# sourceMappingURL=ice-agitator-services.d.ts.map

package/models/models/ice-agitator/services/ice-agitator-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ice-agitator-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/ice-agitator/services/ice-agitator-services.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AAWjC;;;GAGG;AACH,eAAO,MAAM,WAAW,SAAgB,MAAM,sDAM7C,CAAC;AAEF,eAAO,MAAM,aAAa,aAAoB,MAAM,QAAQ,MAAM,iDAOjE,CAAC;AAEF,eAAO,MAAM,eAAe,SAAgB,MAAM,uDAKjD,CAAC;AAEF,eAAO,MAAM,IAAI,SAAgB,MAAM,WAAW,MAAM,4BAYvD,CAAC;AAEF,eAAO,MAAM,OAAO,SAAgB,MAAM,WAAW,MAAM,4BAY1D,CAAC;AAEF,eAAO,MAAM,QAAQ,SAAgB,MAAM,WAAW,MAAM,4BAY3D,CAAC"}