@kosdev-code/kos-freestyle-sdk 2.0.2

package/models/models/agitation-required-trouble/agitation-required-trouble-model.d.ts

@@ -0,0 +1,23 @@
+import { AgitationRequiredTroubleOptions } from './types';
+import { DeferAware, FutureResponse, IKosDataModel, IKosIdentifiable, KosConfigProperty, KosCreationContext, PublicModelInterface, ResolveAware, TroubleModel } from '@kosdev-code/kos-ui-sdk';
+import { HolderModel } from '@kosdev-code/kos-dispense-sdk';
+
+export declare const MODEL_TYPE = "agitation-required-trouble-model";
+export type AgitationRequiredTroubleModel = PublicModelInterface<AgitationRequiredTroubleModelImpl>;
+export declare const agitationModelFactory: (troubleModel: TroubleModel) => "agitation-required-trouble-model" | undefined;
+export declare const AGITATION_REQUIRED_TROUBLE = "InsufficientAgitationTrouble";
+export declare class AgitationRequiredTroubleModelImpl implements IKosDataModel, IKosIdentifiable, ResolveAware, DeferAware {
+    id: string;
+    private logger;
+    private trouble;
+    private _deferred;
+    agitateBeforePour: KosConfigProperty<boolean>;
+    constructor(modelId: string, options: AgitationRequiredTroubleOptions, context: KosCreationContext);
+    resolve(): Promise<FutureResponse | undefined>;
+    get holder(): HolderModel<any>;
+    get shouldDefer(): boolean;
+    get deferred(): boolean;
+    defer(): void;
+    clearDefer(): void;
+}
+//# sourceMappingURL=agitation-required-trouble-model.d.ts.map

package/models/models/agitation-required-trouble/agitation-required-trouble-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agitation-required-trouble-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/agitation-required-trouble/agitation-required-trouble-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EAEZ,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,UAAU,EACV,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EAEjB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACb,MAAM,yBAAyB,CAAC;AAMjC,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAC;AAE/D,eAAO,MAAM,UAAU,qCAAqC,CAAC;AAE7D,MAAM,MAAM,6BAA6B,GACvC,oBAAoB,CAAC,iCAAiC,CAAC,CAAC;AAE1D,eAAO,MAAM,qBAAqB,iBAAkB,YAAY,mDAK/D,CAAC;AAEF,eAAO,MAAM,0BAA0B,iCAAiC,CAAC;AACzE,qBACa,iCACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,UAAU;IAEpE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,SAAS,CAAU;IAM3B,iBAAiB,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;gBAG7C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,+BAA+B,EACxC,OAAO,EAAE,kBAAkB;IAOvB,OAAO,IAAI,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAKpD,IAAI,MAAM,qBAIT;IAED,IAAI,WAAW,YAMd;IAED,IAAI,QAAQ,YAEX;IACD,KAAK;IAIL,UAAU;CAGX"}

package/models/models/agitation-required-trouble/agitation-required-trouble-registration.d.ts

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

package/models/models/agitation-required-trouble/agitation-required-trouble-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agitation-required-trouble-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/agitation-required-trouble/agitation-required-trouble-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAKxF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,wBAAwB,6FAMnC,CAAC"}

package/models/models/agitation-required-trouble/index.d.ts

@@ -0,0 +1,4 @@
+export { AGITATION_REQUIRED_TROUBLE, type AgitationRequiredTroubleModel, } from './agitation-required-trouble-model';
+export { AgitationRequiredTrouble } from './agitation-required-trouble-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/models/models/agitation-required-trouble/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/agitation-required-trouble/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,KAAK,6BAA6B,GACnC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,mBAAmB,SAAS,CAAC"}

package/models/models/agitation-required-trouble/types/index.d.ts

@@ -0,0 +1,8 @@
+import { IKosCompanionOptions, TroubleModel, TroubleOptions } from '@kosdev-code/kos-ui-sdk';
+import { HolderTroubleData } from '@kosdev-code/kos-dispense-sdk';
+
+
+export type AgitationRequiredTroubleOptions = IKosCompanionOptions<
+  TroubleModel<HolderTroubleData>,
+  TroubleOptions
+>;

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

@@ -0,0 +1,14 @@
+import { CarbAgitatorModel, CarbAgitatorOptions } from './types';
+import { IKosDataModel, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "carb-agitator-model";
+export declare class CarbAgitatorModelImpl implements CarbAgitatorModel, IKosDataModel {
+    id: string;
+    name: string;
+    path: string;
+    private logger;
+    constructor(modelId: string, options: CarbAgitatorOptions, context: KosCreationContext);
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=carb-agitator-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"carb-agitator-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/carb-agitator/carb-agitator-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEtE,eAAO,MAAM,UAAU,wBAAwB,CAAC;AAEhD,qBACa,qBAAsB,YAAW,iBAAiB,EAAE,aAAa;IAC5E,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IAEb,OAAO,CAAC,MAAM,CAAmB;gBAE/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,kBAAkB;IAavB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"carb-agitator-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/carb-agitator/carb-agitator-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AAEL,eAAO,MAAM,YAAY,qEAMvB,CAAC"}

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

@@ -0,0 +1,3 @@
+export { CarbAgitator } from './carb-agitator-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/carb-agitator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,mBAAmB,SAAS,CAAC"}

package/models/models/carb-agitator/types/index.d.ts

@@ -0,0 +1,14 @@
+import { IKosIdentifiable } from '@kosdev-code/kos-ui-sdk';
+
+
+export interface CarbAgitatorOptions {
+  name: string;
+  path: string;
+}
+
+export interface CarbAgitatorModel extends IKosIdentifiable {
+  name: string;
+  path: string;
+}
+
+export {};

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

@@ -0,0 +1,20 @@
+import { CartridgeAgitatorContainerOptions } from './types';
+import { CartridgeAgitatorModel } from './cartridge-agitator-model';
+import { IKosDataModel, IKosIdentifiable, IKosModelContainer, IKosModelHolder, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "cartridge-agitator-container-model";
+export type CartridgeAgitatorContainerModel = PublicModelInterface<CartridgeAgitatorContainerModelImpl>;
+export declare class CartridgeAgitatorContainerModelImpl implements IKosIdentifiable, IKosModelHolder<CartridgeAgitatorModel>, IKosDataModel {
+    id: string;
+    private logger;
+    private _models;
+    constructor(modelId: string, options: CartridgeAgitatorContainerOptions, context: KosCreationContext);
+    getModel(id: string): CartridgeAgitatorModel | undefined;
+    get models(): IKosModelContainer<CartridgeAgitatorModel>;
+    get data(): CartridgeAgitatorModel[];
+    addModel(model: CartridgeAgitatorModel): void;
+    removeModel(id: string): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=cartridge-agitator-container-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartridge-agitator-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/cartridge-agitator/cartridge-agitator-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAEf,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,SAAS,CAAC;AAEjE,eAAO,MAAM,UAAU,uCAAuC,CAAC;AAE/D,MAAM,MAAM,+BAA+B,GACzC,oBAAoB,CAAC,mCAAmC,CAAC,CAAC;AAE5D,qBACa,mCACX,YACE,gBAAgB,EAChB,eAAe,CAAC,sBAAsB,CAAC,EACvC,aAAa;IAEf,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACvB,OAAO,CAAC,OAAO,CAA6C;gBAEpE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iCAAiC,EAC1C,OAAO,EAAE,kBAAkB;IAY7B,QAAQ,CAAC,EAAE,EAAE,MAAM;IAGnB,IAAI,MAAM,+CAET;IACD,IAAI,IAAI,6BAEP;IAED,QAAQ,CAAC,KAAK,EAAE,sBAAsB;IAItC,WAAW,CAAC,EAAE,EAAE,MAAM;IAKhB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAK5B"}

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

@@ -0,0 +1,87 @@
+import { CartridgeAgitatorContainerOptions } from './types';
+import { CartridgeAgitatorContainerModel } from './cartridge-agitator-container-model';
+import { SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # CartridgeAgitatorContainer
+ *
+ * The registration bean includes convenience methods for creating and working with CartridgeAgitatorContainerModel 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: CartridgeAgitatorContainer.type, id: "cartridgeAgitatorContainerId"})
+ * private cartridgeAgitatorContainerModel: 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

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

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

@@ -0,0 +1,27 @@
+import { CartridgeAgitatorOptions } from './types';
+import { FutureAwareContainer, FutureContainer, IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "cartridge-agitator-model";
+export type CartridgeAgitatorModel = PublicModelInterface<CartridgeAgitatorModelImpl>;
+export declare class CartridgeAgitatorEvents {
+    static TOPIC_AGITATION_STARTED: string;
+    static TOPIC_AGITATION_ENDED: string;
+}
+export declare class CartridgeAgitatorModelImpl implements IKosDataModel, IKosIdentifiable, FutureContainer {
+    id: string;
+    futureHandler: FutureAwareContainer<Record<string, unknown>>;
+    private logger;
+    private disposer?;
+    private agitating;
+    path: string;
+    statePath: string;
+    name: string;
+    constructor(modelId: string, options: CartridgeAgitatorOptions, context: KosCreationContext);
+    get isAgitating(): boolean;
+    get future(): import('@kosdev-code/kos-ui-sdk').IFutureModel<Record<string, unknown>> | undefined;
+    testAgitate(tracker?: string): Promise<import('@kosdev-code/kos-ui-sdk').FutureResponse>;
+    init(): Promise<void>;
+    unload(): void;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=cartridge-agitator-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartridge-agitator-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/cartridge-agitator/cartridge-agitator-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAElB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAWjC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,eAAO,MAAM,UAAU,6BAA6B,CAAC;AAErD,MAAM,MAAM,sBAAsB,GAChC,oBAAoB,CAAC,0BAA0B,CAAC,CAAC;AAEnD,qBAAa,uBAAuB;IAClC,MAAM,CAAC,uBAAuB,SAAuC;IACrE,MAAM,CAAC,qBAAqB,SAAqC;CAClE;AAED,qBACa,0BACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,eAAe;IAE3D,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,oBAAoB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7D,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,QAAQ,CAAC,CAAe;IAEhC,OAAO,CAAC,SAAS,CAAyB;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;gBAEX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,kBAAkB;IAU7B,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,MAAM,wFAET;IAGK,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM;IAY5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM;IAIA,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAoB5B"}

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

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

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

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

@@ -0,0 +1,6 @@
+export type { CartridgeAgitatorContainerModel } from './cartridge-agitator-container-model';
+export { CartridgeAgitatorContainer } from './cartridge-agitator-container-registration';
+export { CartridgeAgitatorEvents, type CartridgeAgitatorModel, } from './cartridge-agitator-model';
+export { CartridgeAgitator } from './cartridge-agitator-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/cartridge-agitator/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AAC5F,OAAO,EAAE,0BAA0B,EAAE,MAAM,6CAA6C,CAAC;AACzF,OAAO,EACL,uBAAuB,EACvB,KAAK,sBAAsB,GAC5B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,mBAAmB,SAAS,CAAC"}

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

@@ -0,0 +1,8 @@
+import { FutureResponse } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * @category Service
+ * Retrieves the initial screen data.
+ */
+export declare const agitate: (path: string, tracker: string) => Promise<FutureResponse>;
+//# sourceMappingURL=cartridge-agitator-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartridge-agitator-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/cartridge-agitator/services/cartridge-agitator-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,yBAAyB,CAAC;AAOjC;;;GAGG;AACH,eAAO,MAAM,OAAO,SAAgB,MAAM,WAAW,MAAM,4BAY1D,CAAC"}

package/models/models/cartridge-agitator/types/index.d.ts

@@ -0,0 +1,14 @@
+// ---------------  CartridgeAgitator ---------------
+
+export interface CartridgeAgitatorOptions {
+  name: string;
+  path: string;
+  statePath: string;
+}
+
+export interface AgitationRequiredTroubleIface {
+  agitationRequired: boolean;
+}
+
+// ---------------  CartridgeAgitatorContainer ---------------
+export interface CartridgeAgitatorContainerOptions {}

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

@@ -0,0 +1,38 @@
+import { FreestyleHolderModelExt, FreestyleModelAssemblyExt } from '../types/assembly';
+import { IceAgitatorModel } from '../ice-agitator';
+import { CartridgeAgitatorContainerModel, CartridgeAgitatorModel } from '../cartridge-agitator';
+import { CarbAgitatorModel } from '../carb-agitator';
+import { AssemblyModel, AssemblyOptions, BoardModel, HolderModel, PumpModel } from '@kosdev-code/kos-dispense-sdk';
+import { FreestyleAssemblyOptions } from './types';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "freestyle-assembly-model";
+export declare const FEATURE_SUPPORTS_ICE = "iceAgitator";
+export declare const FEATURE_SUPPORTS_CARB = "carbAgitator";
+export type FreestyleAssemblyModel = PublicModelInterface<FreestyleAssemblyModelImpl> & AssemblyModel<FreestyleModelAssemblyExt, FreestyleHolderModelExt>;
+export declare class FreestyleAssemblyModelImpl implements IKosDataModel, IKosIdentifiable, AssemblyModel<FreestyleModelAssemblyExt, FreestyleHolderModelExt> {
+    id: string;
+    private logger;
+    private assembly;
+    constructor(modelId: string, options: FreestyleAssemblyOptions, context: KosCreationContext);
+    get holderGroups(): string[];
+    get nozzlePaths(): string[];
+    get allHolders(): HolderModel<FreestyleHolderModelExt>[];
+    getHoldersByGroup(group: string): HolderModel<FreestyleHolderModelExt>[];
+    getHoldersByNozzle(nozzlePath: string): HolderModel<FreestyleHolderModelExt>[];
+    get pumpsByNozzle(): Record<string, PumpModel<any>[]>;
+    get pumpPaths(): string[];
+    get boards(): BoardModel<any>[];
+    updateModel(options: AssemblyOptions): void;
+    get iceAgitator(): IceAgitatorModel;
+    get carbAgitator(): CarbAgitatorModel;
+    get cartridgeAgitators(): CartridgeAgitatorContainerModel;
+    get defaultCartridgeAgitator(): CartridgeAgitatorModel;
+    get cartridgeAgitatorModels(): CartridgeAgitatorModel[];
+    get hasCartridgeAgitators(): boolean;
+    get supportsIce(): boolean;
+    get supportsCarb(): boolean;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=freestyle-assembly-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-assembly-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-assembly/freestyle-assembly-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,UAAU,EACV,WAAW,EACX,SAAS,EACV,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EACL,KAAK,+BAA+B,EACpC,KAAK,sBAAsB,EAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EACV,uBAAuB,EACvB,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,eAAO,MAAM,UAAU,6BAA6B,CAAC;AAErD,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAClD,eAAO,MAAM,qBAAqB,iBAAiB,CAAC;AAEpD,MAAM,MAAM,sBAAsB,GAChC,oBAAoB,CAAC,0BAA0B,CAAC,GAC9C,aAAa,CAAC,yBAAyB,EAAE,uBAAuB,CAAC,CAAC;AAEtE,qBACa,0BACX,YACE,aAAa,EACb,gBAAgB,EAChB,aAAa,CAAC,yBAAyB,EAAE,uBAAuB,CAAC;IAEnE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,QAAQ,CAGd;gBAGA,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,kBAAkB;IAW7B,IAAI,YAAY,IAAI,MAAM,EAAE,CAE3B;IACD,IAAI,WAAW,IAAI,MAAM,EAAE,CAE1B;IACD,IAAI,UAAU,IAAI,WAAW,CAAC,uBAAuB,CAAC,EAAE,CAEvD;IACD,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,uBAAuB,CAAC,EAAE;IAGxE,kBAAkB,CAChB,UAAU,EAAE,MAAM,GACjB,WAAW,CAAC,uBAAuB,CAAC,EAAE;IAGzC,IAAI,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAEpD;IACD,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAED,IAAI,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAE9B;IACD,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAG3C,IAAI,WAAW,IAAI,gBAAgB,CAElC;IACD,IAAI,YAAY,IAAI,iBAAiB,CAEpC;IAED,IAAI,kBAAkB,IAAI,+BAA+B,CAExD;IAED,IAAI,wBAAwB,IAAI,sBAAsB,CAErD;IACD,IAAI,uBAAuB,IAAI,sBAAsB,EAAE,CAEtD;IAED,IAAI,qBAAqB,IAAI,OAAO,CAEnC;IAID,IAAI,WAAW,YAEd;IAED,IAAI,YAAY,YAEf;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}