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

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,23 @@
+import { CartridgeAgitatorOptions } from './types';
+import { ExternalFutureInterface, IKosDataModel, IKosIdentifiable, KosFutureAwareFull, KosLoggerAware, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "cartridge-agitator-model";
+export type CartridgeAgitatorModel = PublicModelInterface<CartridgeAgitatorModelImpl> & ExternalFutureInterface;
+export declare class CartridgeAgitatorEvents {
+    static TOPIC_AGITATION_STARTED: string;
+    static TOPIC_AGITATION_ENDED: string;
+}
+export interface CartridgeAgitatorModelImpl extends KosFutureAwareFull, KosLoggerAware {
+}
+export declare class CartridgeAgitatorModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private agitating;
+    path: string;
+    statePath: string;
+    name: string;
+    constructor(modelId: string, options: CartridgeAgitatorOptions);
+    get isAgitating(): boolean;
+    testAgitate(tracker?: string): Promise<import('@kosdev-code/kos-ui-sdk').FutureResponse>;
+    handleAgitation(): 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":"AACA,OAAO,KAAK,EACV,uBAAuB,EACvB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EAEd,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAYjC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,eAAO,MAAM,UAAU,6BAA6B,CAAC;AAErD,MAAM,MAAM,sBAAsB,GAChC,oBAAoB,CAAC,0BAA0B,CAAC,GAAG,uBAAuB,CAAC;AAE7E,qBAAa,uBAAuB;IAClC,MAAM,CAAC,uBAAuB,SAAuC;IACrE,MAAM,CAAC,qBAAqB,SAAqC;CAClE;AAGD,MAAM,WAAW,0BACf,SAAQ,kBAAkB,EACxB,cAAc;CAAG;AAGrB,qBAGa,0BACX,YAAW,aAAa,EAAE,gBAAgB;IAE1C,EAAE,EAAE,MAAM,CAAC;IAEX,OAAO,CAAC,SAAS,CAAyB;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;gBACD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,wBAAwB;IAQ9D,IAAI,WAAW,IAAI,OAAO,CAEzB;IAGK,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM;IAclC,eAAe;CAahB"}

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

@@ -0,0 +1,89 @@
+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
+ *
+ * import type { CartridgeAgitatorModel } from "./cartridge-agitator-model";
+ *
+ * @kosDependency({modelType: CartridgeAgitator.type, id: "cartridgeAgitatorId"})
+ * private cartridgeAgitatorModel: CartridgeAgitatorModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new CartridgeAgitatorModel instances.
+ *
+ 
+ * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
+ *
+ * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = CartridgeAgitator.factory("cartridgeAgitatorId")({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## 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,EACL,sBAAsB,EAGvB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;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,43 @@
+import { FreestyleHolderModelExt, FreestyleModelAssemblyExt } from '../types/assembly';
+import { RemoteTrayContainerModel } from '../remote-tray';
+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 declare const FEATURE_SUPPORTS_REMOTE_TRAYS = "remoteTrays";
+export type FreestyleAssemblyModel = PublicModelInterface<FreestyleAssemblyModelImpl> & AssemblyModel<FreestyleModelAssemblyExt, FreestyleHolderModelExt>;
+export declare class FreestyleAssemblyModelImpl implements IKosDataModel, IKosIdentifiable, AssemblyModel<FreestyleModelAssemblyExt, FreestyleHolderModelExt> {
+    id: string;
+    private logger;
+    private assembly;
+    private _remoteTrays;
+    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 remoteTrays(): RemoteTrayContainerModel;
+    get hasRemoteTrays(): boolean;
+    get supportsRemoteTrays(): boolean;
+    get supportsIce(): boolean;
+    get supportsCarb(): boolean;
+    init(): 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;AAOjC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,SAAS,EACf,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,EAAE,KAAK,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,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;AACpD,eAAO,MAAM,6BAA6B,gBAAgB,CAAC;AAE3D,MAAM,MAAM,sBAAsB,GAChC,oBAAoB,CAAC,0BAA0B,CAAC,GAC9C,aAAa,CAAC,yBAAyB,EAAE,uBAAuB,CAAC,CAAC;AAEtE,qBAEa,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;IAGF,OAAO,CAAC,YAAY,CAA4B;gBAG9C,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;IAED,IAAI,WAAW,IAAI,wBAAwB,CAE1C;IAED,IAAI,cAAc,IAAI,OAAO,CAI5B;IAID,IAAI,mBAAmB,IAAI,OAAO,CAEjC;IACD,IAAI,WAAW,YAEd;IAED,IAAI,YAAY,YAEf;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

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

@@ -0,0 +1,89 @@
+import { FreestyleAssemblyOptions } from './types';
+import { FreestyleAssemblyModel } from './freestyle-assembly-model';
+import { SingletonKosModelRegistrationFactory } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # FreestyleAssembly
+ *
+ * The registration bean includes convenience methods for creating and working with FreestyleAssemblyModel 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: FreestyleAssembly.type, id: "freestyleAssemblyId"})
+ * private freestyleAssemblyModel: FreestyleAssemblyModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new FreestyleAssemblyModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = FreestyleAssembly.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a FreestyleAssemblyModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (FreestyleAssembly.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to FreestyleAssemblyModel
+ *    // and the compiler will know that the model has the FreestyleAssemblyModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { FreestyleAssembly } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(FreestyleAssembly);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The freestyleAssembly model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const FreestyleAssembly: SingletonKosModelRegistrationFactory<FreestyleAssemblyModel, FreestyleAssemblyOptions>;
+//# sourceMappingURL=freestyle-assembly-registration.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-assembly/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC"}

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

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

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

@@ -0,0 +1,21 @@
+import { HolderModel } from '@kosdev-code/kos-dispense-sdk';
+import { FreestyleHolderOptions } from './types';
+import { FutureDelegate, IFutureModel, IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "freestyle-holder-model";
+export declare const freestyleHolderFactory: (holder: HolderModel) => "freestyle-holder-model" | undefined;
+export type FreestyleHolderModel = PublicModelInterface<FreestyleHolderModelImpl>;
+export declare class FreestyleHolderModelImpl implements IKosDataModel, IKosIdentifiable, FutureDelegate {
+    id: string;
+    private logger;
+    private holder;
+    private context;
+    future?: IFutureModel;
+    constructor(modelId: string, options: FreestyleHolderOptions, context: KosCreationContext);
+    get agitated(): boolean | undefined;
+    agitate(): Promise<IFutureModel<Record<string, unknown>> | undefined>;
+    get isRemote(): boolean;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=freestyle-holder-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freestyle-holder-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-freestyle-sdk/src/models/models/freestyle-holder/freestyle-holder-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EAEd,YAAY,EACZ,aAAa,EACb,gBAAgB,EAGhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAQjC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AASjE,eAAO,MAAM,UAAU,2BAA2B,CAAC;AAoCnD,eAAO,MAAM,sBAAsB,WAAY,WAAW,yCAKzD,CAAC;AACF,MAAM,MAAM,oBAAoB,GAC9B,oBAAoB,CAAC,wBAAwB,CAAC,CAAC;AAEjD,qBACa,wBACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,cAAc;IAE1D,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,OAAO,CAAa;IAE5B,MAAM,CAAC,EAAE,YAAY,CAAC;gBAEpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,kBAAkB;IAQ7B,IAAI,QAAQ,wBAEX;IACK,OAAO;IAuBb,IAAI,QAAQ,IAAI,OAAO,CAOtB;IAIK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}