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

package/lib/agitation-control/agitation-control-model.d.ts

@@ -0,0 +1,53 @@
+import { FutureAwareContainer, FutureContainer, IFutureModel, IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '@kosdev-code/kos-ui-sdk';
+import { AgitationControlOptions } from './types';
+export declare const MODEL_TYPE = "agitation-control-model";
+export declare const FUTURE_RESOLVE = "resolve";
+export declare const FUTURE_AGITATE = "agitate";
+export type AgitationControlModel = PublicModelInterface<AgitationControlModelImpl>;
+/**
+ * @kosService ddk.agitation-control
+ * @kosApiLevel 1
+ */
+export declare class AgitationControlModelImpl implements IKosDataModel, IKosIdentifiable, FutureContainer {
+    id: string;
+    futureHandler: FutureAwareContainer;
+    private logger;
+    private troubleContainer;
+    private _agitationFutureId?;
+    private _canExit;
+    private _exiting;
+    private _isFailed;
+    private disposer?;
+    private application;
+    constructor(modelId: string, options: AgitationControlOptions, context: KosCreationContext);
+    set isFailed(value: boolean);
+    get isFailed(): boolean;
+    get isDoorClosed(): boolean;
+    get isAgitating(): boolean;
+    set exiting(value: boolean);
+    get exiting(): boolean;
+    get canExit(): boolean;
+    clearAll(): void;
+    get readyToResolve(): boolean;
+    onFutureUpdate(future: IFutureModel<Record<string, unknown>>): void;
+    private inProgress;
+    resolveDeferredTroubles(tracker?: string): Promise<import('@kosdev-code/kos-ui-sdk').FutureResponse | undefined>;
+    get hasQueuedTroubles(): boolean;
+    get queuedTroubles(): import('@kosdev-code/kos-ui-sdk').TroubleModel<any>[];
+    get visibleTroubles(): import('@kosdev-code/kos-ui-sdk').TroubleModel<any>[];
+    get future(): IFutureModel<Record<string, unknown>> | undefined;
+    get resolveFuture(): IFutureModel<Record<string, unknown>> | undefined;
+    get agitateFuture(): IFutureModel<Record<string, unknown>> | undefined;
+    handleAgitationStarted(event: {
+        path: string;
+        futureId: number;
+    }): void;
+    handleAgitationEnded(event: {
+        path: string;
+    }): void;
+    init(): Promise<void>;
+    unload(): void;
+    handleReadyToResolve(): void;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=agitation-control-model.d.ts.map

package/lib/agitation-control/agitation-control-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agitation-control-model.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/agitation-control/agitation-control-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EAEpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EAGrB,KAAK,kBAAkB,EAOvB,KAAK,oBAAoB,EAI1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AASvD,eAAO,MAAM,UAAU,4BAA4B,CAAC;AACpD,eAAO,MAAM,cAAc,YAAY,CAAC;AACxC,eAAO,MAAM,cAAc,YAAY,CAAC;AACxC,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAElD;;;GAGG;AACH,qBACa,yBACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,eAAe;IAE3D,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,oBAAoB,CAAC;IACpC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,kBAAkB,CAAC,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAe;IAEhC,OAAO,CAAC,WAAW,CAAoB;gBAErC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,kBAAkB;IAY7B,IAAI,QAAQ,CAAC,KAAK,EAAE,OAAO,EAE1B;IACD,IAAI,QAAQ,IAHQ,OAAO,CAK1B;IACD,IAAI,YAAY,YAIf;IAED,IAAI,WAAW,YAEd;IAED,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAEzB;IAED,IAAI,OAAO,IAJQ,OAAO,CAMzB;IAED,IAAI,OAAO,YAIV;IAED,QAAQ;IAMR,IAAI,cAAc,YAKjB;IACD,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IA0B5D,OAAO,CAAC,UAAU,CAAgB;IAE5B,uBAAuB,CAAC,OAAO,CAAC,EAAE,MAAM;IAmB9C,IAAI,iBAAiB,YAEpB;IACD,IAAI,cAAc,0DAKjB;IAED,IAAI,eAAe,0DAKlB;IAGD,IAAI,MAAM,sDAET;IAED,IAAI,aAAa,sDAEhB;IAED,IAAI,aAAa,sDAEhB;IAGD,sBAAsB,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;IAMhE,oBAAoB,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;IAKtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM;IAUN,oBAAoB;IAUd,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/lib/agitation-control/agitation-control-registration.d.ts

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

package/lib/agitation-control/agitation-control-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agitation-control-registration.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/agitation-control/agitation-control-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAKvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,gBAAgB,sFAM3B,CAAC"}

package/lib/agitation-control/index.d.ts

@@ -0,0 +1,4 @@
+export { AgitationControl } from './agitation-control-registration';
+export type * from './types';
+export type { AgitationControlModel } from './agitation-control-model';
+//# sourceMappingURL=index.d.ts.map

package/lib/agitation-control/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/agitation-control/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC"}

package/lib/agitation-control/types/index.d.ts

@@ -0,0 +1,5 @@
+import { IKosCompanionOptions, TroubleContainerModel, TroubleContainerOptions } from '@kosdev-code/kos-ui-sdk';
+export type AgitationControlOptions = IKosCompanionOptions<
+  TroubleContainerModel,
+  TroubleContainerOptions
+>;

package/lib/animation/animation-model.d.ts

@@ -0,0 +1,17 @@
+import { IKosDataModel, KosConfigProperty, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
+import { AnimationModel, AnimationOptions } from './types';
+export declare const MODEL_TYPE = "animation-model";
+/**
+ * @kosService ddk.animation
+ * @kosApiLevel 1
+ */
+export declare class AnimationModelImpl implements AnimationModel, IKosDataModel {
+    id: string;
+    private logger;
+    disableAll: KosConfigProperty<boolean>;
+    enableDial: KosConfigProperty<boolean>;
+    enableModal: KosConfigProperty<boolean>;
+    enableSideBar: KosConfigProperty<boolean>;
+    constructor(modelId: string, options: AnimationOptions, context: KosCreationContext);
+}
+//# sourceMappingURL=animation-model.d.ts.map

package/lib/animation/animation-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-model.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/animation/animation-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EAEjB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhE,eAAO,MAAM,UAAU,oBAAoB,CAAC;AAE5C;;;GAGG;AACH,qBACa,kBAAmB,YAAW,cAAc,EAAE,aAAa;IACtE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAMjC,UAAU,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAMxC,UAAU,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAMxC,WAAW,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAMzC,aAAa,EAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;gBAGzC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,kBAAkB;CAQ9B"}

package/lib/animation/animation-registration.d.ts

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

package/lib/animation/animation-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-registration.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/animation/animation-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,SAAS,EAAE,QAAQ,CAC9B,iCAAiC,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAWpE,CAAC"}

package/lib/animation/index.d.ts

@@ -0,0 +1,4 @@
+export { Animation } from './animation-registration';
+export type * from './types';
+export * as AnimationServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/lib/animation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/animation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,iBAAiB,MAAM,YAAY,CAAC"}

package/lib/animation/services/animation-services.d.ts

@@ -0,0 +1,10 @@
+interface AnimationResponse {
+    id: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial animation data.
+ */
+export declare const getAnimations: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<AnimationResponse[]> | undefined>;
+export {};
+//# sourceMappingURL=animation-services.d.ts.map

package/lib/animation/services/animation-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-services.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-ddk-models/src/lib/animation/services/animation-services.ts"],"names":[],"mappings":"AAcA,UAAU,iBAAiB;IACzB,EAAE,EAAE,MAAM,CAAC;CACZ;AACD;;;GAGG;AACH,eAAO,MAAM,aAAa,sGAIzB,CAAC"}

package/lib/animation/services/index.d.ts

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

package/lib/animation/services/index.d.ts.map

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

package/lib/animation/types/index.d.ts

@@ -0,0 +1,12 @@
+import { IKosIdentifiable, KosConfigProperty } from '@kosdev-code/kos-ui-sdk';
+export interface AnimationOptions {}
+
+export interface AnimationModel extends IKosIdentifiable {
+  disableAll: KosConfigProperty<boolean>;
+
+  enableDial: KosConfigProperty<boolean>;
+
+  enableModal: KosConfigProperty<boolean>;
+
+  enableSideBar: KosConfigProperty<boolean>;
+}

package/lib/application/application-model.d.ts

@@ -0,0 +1,36 @@
+import { DeviceModel, IKosDataModel, KosConfigProperty, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
+import { AuthModel } from '../auth';
+import { DoorModel } from '../door';
+import { SetupStepContainerModel } from '../setup-step';
+import { NavigationItem } from './services';
+import { ApplicationModel, ApplicationOptions, Language } from './types';
+export declare const MODEL_TYPE = "application-model";
+/**
+ * @kosService ddk.application
+ * @kosApiLevel 1
+ */
+export declare class ApplicationModelImpl implements ApplicationModel, IKosDataModel {
+    id: string;
+    device: DeviceModel;
+    authModel: AuthModel;
+    setupStepContainer: SetupStepContainerModel;
+    door: DoorModel;
+    ncuiLanguage: KosConfigProperty<string>;
+    activeCui: KosConfigProperty<string>;
+    fallbackCui: KosConfigProperty<string>;
+    private _cuis;
+    private _navigationItems;
+    languages: Language[];
+    private logger;
+    constructor(modelId: string, _options: ApplicationOptions, context: KosCreationContext);
+    get setupRequired(): boolean;
+    get currentRole(): import('../auth').NcuiRole;
+    get cuis(): {};
+    get navigationItems(): Record<string, NavigationItem>;
+    get hasCuiDefined(): boolean;
+    get doorIsOpen(): boolean;
+    enter(): Promise<void>;
+    exit(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=application-model.d.ts.map

package/lib/application/application-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-model.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/application/application-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,iBAAiB,EAEjB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAQjC,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE9E,eAAO,MAAM,UAAU,sBAAsB,CAAC;AAkB9C;;;GAGG;AACH,qBACa,oBAAqB,YAAW,gBAAgB,EAAE,aAAa;IAC1E,EAAE,EAAE,MAAM,CAAC;IAGX,MAAM,EAAG,WAAW,CAAC;IAGrB,SAAS,EAAG,SAAS,CAAC;IAGtB,kBAAkB,EAAG,uBAAuB,CAAC;IAG7C,IAAI,EAAE,SAAS,CAAC;IAMhB,YAAY,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAMzC,SAAS,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAMtC,WAAW,EAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAExC,OAAO,CAAC,KAAK,CAAqB;IAElC,OAAO,CAAC,gBAAgB,CAAwB;IAmBhD,SAAS,EAAE,QAAQ,EAAE,CAAC;IAEtB,OAAO,CAAC,MAAM,CAAmB;gBAG/B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,kBAAkB;IAa7B,IAAI,aAAa,YAIhB;IAED,IAAI,WAAW,+BAEd;IAED,IAAI,IAAI,OAKP;IAED,IAAI,eAAe,mCAElB;IAED,IAAI,aAAa,YAEhB;IAED,IAAI,UAAU,YAEb;IAEK,KAAK;IAKL,IAAI;IAMJ,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAgC5B"}

package/lib/application/application-registration.d.ts

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

package/lib/application/application-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-registration.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/application/application-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,WAAW,EAAE,QAAQ,CAChC,iCAAiC,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAaxE,CAAC"}

package/lib/application/index.d.ts

@@ -0,0 +1,4 @@
+export { Application } from './application-registration';
+export type * from './types';
+export type * from './services';
+//# sourceMappingURL=index.d.ts.map

package/lib/application/index.d.ts.map

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

package/lib/application/services/application-services.d.ts

@@ -0,0 +1,32 @@
+export interface LanguageResponse {
+    languages: {
+        name: string;
+        locale: string;
+    }[];
+}
+export interface CuiResponse {
+    name: string;
+    basePath: string;
+    sectionName: string;
+    appId: string;
+}
+export interface NavigationItem {
+    name: string;
+    roles: string[];
+    root?: boolean;
+    options?: {
+        embed?: boolean;
+    };
+    children?: NavigationItem[];
+}
+/**
+ * @category Service
+ * Retrieves the initial language data.
+ */
+export declare const getLanguages: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<LanguageResponse> | undefined>;
+export declare const getCuis: () => Promise<CuiResponse[]>;
+export declare const getDescriptor: <T extends Record<string, any> = any>(path: string) => Promise<T>;
+export declare const getNavigation: () => Promise<NavigationItem[]>;
+export declare const navigateToCui: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
+export declare const navigateToNCui: () => Promise<import('@kosdev-code/kos-ui-sdk').KosServiceResponse<unknown> | undefined>;
+//# sourceMappingURL=application-services.d.ts.map

package/lib/application/services/application-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-services.d.ts","sourceRoot":"","sources":["../../../../../../packages/kos-ddk-models/src/lib/application/services/application-services.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,EAAE,CAAC;CACL;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;CAC7B;AACD;;;GAGG;AACH,eAAO,MAAM,YAAY,mGAMxB,CAAC;AAEF,eAAO,MAAM,OAAO,8BAUnB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EACrE,MAAM,MAAM,KACX,OAAO,CAAC,CAAC,CAwBX,CAAC;AAEF,eAAO,MAAM,aAAa,iCAwBzB,CAAC;AAEF,eAAO,MAAM,aAAa,0FAMzB,CAAC;AAEF,eAAO,MAAM,cAAc,0FAM1B,CAAC"}

package/lib/application/services/index.d.ts

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

package/lib/application/services/index.d.ts.map

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

package/lib/application/types/index.d.ts

@@ -0,0 +1,29 @@
+import { IKosIdentifiable, KosConfigProperty, DeviceModel } from '@kosdev-code/kos-ui-sdk';
+import { AuthModel, NcuiRole } from '../../auth';
+import { CuiResponse, NavigationItem } from '../services';
+export interface ApplicationOptions {}
+
+export interface Language {
+  name: string;
+  locale: string;
+}
+
+export interface ApplicationModel extends IKosIdentifiable {
+  // enableDialAnimation: KosConfigProperty<boolean>;
+  // enableModalAnimation: KosConfigProperty<boolean>;
+  // enableSidebarAnimation: KosConfigProperty<boolean>;
+  activeCui: KosConfigProperty<string>;
+  authModel: AuthModel;
+  cuis: Record<string, CuiResponse>;
+  currentRole: NcuiRole;
+  device: DeviceModel;
+  doorIsOpen: boolean;
+  enter: () => Promise<void>;
+  exit: () => Promise<void>;
+  fallbackCui: KosConfigProperty<string>;
+  hasCuiDefined: boolean;
+  languages: Language[];
+  navigationItems: Record<string, NavigationItem>;
+  ncuiLanguage: KosConfigProperty<string>;
+  setupRequired: boolean;
+}

package/lib/auth/auth-model.d.ts

@@ -0,0 +1,20 @@
+import { IKosDataModel, KosCreationContext } from '@kosdev-code/kos-ui-sdk';
+import { AuthResponse } from './services';
+import { AuthModel, AuthOptions, NcuiRole } from './types';
+export declare const MODEL_TYPE = "auth-model";
+/**
+ * @kosService ddk.auth
+ * @kosApiLevel 1
+ */
+export declare class AuthModelImpl implements AuthModel, IKosDataModel {
+    id: string;
+    private logger;
+    currentRole: NcuiRole;
+    constructor(modelId: string, options: AuthOptions, context: KosCreationContext);
+    authorize(pinCode: string): Promise<boolean>;
+    init(): Promise<void>;
+    load(): Promise<void>;
+    handleRoleChange(role: AuthResponse): void;
+    forceRole(role: NcuiRole): void;
+}
+//# sourceMappingURL=auth-model.d.ts.map

package/lib/auth/auth-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-model.d.ts","sourceRoot":"","sources":["../../../../../packages/kos-ddk-models/src/lib/auth/auth-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAA+B,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhE,eAAO,MAAM,UAAU,eAAe,CAAC;AAIvC;;;GAGG;AACH,qBACa,aAAc,YAAW,SAAS,EAAE,aAAa;IAC5D,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,WAAW,EAAE,QAAQ,CAAC;gBAEpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,kBAAkB;IAUvB,SAAS,CAAC,OAAO,EAAE,MAAM;IAczB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAe3B,gBAAgB,CAAC,IAAI,EAAE,YAAY;IAGnC,SAAS,CAAC,IAAI,EAAE,QAAQ;CAGzB"}

package/lib/auth/auth-registration.d.ts

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