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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"device-assembly-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/device-assembly/device-assembly-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,cAAc,kFAMzB,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/device-assembly/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

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

@@ -0,0 +1 @@
+export interface DeviceAssemblyOptions {}

package/models/models/generic-pour/generic-pour-model.d.ts

@@ -0,0 +1,53 @@
+import { GenericPourOptions } from './types';
+import { PourState } from '../types';
+import { PourStrategyAware } from '../../../ui/hooks/utils/pour-strategy';
+import { FutureContainer, IFutureModel, IKosDataModel, PublicModelInterface, KosData, KosFutureAwareFull, KosLoggerAware } from '@kosdev-code/kos-ui-sdk';
+
+export declare const MODEL_TYPE = "generic-pour-model";
+export type GenericPourModel = PublicModelInterface<GenericPourModelImpl>;
+export declare const TOPIC_GENERIC_POUR_STARTED = "/kos/generic/pour/started";
+export declare const TOPIC_GENERIC_POUR_PROGRESS = "/kos/generic/pour/progress";
+export declare const TOPIC_GENERIC_POUR_CANCEL = "/kos/generic/pour/cancel";
+export interface GenericPourModelImpl extends KosLoggerAware, KosFutureAwareFull<any> {
+}
+export declare class GenericPourModelImpl implements IKosDataModel, PourStrategyAware, FutureContainer {
+    id: string;
+    currentState: PourState;
+    servicePathFactory: (selectedId: string, context?: KosData<Record<string, any>>) => string;
+    pourType: string;
+    selectedId?: string;
+    private state;
+    constructor(modelId: string, options: GenericPourOptions);
+    get servicePath(): string;
+    updateContextData(key: string, value: any): void;
+    removeContextData(key: string): void;
+    clearContextData(): void;
+    /**
+     * An action that will initiate a pour for this nozzle.
+     *
+     * The invocation of this action will result in a Future being returned that will
+     * provide the status of the pour and return any errors that may occur.
+     *
+     * @see {@link kosFuture}
+     * */
+    pour(tracker?: string): Promise<void>;
+    cancelPour(): Promise<void>;
+    private updateIfCurrent;
+    /**
+     * A derived value that indicates if the nozzle is currently pouring a beverage.
+     * @readonly
+     */
+    get isPouring(): boolean;
+    /**
+     * A derived value that indicates if the pour target is currently available to pour a beverage.
+     *
+     * Generally this means that the pour target is currently idle and not in the process of pouring, initiating a pour, or canceling a pour.
+     * The value is observable and will change when the selected pourable changes or the pour target
+     * starts or stops pouring.
+     * @readonly
+     */
+    get canPour(): boolean;
+    get pourProgress(): number;
+    onFutureUpdate(future: IFutureModel<any>): void;
+}
+//# sourceMappingURL=generic-pour-model.d.ts.map

package/models/models/generic-pour/generic-pour-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-pour-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/generic-pour/generic-pour-model.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,eAAe,EAGf,YAAY,EACZ,aAAa,EAEb,oBAAoB,EAOpB,KAAK,OAAO,EACZ,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAE/E,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,UAAU,uBAAuB,CAAC;AAE/C,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;AAE1E,eAAO,MAAM,0BAA0B,8BAA8B,CAAC;AACtE,eAAO,MAAM,2BAA2B,+BAA+B,CAAC;AACxE,eAAO,MAAM,yBAAyB,6BAA6B,CAAC;AA4BpE,MAAM,WAAW,oBACf,SAAQ,cAAc,EACpB,kBAAkB,CAAC,GAAG,CAAC;CAAG;AAC9B,qBAGa,oBACX,YAAW,aAAa,EAAE,iBAAiB,EAAE,eAAe;IAE5D,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,SAAS,CAAkB;IACzC,kBAAkB,EAAE,CAClB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,KACnC,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IAEjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,KAAK,CAA+B;gBAChC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;IAUxD,IAAI,WAAW,WAKd;IAED,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAIzC,iBAAiB,CAAC,GAAG,EAAE,MAAM;IAI7B,gBAAgB;IAGhB;;;;;;;SAOK;IAEQ,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM;IAyCrB,UAAU;IA2BvB,OAAO,CAAC,eAAe;IAQvB;;;OAGG;IACH,IAAI,SAAS,YAOZ;IAED;;;;;;;OAOG;IACH,IAAI,OAAO,YAEV;IAED,IAAI,YAAY,WAEf;IAED,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,CAAC;CA0BzC"}

package/models/models/generic-pour/generic-pour-registration.d.ts

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

package/models/models/generic-pour/generic-pour-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-pour-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/generic-pour/generic-pour-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,WAAW,mEAMtB,CAAC"}

package/models/models/generic-pour/index.d.ts

@@ -0,0 +1,5 @@
+export { GenericPour } from './generic-pour-registration';
+export type * from './types';
+export type { GenericPourModel } from './generic-pour-model';
+export * as GenericPourServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/generic-pour/index.d.ts.map

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

package/models/models/generic-pour/services/generic-pour-services.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * Initiates a pour for a pour target on a given path.
+ *
+
+ *
+ * @param path - the API path to pour from, this will be passed in from the model
+ * @param tracker - the tracker to use for the pour.  It will be returned in the future to allow consumers
+ * to track the pour
+ * @category Service
+ *
+ * @see {@link FutureManager.initiateFuture}
+ * @returns - a Future that encapsulates the pour including its status and progress.
+ **/
+export declare const pourOnTarget: (path: string, tracker: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+//# sourceMappingURL=generic-pour-services.d.ts.map

package/models/models/generic-pour/services/generic-pour-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-pour-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/generic-pour/services/generic-pour-services.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;IAaI;AACJ,eAAO,MAAM,YAAY,SAAgB,MAAM,WAAW,MAAM,mFAW/D,CAAC"}

package/models/models/generic-pour/services/index.d.ts

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

package/models/models/generic-pour/services/index.d.ts.map

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

package/models/models/generic-pour/types/index.d.ts

@@ -0,0 +1,5 @@
+export interface GenericPourOptions {
+  servicePathFactory: (selectedId: string) => string;
+  selectedId?: string;
+  pourType?: string;
+}

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

@@ -0,0 +1,93 @@
+import { HolderModel, HolderOptions } from './types';
+import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+export interface HolderTroubleData {
+    holderPaths: string[];
+    holderNames: string[];
+}
+export interface ContainerTroubleData {
+    ingredients: string[];
+    unknonwnIngredientId?: string;
+}
+/**
+ * # Holder
+ *
+ * The registration bean includes convenience methods for creating and working with HolderModel 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: Holder.type, id: "holderId"})
+ * private holderModel: HolderModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new HolderModel 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 = Holder.factory("S1")({
+ *  path: "core.dispenser.holder.s1",
+ *  name: "S1",
+ *  ingredientId: "1234532",
+ *  assemblyName: "",
+ *  type: "syrup",
+ *  });
+ * ```
+ *
+ * ## 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 HolderModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Holder.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to HolderModel
+ *    // and the compiler will know that the model has the HolderModel 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 { Holder } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Holder.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ *
+ * The holder 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 Holder: Readonly<KosModelRegistrationBean<HolderModel, HolderOptions>>;
+//# sourceMappingURL=holder-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"holder-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/holder-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,wBAAwB,EAGzB,MAAM,yBAAyB,CAAC;AAiCjC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAM1D,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AA6YD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+EK;AACL,eAAO,MAAM,MAAM,EAAE,QAAQ,CAC3B,wBAAwB,CAAC,WAAW,EAAE,aAAa,CAAC,CAWrD,CAAC"}

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

@@ -0,0 +1,5 @@
+export { Holder, type HolderTroubleData } from './holder-model';
+export * as HolderServices from './services';
+export type * from './types';
+export * from './utils/holder-utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,cAAc,MAAM,YAAY,CAAC;AAC7C,mBAAmB,SAAS,CAAC;AAC7B,cAAc,sBAAsB,CAAC"}

package/models/models/holder/services/assignment-services.d.ts

@@ -0,0 +1,25 @@
+export interface Assignment {
+    ingredientId: string;
+    holderPath: string;
+    containerId?: string;
+    fuelGauge?: number;
+}
+export interface AssignmentFactoryJson {
+    stickerId: string;
+    stickerCode: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial dispenser data.
+ */
+export declare const getAssignments: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<Assignment[]> | undefined>;
+export type AssignmentErrorType = "errIdLen" | "errCodeLen" | "errIdFormat" | "errCodeFormat" | "errVerify" | "errBadJson" | "unknownError";
+type AssignmentResponse = [
+    AssignmentErrorType | undefined,
+    Assignment | undefined
+];
+export declare const sendRfidOverride: (holderPath: string, overrides: any) => Promise<AssignmentResponse>;
+export declare const addAssignment: (assignment: Assignment) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+export declare const deleteAssignment: (id: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
+export {};
+//# sourceMappingURL=assignment-services.d.ts.map

package/models/models/holder/services/assignment-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/services/assignment-services.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AACD;;;GAGG;AACH,eAAO,MAAM,cAAc,+FAG1B,CAAC;AACF,MAAM,MAAM,mBAAmB,GAC3B,UAAU,GACV,YAAY,GACZ,aAAa,GACb,eAAe,GACf,WAAW,GACX,YAAY,GACZ,cAAc,CAAC;AACnB,KAAK,kBAAkB,GAAG;IACxB,mBAAmB,GAAG,SAAS;IAC/B,UAAU,GAAG,SAAS;CACvB,CAAC;AACF,eAAO,MAAM,gBAAgB,eACf,MAAM,aACP,GAAG,KACb,QAAQ,kBAAkB,CAsB5B,CAAC;AAEF,eAAO,MAAM,aAAa,eAAsB,UAAU,mFAUzD,CAAC;AAEF,eAAO,MAAM,gBAAgB,OAAc,MAAM,uFAGhD,CAAC"}

package/models/models/holder/services/holder-services.d.ts

@@ -0,0 +1,28 @@
+export interface Pump {
+    inserted: boolean;
+    beveragePour: boolean;
+    ingredientPour: boolean;
+    type: string;
+    category: string;
+    ingredientId: string;
+    holderPath: string;
+    boardPath: string;
+    nozzlePath: string;
+    name: string;
+    path: string;
+}
+export interface HolderResponse {
+    path: string;
+    name: string;
+    ingType: string;
+    ingSource: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial Holder data.
+ */
+export declare const getHolders: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<HolderResponse[]> | undefined>;
+export declare const assignHolderIngredient: (holderPath: string, ingredientId: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+export declare const unassignHolderIngredient: (holderPath: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
+export declare const replaceLine: (holderPath: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+//# sourceMappingURL=holder-services.d.ts.map

package/models/models/holder/services/holder-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"holder-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/services/holder-services.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,IAAI;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AACD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AACD;;;GAGG;AACH,eAAO,MAAM,UAAU,mGAGtB,CAAC;AAEF,eAAO,MAAM,sBAAsB,eACrB,MAAM,gBACJ,MAAM,mFAYrB,CAAC;AAEF,eAAO,MAAM,wBAAwB,eAAsB,MAAM,uFAWhE,CAAC;AAEF,eAAO,MAAM,WAAW,eAAsB,MAAM,mFAanD,CAAC"}

package/models/models/holder/services/index.d.ts

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

package/models/models/holder/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/holder/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}

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

@@ -0,0 +1,170 @@
+import { Assignment } from '../services';
+import { IntentAware } from '../../types/intent';
+import { HolderSlice } from '../../types/assembly';
+import { PumpModel } from '../../pump/types';
+import { IngredientModel } from '../../ingredient';
+import { IKosDataModel, IKosModelContainer, TroubleAware } from '@kosdev-code/kos-ui-sdk';
+
+
+export interface HolderOptions<AdditionalData extends object = any> {
+  path: string;
+  name: string;
+  enjoyByDate?: Date;
+  ingredientId?: string;
+  ingredientType?: string;
+  ingredientSource?: string;
+  group: string;
+  slice: HolderSlice;
+  data: AdditionalData;
+}
+
+/**
+ * Abstraction of how an ingredient cartridge attaches to a pump. In many cases
+ * this is simply a hose that connects a BiB container to a pump, but in more
+ * complex devices this represents a cartridge slot which may have associated
+ * hardware, such as RFID antenna, indicator lights, and so on. This also holds
+ * state about the availability of a pump to pump the connected ingredient.
+ *
+ * @category Model
+ */
+export interface HolderModel<AdditionalData extends object = any>
+  extends IKosDataModel,
+    IntentAware,
+    TroubleAware {
+  id: string;
+  name: string;
+  path: string;
+  ingredientId?: string;
+  ingredientType?: string;
+  ingredientSource?: string;
+  group: string;
+  slice: HolderSlice;
+  enjoyByDate?: Date;
+  hasEnjoyByWarning: boolean;
+  prevIngredientId?: string;
+
+  readonly maxVolume: number;
+  readonly remainingVolume: number;
+  readonly hasMaxVolume: boolean;
+  readonly hasRemainingVolume: boolean;
+  readonly fillPercent: number;
+  readonly hasFuelGuage: boolean;
+  readonly hasEnjoyByDate: boolean;
+
+  removed: boolean;
+  unassigned: boolean;
+  updateModel(options: HolderOptions): void;
+  data: AdditionalData;
+
+  /**
+   * Perform an RFID override on the holder
+   * @param overrides
+   * @throws AssignmentError(errIdLen) if the id length is invalid
+   * @throws AssignmentError(errCodeLen) if the code length is invalid
+   * @throws AssignmentError(errIdFormat) if the id format is invalid
+   * @throws AssignmentError(errCodeFormat) if the code format is invalid
+   * @throws AssignmentError(errVerify) if the verification fails
+   * @throws AssignmentError(errBadJson) if the json is invalid
+   *
+   * @returns
+   */
+  overrideRfidCode<T extends Record<string, any>>(
+    overrides: T
+  ): Promise<Assignment | undefined>;
+  /**
+   * The name of the ingredient assigned to the holder
+   * @readonly
+   */
+  readonly ingredientName: string;
+  /**
+   * The {@link IngredientModel} assigned to the holder
+   */
+  readonly ingredient?: IngredientModel;
+
+  /**
+   * The name of the previous ingredient assigned to the holder
+   * @readonly
+   */
+  readonly previousIngredientName: string;
+  /**
+   * The previous {@link IngredientModel} assigned to the holder
+   */
+  readonly previousIngredient?: IngredientModel;
+
+  /**
+   * The {@link PumpModel} models assigned to the holder.
+   */
+  pumps: IKosModelContainer<PumpModel>;
+
+  /**
+   * The {@link PumpModel} models assigned to the holder sorted by the pump order.
+   */
+  sortedPumps: PumpModel[];
+
+  /**
+   * The paths of the nozzles that are attached to the holder. It is possible
+   * for a holder to be connected to multiple nozzles depending on the number
+   * of pumps it has.  For example, some dispensers might be configured to share
+   * ingredients across nozzles in cases where less frequently used ingredients
+   * are used in smaller quantities.
+   */
+  readonly nozzlePaths: string[];
+
+  /**
+   * A boolean value that indicates if the ingredient in the holder can be poured.
+   * This is derived from the pour status of all of the underlying pumps.
+   */
+  readonly canPour: boolean;
+
+  /**
+   * A boolean value that indicates if the ingredient in the holder is currently
+   * pouring.
+   *
+   * This is derived from the pour status of the underlying pumps indicating if any
+   * of the pumps are currently pouring.
+   */
+  readonly isPouring: boolean;
+
+  readonly pourState: string;
+
+  /**
+   * Assign an ingredient to the holder.
+   *
+   * This method will call into the {@link assignHolderIngredient} service to assign the ingredient to the holder.
+   *
+   * If unassigning the ingredient, the {@link unassignHolderIngredient} service will be called.
+   *
+   * @param ingredientId The id of the ingredient to assign to the holder.  If not specified, the ingredient will be unassigned.
+   */
+  assignIngredient(ingredientId?: string): Promise<void>;
+
+  /**
+   * Update the ingredient id of the holder.
+   *
+   * This method will update the ingredient id of the holder without calling into the {@link assignHolderIngredient} or {@link unassignHolderIngredient} services.
+   *
+   * It is intended to be used when ingredient assignment events are received from the dispenser, such as when an ingredient is
+   * inserted into a holder and the rfid tag is read.  In this case, the assignment will be received via the topic handler and
+   * the ingredient id will be updated on the holder.
+   *
+   * This method should be used to update state as opposed to the {@link assignIngredient} method which should be used to
+   * perform the actual assignment.
+   *
+   * @param ingredientId The id of the ingredient to assign to the holder.  If not specified, the ingredient will be unassigned.
+   */
+  updateIngredient(ingredientId?: string): void;
+
+  resolveIntentVolume(intent: string): Promise<{ volume: number }>;
+
+  /**
+   * Indicate that the lines associated with holder have been replaced.
+   */
+  replaceLine(): Promise<void>;
+
+  /**
+   * Indicates that one or more of the pumps associated with the holder have constraints that
+   * must be satisfied before pouring can occur.  For example, an ingredient may require agitation
+   * before pouring can occur.  This is used to defer the pour until the constraints are satisfied.
+   */
+  shouldDefer: boolean;
+}