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

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

@@ -0,0 +1,257 @@
+import { NozzleOptions, SelectedPourable } from './types';
+import { AvailabilityResponse } from './services';
+import { PourState } from '../types/pouring';
+import { AvailabilityModel } from '../availability';
+import { FutureAwareContainer, FutureContainer, IFutureModel, IKosDataModel, IKosModelLogger, KosContext, KosContextLogger, KosCreationContext, KosModelRegistrationBean, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+
+export declare const TOPIC_NOZZLE_POUR_STARTED = "/kos/nozzle/pour/started";
+export declare const TOPIC_NOZZLE_POUR_PROGRESS = "/kos/nozzle/pour/progress";
+export declare const TOPIC_NOZZLE_POUR_CANCEL = "/kos/nozzle/pour/cancel";
+/**
+ *
+ */
+declare class NozzleModelImpl implements IKosModelLogger, IKosDataModel, FutureContainer {
+    /** the unique identifier for this nozzle.*/
+    id: string;
+    path: string;
+    logger: KosContextLogger;
+    name: string;
+    private _selectedBeverage?;
+    private _selectedBrand?;
+    private _additionalItems?;
+    private _availabilityItems;
+    futureHandler: FutureAwareContainer;
+    currentState: PourState;
+    beverageTopicPrefix: string;
+    topicPrefix: string;
+    urlPrefix: string;
+    /**
+     * The availability nodes that can be dispensed from this nozzle.
+     * This is a subset of the availability for the entire dispenser
+     * and is determined by the nodes associated with a nozzle.
+     */
+    get beverages(): AvailabilityModel<any, Record<string, any>>[];
+    /**
+     * The availability nodes that have been grouped into the "brands" group.
+     *
+     */
+    get brands(): AvailabilityModel<any, Record<string, any>>[];
+    get visibleBrands(): AvailabilityModel<any, Record<string, any>>[];
+    get visibleBeverages(): AvailabilityModel<any, Record<string, any>>[];
+    /**
+     * A derived value that indicates if the nozzle is currently pouring a beverage.
+     * @readonly
+     */
+    get isPouring(): boolean;
+    /**
+     * A derived value that indicates if the nozzle is currently available to pour a beverage.
+     *
+     * This will generally be determined by whether there is a currently selected pourable AND
+     * the nozzle is not currently pouring.
+     *
+     * The value is observable and will change when the selected pourable changes or the nozzle
+     * starts or stops pouring.
+     * @readonly
+     * */
+    get canPour(): boolean;
+    /**
+     * The selected pourable for this nozzle.  Its shape is determined by the results of the
+     * {@link ExtensionType.SelectedPourableMapper} extension.
+     * @readonly
+     *
+     * */
+    get selectedPourable(): {
+        beverage: AvailabilityModel<any, Record<string, any>> | undefined;
+        additional: AvailabilityModel<any, Record<string, any>>[] | undefined;
+    };
+    get future(): IFutureModel<Record<string, unknown>> | undefined;
+    get pourProgress(): number;
+    constructor(modelId: string, options: NozzleOptions, context: KosCreationContext);
+    updateModel(): void;
+    setSelectedBrand(brand?: AvailabilityModel): void;
+    get selectedBrand(): AvailabilityModel<any, Record<string, any>> | undefined;
+    /**
+     * Set the values used to determine the selected pourable for this nozzle.
+     *
+     * @param pourable The pourable to set.
+     * @param pourable.beverage The beverage selected.
+     * @param pourable.additional The additional items such as flavors or other items that could be incorporated
+     * into the pourable.
+     * */
+    setSelectedPourable({ beverage, additional, context, }: SelectedPourable): Promise<void>;
+    /**
+     * Utility method that will return the availability nodes that belong to the specified
+     * group as defined in the dispenser beverage graph.  For example, a dispenser
+     * implementation may group availability nodes by Brand, Beverage, or Flavors
+     *
+     * @param groupId The group to filter by.
+     * @returns The availability nodes that are available to be dispensed from this nozzle
+     * and are in the specified group.
+     * */
+    getGroupAvailabilityItems<D extends object = any>(groupId: string): AvailabilityModel<D, Record<string, any>>[];
+    /**
+     * Utility method that will return the availability nodes that are tagged with the specified parent id.
+     *
+     * This is useful when brandsets use the taggedIds property to associate nodes with a parent node. For example,
+     * when organizing a brandset into brands and beverages, the brand nodes will be tagged with the beverage nodes.
+     *
+     * @param parentId - The parent id to filter by.
+     * @returns the availability nodes that are tagged with the specified parent id.
+     */
+    getAvailabilityByParent<D extends object = any>(parentId: string): AvailabilityModel<D, Record<string, any>>[];
+    private updateIfCurrent;
+    onFutureUpdate(future: IFutureModel<any>): 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>;
+    /**
+     * An action that will initiate a fixed volume pour for this nozzle using the
+     * specified pourable volume name.
+     *
+     * 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}
+     * */
+    fixedPour(name: string, tracker?: string): Promise<void>;
+    /**
+     * An action that will cancel a pour for this nozzle.
+     * */
+    cancelPour(): Promise<void>;
+    private updateGroupMembers;
+    /** @internal */
+    load(context?: KosContext): Promise<void>;
+    updateAvailability(update: AvailabilityResponse): Promise<void>;
+}
+/**
+ *
+ * The NozzleModel provides the availability of pourables that are
+ * associated with the nozzle.
+ *
+ * Its primary purpose is to provide a mechanism for selecting from available pourables and initiating a pour.
+ *
+ * It is possible for a dispenser to have multiple asymmetrical nozzles.  For example, a dispenser may have
+ * a nozzle that is used for dispensing a syrups and flavors and another that is just dispensing water.
+ *
+ * The NozzleModel is a {@link IKosDataModel} and is registered with the model registry using the {@link Nozzle} type.
+ *
+ *
+ * @see {@link NozzleServices.getAvailability} - The availability service will retrieve the availability for the nozzle.
+ *
+ * ## Lifecycle
+ *
+ * ### Load
+ *
+ * During the `load` phase of the model lifecycle, the set of Availability nodes will be retrieved for the nozzle.  The nodes will be indexed based on
+ * the defined `groupId` for the node.  The `groupId` is defined in the dispenser beverage graph and is used to group availability nodes.
+ *
+ * #### Extension Points
+ *
+ * The `load` lifecycle hook will first call into the {@link ExtensionType.AvailabilityLoader} extension point in order to establish the context
+ * that will be used to populate the availability nodes.
+ *
+ * The `load` lifecycle hook will then call into the {@link ExtensionType.AvailabilityMapper} for each Availability node that is retrieved.
+ * The extension point will be called the the Availability context data and the {@link NozzleServices.BeverageResponse} for the availability node.
+ *
+ *
+ *
+ * @see {@link Nozzle}
+ *
+ *
+ *
+ *
+ * @category Model
+ * @interface
+ *
+
+ */
+export type NozzleModel = PublicModelInterface<NozzleModelImpl>;
+/**
+ *
+ *
+ * # Nozzle
+ *
+ * The registration bean includes convenience methods for creating and working with NozzleModel 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: Nozzle.type, id: "nozzleId"})
+ * private nozzleModel: NozzleModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new NozzleModel 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 = Nozzle.factory("S1")({
+ *    path: "core.assemby.nozzle.nozzle1",
+ *  });
+ * ```
+ *
+ * ## 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 NozzleModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Nozzle.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to NozzleModel
+ *    // and the compiler will know that the model has the NozzleModel interface
+ *    model.pour();
+ * }
+ * ```
+ *
+ * ## 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 { Nozzle } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Nozzle.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ *
+ * The nozzle 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.
+ *
+ *  @category KOS Model Registration
+ * */
+export declare const Nozzle: Readonly<KosModelRegistrationBean<NozzleModel, NozzleOptions>>;
+export {};
+//# sourceMappingURL=nozzle-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nozzle-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/nozzle/nozzle-model.ts"],"names":[],"mappings":"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"}

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

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

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

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

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

@@ -0,0 +1,182 @@
+/**
+ * An individual availability node for a nozzle.
+ * */
+export interface BeverageResponse<Properties extends Record<string, any> = Record<string, any>> {
+    /**
+     * Is the node available for based on the beverage graph.
+     * */
+    available: boolean;
+    /**
+     * an alternate id for the node.  Typically used in cases where there are multiple nozzles where
+     * the same beverage could be available.  This id will represent the common id for the beverage without
+     * the nozzle specific id.
+     * */
+    altId: string;
+    /**
+     * Is the item visible. This is typically used to hide items that are not available.
+     * */
+    visible: boolean;
+    /**
+     * The id of the availability node.
+     * */
+    id: string;
+    type: string;
+    taggedIds?: string[];
+    note?: string;
+    properties?: Properties;
+}
+/**
+ * The response from the availability endpoint.
+ * */
+export interface AvailabilityResponse {
+    /**
+     * Indicates if the availability requires a full calculation of the availability nodes or just a
+     * delta calculation.
+     * */
+    rebuild: boolean;
+    /**
+     * The availability groups for the nozzle.
+     * */
+    groups: {
+        /**
+         * the built-in beverages group
+         * */
+        beverages: BeverageResponse[];
+        /**
+         * the built-in flavors group
+         * */
+        flavors: BeverageResponse[];
+        /**
+         * the built-in brands group
+         * */
+        brands: BeverageResponse[];
+        /**
+         * Additional named groups that are defined by the dispenser.
+         * */
+        [k: string]: BeverageResponse[];
+    };
+}
+/**
+ *
+ * Initiates a pour for the specified nozzle.
+ *
+ * Uses the KOS endpoint [POST] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/pour`
+ *
+ * @param nozzleId - the nozzle id to pour from.
+ * @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
+ *
+ * @example
+ * ```typescript
+ * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ *
+ * await NozzleServices.pourPourable("nozzle-1", "my-tracker");
+ * ```
+ * @see {@link FutureManager.initiateFuture}
+ * @returns - a Future that encapsulates the pour including its status and progress.
+ **/
+export declare const pourPourable: (nozzleId: string, tracker: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+/**
+ *
+ * Initiates a fixed named pour for the specified nozzle.
+ *
+ * Typically used for cases where a named cup size is to be poured where the volume of the pour is
+ * dictated by the name.
+ *
+ *
+ * Uses the KOS endpoint [POST] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/fixed/${name}`
+ *
+ * @param name - name of the fixed pour volume.
+ * @param nozzleId - the nozzle id to pour from.
+ * @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
+ *
+ * @example
+ * ```typescript
+ * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ *
+ * await NozzleServices.pourPourable("nozzle-1", "my-tracker");
+ * ```
+ * @see {@link FutureManager.initiateFuture}
+ * @returns - a Future that encapsulates the pour including its status and progress.
+ **/
+export declare const pourNamedPourable: (name: string, nozzleId: string, tracker: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+/**
+ * Retrieves the availability nodes for a specified nozzle.
+ *
+ * Uses the KOS endpoint [GET] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/availability`
+ *
+ * @param nozzleId - the nozzle id to retrieve availability for.
+ * @returns - the availability nodes for the specified nozzle.
+ * @category Service
+ *
+ *  @example
+ * ```typescript
+ * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ *
+ * const availability = await NozzleServices.getAvailability("nozzle-1");
+ * if (availability?.status !== 200) {
+ *     throw new Error("Failed to load nozzle availability");
+ *  }
+ * ```
+ */
+export declare const getAvailability: (urlPrefix: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<AvailabilityResponse> | undefined>;
+/**
+ * Invokes the endpoint to select a pourable for the specified nozzle.
+ *
+ * Uses the KOS endpoint [POST] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/select`
+ *
+ *
+ * @param nozzleId - the nozzle id to select a pourable for.
+ * @param payload - the payload to send to the endpoint.  The shape of the payload is determined by the
+ * {@link ExtensionType.SelectedPourableMapper} extension.
+ * @category Service
+ * @see {@link ExtensionType.SelectedPourableMapper}
+ * @returns - an emtpy response.
+ *
+ *  @example
+ * ```typescript
+ * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * try {
+ *    const response = await NozzleServices.selectPourable("nozzle-1", {
+ *      beverage: "beverage-1",
+ *      additional: ["flavor-1"],
+ *    });
+ *    if (response?.status !== 200) {
+ *     throw new Error("Failed to select pourable");
+ *    }
+ * } catch (e) {
+ *   console.error(e);
+ * }
+ * ```
+ * */
+export declare const selectPourable: (nozzleId: string, payload: object) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<any> | undefined>;
+/**
+ * Invokes the endpoint to clear the selected pourable for the specified nozzle.
+ * Uses the KOS endpoint [DELETE] `${URL}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/select`
+ *
+ * @param nozzleId - the nozzle id to clear the selected pourable for.
+ * @category Service
+ * @returns - an emtpy response.
+ *  @example
+ * ```typescript
+ * import { NozzleServices } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * try {
+ *    const response = await NozzleServices.clearPourable("nozzle-1");
+ *    if (response?.status !== 200) {
+ *     throw new Error("Failed to clear pourable");
+ *    }
+ * } catch (e) {
+ *   console.error(e);
+ * }
+ * ```
+ * */
+export declare const clearPourable: (nozzleId: string) => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
+//# sourceMappingURL=nozzle-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nozzle-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/nozzle/services/nozzle-services.ts"],"names":[],"mappings":"AAUA;;KAEK;AACL,MAAM,WAAW,gBAAgB,CAC/B,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAE5D;;SAEK;IACL,SAAS,EAAE,OAAO,CAAC;IACnB;;;;SAIK;IACL,KAAK,EAAE,MAAM,CAAC;IACd;;SAEK;IACL,OAAO,EAAE,OAAO,CAAC;IAEjB;;SAEK;IACL,EAAE,EAAE,MAAM,CAAC;IAEX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED;;KAEK;AACL,MAAM,WAAW,oBAAoB;IACnC;;;SAGK;IACL,OAAO,EAAE,OAAO,CAAC;IAEjB;;SAEK;IACL,MAAM,EAAE;QACN;;aAEK;QACL,SAAS,EAAE,gBAAgB,EAAE,CAAC;QAC9B;;aAEK;QACL,OAAO,EAAE,gBAAgB,EAAE,CAAC;QAE5B;;aAEK;QACL,MAAM,EAAE,gBAAgB,EAAE,CAAC;QAE3B;;aAEK;QACL,CAAC,CAAC,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAAC;KACjC,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;IAoBI;AACJ,eAAO,MAAM,YAAY,aAAoB,MAAM,WAAW,MAAM,mFAWnE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;IAyBI;AACJ,eAAO,MAAM,iBAAiB,SACtB,MAAM,YACF,MAAM,WACP,MAAM,mFAYhB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe,cAAqB,MAAM,oGAKtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BK;AACL,eAAO,MAAM,cAAc,aAAoB,MAAM,WAAW,MAAM,mFAMrE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;KAoBK;AACL,eAAO,MAAM,aAAa,aAAoB,MAAM,uFAOnD,CAAC"}

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

@@ -0,0 +1,85 @@
+import { AvailabilityModel } from '../../availability';
+
+
+/**
+ * Options for a nozzle.
+ */
+export interface NozzleOptions {
+  /**
+   * The nozzle path.
+   */
+  path: string;
+  name: string;
+  name: string;
+  urlPrefix: string;
+  topicPrefix: string;
+  beverageTopicPrefix: string;
+}
+
+/**
+ * The selected pourable for a nozzle.  This interface provides an abstraction that
+ * determines the combination of beverages and additional items that are selected
+ * for pouring.
+ *
+ * For example, a legacy plus dispenser may have a beverage and additional items such as flavor shots
+ * that a user can select.
+ *
+ * In micro-dosing dispensers, the selected pourable may be a single beverage that is represents a recipe defined in
+ * the brandset.
+ *
+ * The structure of the selected pourable is determined by the {@link ExtensionType.SelectedPourableMapper} extension point
+ * and allows for the payload to be customized for the dispenser implementation.
+ * */
+export interface SelectedPourable {
+  beverage?: AvailabilityModel;
+  additional?: AvailabilityModel[];
+  context?: any;
+}
+
+/**
+ *  The PourAware interface can be implemented on any companion models for the nozzle model to provide
+ *  immediate access to pour lifecycle events such as start, progress, and cancel.
+ */
+export interface PourAware<
+  T extends Record<string, any> = Record<string, any>
+> {
+  /**
+   * Called when a pour is successfully started.
+   */
+  onPourStart?: () => void;
+
+  /**
+   * Called when a pour is cancelled.
+   */
+  onPourCancel?: () => void;
+
+  /**
+   * Called when a pour is in progress. This will give access to the future associated with the pour and
+   * can be used to update the UI with the progress of the pour based on progress future or clientData.
+   *
+   * @param future - The future model for the pour.
+   */
+  onPourProgress: (future: IFutureModel<T>) => void;
+}
+
+interface BasePourEvent {
+  nozzleId: string;
+}
+
+interface PourStartEvent extends BasePourEvent {
+  type: "fixed" | "free";
+}
+
+type PourCancelEvent = BasePourEvent;
+
+interface PourProgressEvent<T extends Record<string, any> = Record<string, any>>
+  extends BasePourEvent {
+  remainingTimeMs: number;
+  endState?: FutureEndState;
+  reason?: string;
+  clientData?: T;
+  futureId: string;
+  status: string;
+  timeRemaining: string;
+  progress: number;
+}

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

@@ -0,0 +1,4 @@
+export { Pump } from './pump-model';
+export type * from './types';
+export * as PumpServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,91 @@
+import { PumpModel, PumpOptions } from './types';
+import { KosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # Pump
+ *
+ * The registration bean includes convenience methods for creating and working with PumpModel 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: Pump.type, id: "pumpId"})
+ * private pumpModel: PumpModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new PumpModel 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 = Pump.factory("S1")({
+ *    name: "S1",
+ *    path: "core.assembly.pump.S1",
+ *    beveragePour: true,
+ *    type: "syrup",
+ *    ingredientId: "1234532",
+ *    holderPath: "core.dispenser.holder.s1",
+ *    boardPath: "core.dispenser.board.s1",
+ *    nozzlePath: "core.dispenser.nozzle.s1",
+ *    inserted: true,
+ *    category: "flavor",
+ *    prevIngredientId: "1234567",
+ *  });
+ * ```
+ *
+ * ## 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 PumpModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Pump.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to PumpModel
+ *    // and the compiler will know that the model has the PumpModel 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 { Pump } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Pump.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ *
+ * The pump 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 Pump: Readonly<KosModelRegistrationBean<PumpModel, PumpOptions>>;
+//# sourceMappingURL=pump-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pump-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/pump/pump-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,wBAAwB,EAEzB,MAAM,yBAAyB,CAAC;AAYjC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAoLtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqFK;AACL,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,wBAAwB,CAAC,SAAS,EAAE,WAAW,CAAC,CAWzE,CAAC"}

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { FutureResponse, KosServiceResponse } from '@kosdev-code/kos-ui-sdk';
+
+export interface PumpResponse {
+    inserted: boolean;
+    beveragePour: boolean;
+    ingredientPour: boolean;
+    type: string;
+    ingredientId: string;
+    holderPath: string;
+    boardPath: string;
+    nozzlePath: string;
+    name: string;
+    path: string;
+    category: string;
+}
+interface IntentRequest {
+    intent: string;
+    pumpId: string;
+    tracker: string;
+}
+interface IntentVolumeResponse {
+    volume: number;
+}
+export declare const sendIntent: ({ intent, pumpId, tracker, }: IntentRequest) => Promise<KosServiceResponse<FutureResponse> | undefined>;
+export declare const getIntentVolume: (pumpId: string, intent: string) => Promise<IntentVolumeResponse>;
+export {};
+//# sourceMappingURL=pump-services.d.ts.map