@kosdev-code/kos-dispense-sdk 2.0.2

package/models/models/ingredient-container/ingredient-container-model.d.ts

@@ -0,0 +1,80 @@
+import { IngredientContainerModel, IngredientContainerOptions } from './types';
+import { SingletonKosModelRegistrationBean } from '@kosdev-code/kos-ui-sdk';
+
+/**
+ * # IngredientContainer
+ *
+ * The registration bean includes convenience methods for creating and working with IngredientContainerModel 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: IngredientContainer.type})
+ * private holderContainerModel: IngredientContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory function that can be used to create new IngredientContainerModel 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 = IngredientContainer.factory({ });
+ * ```
+ *
+ * ## 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 IngredientContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (IngredientContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to IngredientContainerModel
+ *    // and the compiler will know that the model has the IngredientContainerModel 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 { IngredientContainer } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...IngredientContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ * The IngredientContainer model is a singleton.  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.
+ *
+ * * */
+export declare const IngredientContainer: SingletonKosModelRegistrationBean<IngredientContainerModel, IngredientContainerOptions>;
+//# sourceMappingURL=ingredient-container-model.d.ts.map

package/models/models/ingredient-container/ingredient-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingredient-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-dispense-sdk/src/models/models/ingredient-container/ingredient-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,iCAAiC,EAClC,MAAM,yBAAyB,CAAC;AAajC,OAAO,KAAK,EACV,wBAAwB,EACxB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAoFjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EO;AACP,eAAO,MAAM,mBAAmB,EAAE,iCAAiC,CACjE,wBAAwB,EACxB,0BAA0B,CAc3B,CAAC"}

package/models/models/ingredient-container/types/index.d.ts

@@ -0,0 +1,67 @@
+import { IngredientModel } from '../../ingredient/types';
+import { IKosDataModel, IKosModelContainer } from '@kosdev-code/kos-ui-sdk';
+
+
+export interface IngredientContainerOptions {}
+
+/**
+ * The IngredientContainer represents the collection of {@link IngredientModel} entities that are considered as part of the kOS Beverage Graph.
+ *
+ * Its primary purpose is expose the set of ingredients that can be used to compose a pourable beverage.  The presence or absence
+ * of an ingredient in the container will determine if the ingredient is available for use in the beverage graph.
+ *
+ * The ingredient container will index all of the underlying ingredients by the `type` property of the ingredient. This allows for
+ * the grouping and filtering of ingredients based on the `type` property.  For example, to get the ingredients that are used for flavor shots,
+ * you would call {@link IngredientContainer.getIngredientsByType} with the `type` of the flavor shot.
+ *
+ * The Ingredient is a {@link IKosDataModel} and is registered with the model registry using the {@link IngredientContainer} type.
+ *
+ *
+ * @see {@link IngredientServices.getIngredients} - The ingredient service will retrieve the set of ingredients.
+ *
+ * ## Lifecycle
+ *
+ * ### Load
+ *
+ * During the `load` phase of the model lifecycle, the set of {@link IngredientModel} models will be retrieved and processed.  The nodes will be indexed based on
+ * the defined `type` for the node.  The `type` is defined as part of the backend Ingredient model.
+ *
+ * #### Extension Points
+ *
+ * The `load` lifecycle hook will call into the {@link ExtensionType.IngredientLoader} extension point in order to establish the context
+ * that will be used to populate the ingredients nodes.  Use of this extension point is optional.
+ *
+ * The `load` lifecycle hook will  call into the {@link ExtensionType.IngredientMapper} for each ingredient node that is retrieved from the backend.
+ * The extension point will be called with the Ingredient context data and the {@link IngredientServices.IngredientResponse} for the ingredient node and will
+ * map the results into the {@link IngredientModel} as part of the `data` property.
+ *
+ * The `load` lifecycle hook will call into the {@link ExtensionType.IngredientTypeMapper} for each ingredient node that is retrieved from the backend.
+ * The extension point will be called with the Ingredient context data and the {@link IngredientServices.IngredientResponse} for the ingredient node. The results will
+ * be mapped into the {@link IngredientModel} as the `type` property.
+ *
+ *
+ * @see {@link IngredientContainer}
+ *
+ * @category Model
+ */
+export interface IngredientContainerModel<AdditionalData extends object = {}>
+  extends IngredientContainerOptions,
+    IKosDataModel,
+    AdditionalData {
+  id: string;
+  /**
+   * The set of ingredients that are available for use in the beverage graph.
+   * @readonly
+   * */
+  ingredients: IKosModelContainer<IngredientModel>;
+
+  /**
+   * Utility method to retrieve the ingredients that are associated with the specified type.
+   * @param type The type of the ingredient to retrieve.
+   * @returns The set of ingredients that are associated with the specified type.
+   * */
+  getIngredientsByType(type: string): IngredientModel<AdditionalData>[];
+
+  /** @internal */
+  updateModel(options: IngredientContainerOptions): void;
+}

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

@@ -0,0 +1,5 @@
+export { Nozzle, type NozzleModel } from './nozzle-model';
+export type { NozzleOptions, SelectedPourable } from './types';
+/** @category kOS Services */
+export * as NozzleServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

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

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>[];
+    /**
+     * The availability nodes that have been grouped into the "brands" group.
+     *
+     */
+    get brands(): AvailabilityModel<any>[];
+    get visibleBrands(): AvailabilityModel<any>[];
+    get visibleBeverages(): AvailabilityModel<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> | undefined;
+        additional: AvailabilityModel<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> | 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>[];
+    /**
+     * 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>[];
+    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,181 @@
+/**
+ * An individual availability node for a nozzle.
+ * */
+export interface BeverageResponse {
+    /**
+     * 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;
+}
+/**
+ * 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;IAC/B;;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;CACf;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"}