@kosdev-code/kos-ddk-models 0.1.0-dev.5053

package/lib/macro-assignment/macro-assignment-registration.d.ts

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

package/lib/macro-assignment/macro-assignment-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"macro-assignment-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/macro-assignment/macro-assignment-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AACjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAG5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,eAAe,EAAE,QAAQ,CACpC,iCAAiC,CAC/B,oBAAoB,EACpB,sBAAsB,CACvB,CAaF,CAAC"}

package/lib/macro-assignment/services/index.d.ts

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

package/lib/macro-assignment/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/macro-assignment/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/lib/macro-assignment/services/macro-assignment-services.d.ts

@@ -0,0 +1,2 @@
+export declare const purgeMacroPumps: (troubleIds: string[], tracker?: string) => Promise<import('../../../../../../sdk/kos-ui-sdk/src/index.ts').FutureResponse>;
+//# sourceMappingURL=macro-assignment-services.d.ts.map

package/lib/macro-assignment/services/macro-assignment-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"macro-assignment-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/macro-assignment/services/macro-assignment-services.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,eACd,MAAM,EAAE,YACV,MAAM,8DASjB,CAAC"}

package/lib/macro-assignment/types/index.d.ts

@@ -0,0 +1,39 @@
+import { FutureContainer, FutureResponse, IFutureModel, IKosDataModel, TroubleModel } from '../../../../../../sdk/kos-ui-sdk/src/index.ts';
+import { HolderModel, IngredientModel } from '../../../../../../sdk/kos-dispense-sdk/src/index.ts';
+
+
+export interface MacroAssignmentOptions {}
+
+export interface MacroAssignmentModel extends IKosDataModel, FutureContainer {
+  /**
+   * Returns all of the purge troubles for the macro holders.
+   *
+   * Relying on the indexing of troubles by type to find the purge troubles.
+   */
+  readonly holderPurgeTroubles: TroubleModel[];
+
+  /**
+   * Represents the subset of holder that are identified as holding macros.
+   *
+   * This is determined by the group property of the holder which is determined
+   * by the holders position in the dispenser assembly.
+   */
+  readonly macroHolders: HolderModel[];
+  readonly macroIngredients: IngredientModel[];
+  readonly hasHolderPurgeTroubles: boolean;
+  readonly hasHolderPrimeTroubles: boolean;
+
+  /**
+   * Returns true if there are any macro holders in the dispenser assembly
+   */
+  readonly hasMacroHolders: boolean;
+
+  readonly hasMacroIngredients: boolean;
+
+  /**
+   * shortcut to the current running future
+   */
+  readonly future?: IFutureModel;
+
+  resolveAll: (type: string) => Promise<FutureResponse>;
+}

package/lib/network-test/index.d.ts

@@ -0,0 +1,5 @@
+export { NetworkTestContainer } from './network-test-container-registration';
+export { NetworkTest } from './network-test-registration';
+export type * from './types';
+export * as NetworkTestServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/lib/network-test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/network-test/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,mBAAmB,MAAM,YAAY,CAAC"}

package/lib/network-test/network-test-container-model.d.ts

@@ -0,0 +1,23 @@
+import { NetworkTestContainerModel, NetworkTestContainerOptions, NetworkTestModel } from './types';
+import { ReportItem } from './services';
+import { FutureAwareContainer, IFutureModel, IKosModelContainer, KosCreationContext } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+export declare const MODEL_TYPE = "network-test-container-model";
+export declare class NetworkTestContainerModelImpl implements NetworkTestContainerModel {
+    id: string;
+    private logger;
+    lastTested: Date;
+    futureHandler: FutureAwareContainer<ReportItem[]>;
+    models: IKosModelContainer<NetworkTestModel>;
+    constructor(modelId: string, options: NetworkTestContainerOptions, context: KosCreationContext);
+    get data(): NetworkTestModel[];
+    addModel(model: NetworkTestModel): void;
+    removeModel(id: string): void;
+    getModel(id: string): NetworkTestModel | undefined;
+    init(): Promise<void>;
+    getLastTested(groupName: string): string;
+    load(): Promise<void>;
+    performTest(group: string, tracker?: string): Promise<import('../../../../../sdk/kos-ui-sdk/src/index.ts').FutureResponse | undefined>;
+    onFutureUpdate(future: IFutureModel<ReportItem[]>): void;
+}
+//# sourceMappingURL=network-test-container-model.d.ts.map

package/lib/network-test/network-test-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-test-container-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/network-test/network-test-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAElB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAWjC,OAAO,EACL,UAAU,EAIX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACV,yBAAyB,EACzB,2BAA2B,EAC3B,gBAAgB,EAEjB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,UAAU,iCAAiC,CAAC;AAEzD,qBACa,6BACX,YAAW,yBAAyB;IAEpC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,UAAU,EAAE,IAAI,CAAC;IACjB,aAAa,EAAE,oBAAoB,CAAC,UAAU,EAAE,CAAC,CAAC;IACxC,MAAM,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;gBAErD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,2BAA2B,EACpC,OAAO,EAAE,kBAAkB;IAiB7B,IAAI,IAAI,uBAEP;IAED,QAAQ,CAAC,KAAK,EAAE,gBAAgB;IAIhC,WAAW,CAAC,EAAE,EAAE,MAAM;IAItB,QAAQ,CAAC,EAAE,EAAE,MAAM;IAMb,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,aAAa,CAAC,SAAS,EAAE,MAAM;IAUzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCrB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;IAQjD,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,UAAU,EAAE,CAAC;CA+BlD"}

package/lib/network-test/network-test-container-registration.d.ts

@@ -0,0 +1,86 @@
+import { NetworkTestContainerModel, NetworkTestContainerOptions } from './types';
+import { SingletonKosModelRegistrationBean } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+/**
+ * # NetworkTestContainer
+ *
+ * The registration bean includes convenience methods for creating and working with NetworkTestContainerModel 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: NetworkTestContainer.type, id: "networkTestContainerId"})
+ * private networkTestContainerModel: NetworkTestContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new NetworkTestContainerModel 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 = NetworkTestContainer.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 NetworkTestContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (NetworkTestContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to NetworkTestContainerModel
+ *    // and the compiler will know that the model has the NetworkTestContainerModel 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 { NetworkTestContainer } from "@kos-ui/kos-dispenser-model";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...NetworkTestContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The networkTestContainer 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 NetworkTestContainer: Readonly<SingletonKosModelRegistrationBean<NetworkTestContainerModel, NetworkTestContainerOptions>>;
+//# sourceMappingURL=network-test-container-registration.d.ts.map

package/lib/network-test/network-test-container-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-test-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/network-test/network-test-container-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAEjF,OAAO,KAAK,EACV,yBAAyB,EACzB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAMjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CACzC,iCAAiC,CAC/B,yBAAyB,EACzB,2BAA2B,CAC5B,CAeF,CAAC"}

package/lib/network-test/network-test-model.d.ts

@@ -0,0 +1,21 @@
+import { NetworkTestModel, NetworkTestOptions, NetworkTestUpdateOptions } from './types';
+import { ReportResult } from './services';
+import { IKosDataModel, KosCreationContext } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+export declare const MODEL_TYPE = "network-test-model";
+export declare class NetworkTestModelImpl implements NetworkTestModel, IKosDataModel {
+    id: string;
+    group: string;
+    passed: boolean;
+    inProgress: boolean;
+    failureTime?: Date;
+    timestamp?: Date;
+    name: string;
+    results: ReportResult[];
+    private logger;
+    constructor(modelId: string, options: NetworkTestOptions, context: KosCreationContext);
+    updateModel(options: NetworkTestUpdateOptions): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=network-test-model.d.ts.map

package/lib/network-test/network-test-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-test-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/network-test/network-test-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,UAAU,uBAAuB,CAAC;AAE/C,qBACa,oBAAqB,YAAW,gBAAgB,EAAE,aAAa;IAC1E,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,EAAE,CAAC;IAExB,OAAO,CAAC,MAAM,CAAmB;gBAE/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,kBAAkB;IAW7B,WAAW,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAY9C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/lib/network-test/network-test-registration.d.ts

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

package/lib/network-test/network-test-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-test-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/network-test/network-test-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,WAAW,EAAE,QAAQ,CAChC,wBAAwB,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAW/D,CAAC"}

package/lib/network-test/services/index.d.ts

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

package/lib/network-test/services/index.d.ts.map

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

package/lib/network-test/services/network-test-services.d.ts

@@ -0,0 +1,37 @@
+import { FutureResponse } from '../../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+interface NetworkTestResponse {
+    id: string;
+    name: string;
+    group: string;
+}
+export interface ReportResult {
+    name: string;
+    val: string;
+    passed: boolean;
+}
+export interface ReportItem {
+    passed: boolean;
+    timestamp: number;
+    failureTime?: number;
+    inProgress: boolean;
+    results: ReportResult[];
+    name: string;
+    id: string;
+    group: string;
+}
+interface ReportGroup {
+    [k: string]: ReportItem;
+}
+interface NetworkTestReportResponse {
+    [k: string]: ReportGroup;
+}
+/**
+ * @category Service
+ * Retrieves the initial network-test data.
+ */
+export declare const getNetworkTests: () => Promise<NetworkTestResponse[] | undefined>;
+export declare const getTestsReports: () => Promise<NetworkTestReportResponse | undefined>;
+export declare const performGroupTest: (group: string, tracker: string) => Promise<import('../../../../../../sdk/kos-ui-sdk/src/index.ts').KosServiceResponse<FutureResponse> | undefined>;
+export {};
+//# sourceMappingURL=network-test-services.d.ts.map

package/lib/network-test/services/network-test-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-test-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/network-test/services/network-test-services.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAIf,MAAM,yBAAyB,CAAC;AAUjC,UAAU,mBAAmB;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;CACjB;AACD,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,WAAW;IACnB,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;CACzB;AACD,UAAU,yBAAyB;IACjC,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;CAC1B;AACD;;;GAGG;AACH,eAAO,MAAM,eAAe,kDAM3B,CAAC;AAEF,eAAO,MAAM,eAAe,sDAK3B,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAAiB,MAAM,WAAW,MAAM,8FAMpE,CAAC"}

package/lib/network-test/types/index.d.ts

@@ -0,0 +1,44 @@
+import { ReportItem, ReportResult } from '../services';
+import { FutureContainer, IKosDataModel, IKosIdentifiable, IKosModelHolder, Nameable } from '../../../../../../sdk/kos-ui-sdk/src/index.ts';
+
+
+// ---------------  NetworkTest ---------------
+
+export interface NetworkTestOptions {
+  id: string;
+  name: string;
+  group: string;
+}
+
+export interface NetworkTestUpdateOptions {
+  passed: boolean;
+  timestamp: Date;
+  failureTime?: Date;
+  inProgress: boolean;
+  name: string;
+  results: ReportResult[];
+  group: string;
+}
+
+export interface NetworkTestModel
+  extends IKosDataModel,
+    IKosIdentifiable,
+    Nameable {
+  group: string;
+  passed: boolean;
+  inProgress: boolean;
+  failureTime?: Date;
+  timestamp?: Date;
+  results: ReportResult[];
+  updateModel(options: NetworkTestUpdateOptions): void;
+}
+
+// ---------------  NetworkTestContainer ---------------
+export interface NetworkTestContainerOptions {}
+
+export interface NetworkTestContainerModel
+  extends IKosModelHolder<NetworkTestModel>,
+    FutureContainer<ReportItem[]> {
+  performTest(group: string): Promise<FutureResponse>;
+  getLastTested: (group: string) => string;
+}

package/lib/nutritive-sweetener/index.d.ts

@@ -0,0 +1,4 @@
+export { NutritiveSweetener } from './nutritive-sweetener-registration';
+export type * from './types';
+export type { NutritiveSweetenerModel } from './nutritive-sweetener-model';
+//# sourceMappingURL=index.d.ts.map

package/lib/nutritive-sweetener/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/nutritive-sweetener/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC"}

package/lib/nutritive-sweetener/nutritive-sweetener-model.d.ts

@@ -0,0 +1,18 @@
+import { NutritiveSweetenerOptions } from './types';
+import { IKosDataModel, KosCreationContext, PublicModelInterface } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+import { PumpAware } from '../../../../../sdk/kos-freestyle-sdk/src/index.ts';
+import { AssemblyModel } from '../../../../../sdk/kos-dispense-sdk/src/index.ts';
+
+export declare const MODEL_TYPE = "nutritive-sweetener-model";
+export type NutritiveSweetenerModel = PublicModelInterface<NutritiveSweetenerModelImpl>;
+export declare class NutritiveSweetenerModelImpl implements NutritiveSweetenerModel, IKosDataModel, PumpAware {
+    id: string;
+    assemblyModel: AssemblyModel;
+    private logger;
+    constructor(modelId: string, _options: NutritiveSweetenerOptions, context: KosCreationContext);
+    getHolder(): import('../../../../../sdk/kos-dispense-sdk/src/index.ts').HolderModel<any>;
+    getPump(): import('../../../../../sdk/kos-dispense-sdk/src/index.ts').PumpModel<any>;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=nutritive-sweetener-model.d.ts.map

package/lib/nutritive-sweetener/nutritive-sweetener-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nutritive-sweetener-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/nutritive-sweetener/nutritive-sweetener-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD,eAAO,MAAM,UAAU,8BAA8B,CAAC;AAEtD,MAAM,MAAM,uBAAuB,GACjC,oBAAoB,CAAC,2BAA2B,CAAC,CAAC;AAEpD,qBACa,2BACX,YAAW,uBAAuB,EAAE,aAAa,EAAE,SAAS;IAE5D,EAAE,EAAE,MAAM,CAAC;IAGX,aAAa,EAAG,aAAa,CAAC;IAE9B,OAAO,CAAC,MAAM,CAAmB;gBAG/B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,yBAAyB,EACnC,OAAO,EAAE,kBAAkB;IAM7B,SAAS;IAMT,OAAO;IAUD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/lib/nutritive-sweetener/nutritive-sweetener-registration.d.ts

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

package/lib/nutritive-sweetener/nutritive-sweetener-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nutritive-sweetener-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/nutritive-sweetener/nutritive-sweetener-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAEL,uBAAuB,EAExB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CACvC,wBAAwB,CAAC,uBAAuB,EAAE,yBAAyB,CAAC,CAc7E,CAAC"}

package/lib/nutritive-sweetener/services/index.d.ts

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

package/lib/nutritive-sweetener/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/nutritive-sweetener/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}

package/lib/nutritive-sweetener/services/nutritive-sweetener-services.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @category Service
+ * Retrieves the initial nutritive-sweetener data.
+ */
+export declare const performInitializeNS: (_path: string, tracker: string) => Promise<any>;
+//# sourceMappingURL=nutritive-sweetener-services.d.ts.map

package/lib/nutritive-sweetener/services/nutritive-sweetener-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nutritive-sweetener-services.d.ts","sourceRoot":"","sources":["../../../../../../../packages/ddk/kos-ddk-models/src/lib/nutritive-sweetener/services/nutritive-sweetener-services.ts"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,UAAiB,MAAM,WAAW,MAAM,iBAUvE,CAAC"}

package/lib/nutritive-sweetener/types/index.d.ts

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

package/lib/plain-water/index.d.ts

@@ -0,0 +1,4 @@
+export { PlainWater } from './plain-water-registration';
+export type * from './types';
+export type { PlainWaterModel } from './plain-water-model';
+//# sourceMappingURL=index.d.ts.map

package/lib/plain-water/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/plain-water/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC"}