@kosdev-code/kos-ddk-models 0.1.0-dev.5171 → 0.1.0-dev.5179

package/lib/trouble-action/index.d.ts

@@ -1,4 +1,7 @@
+/**
+ * (C) Copyright 2024, TCCC, All rights reserved.
+ */
+export { TroubleAction as TroubleActionManager } from './trouble-action-model';
 export type { TroubleActionModel as TroubleActionManagerModel } from './trouble-action-model';
-export { TroubleAction as TroubleActionManager } from './trouble-action-registration';
 export type { TroubleActionData as TroubleActionManagerData, TroubleActionOptions as TroubleActionManagerOptions, } from './types';
 //# sourceMappingURL=index.d.ts.map

package/lib/trouble-action/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/trouble-action/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,kBAAkB,IAAI,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAC9F,OAAO,EAAE,aAAa,IAAI,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACtF,YAAY,EACV,iBAAiB,IAAI,wBAAwB,EAC7C,oBAAoB,IAAI,2BAA2B,GACpD,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/trouble-action/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC/E,YAAY,EAAE,kBAAkB,IAAI,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAC9F,YAAY,EACV,iBAAiB,IAAI,wBAAwB,EAC7C,oBAAoB,IAAI,2BAA2B,GACpD,MAAM,SAAS,CAAC"}

package/lib/trouble-action/trouble-action-model.d.ts

@@ -1,20 +1,277 @@
 import { TroubleActionOptions } from './types';
-import { IKosDataModel, IKosIdentifiable, KosCreationContext, KosData, PublicModelInterface } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, KosData, KosLoggerAware, PublicModelInterface, SingletonKosModelRegistrationFactory } from '../../../../../sdk/kos-ui-sdk/src/index.ts';
 
+/**
+ * Model type identifier for the TroubleAction singleton model.
+ *
+ * This constant is used for model registration and identification within
+ * the KOS framework. As a singleton model, only one instance exists per
+ * application lifecycle.
+ *
+ * @category Model Configuration
+ */
 export declare const MODEL_TYPE = "trouble-action-model";
+/**
+ * Public interface type for the TroubleActionModel.
+ *
+ * This type represents the publicly accessible interface of the TroubleActionModel,
+ * exposing only the methods and properties intended for external consumption.
+ * Use this type when declaring dependencies on the TroubleActionModel.
+ *
+ * @category Model Types
+ * @see {@link TroubleActionModelImpl} for the implementation details
+ */
 export type TroubleActionModel = PublicModelInterface<TroubleActionModelImpl>;
+/**
+ * Interface definition for TroubleActionModel implementation.
+ *
+ * Manages trouble action state by monitoring active troubles and mapping them
+ * to configurable state key-value pairs. This singleton model acts as a centralized
+ * coordinator between the trouble system and UI state management.
+ *
+ * @author Mark Pomerant (mark@matrica.ca)
+ * @version 2.1.1
+ * @category Model Interface
+ */
+export interface TroubleActionModelImpl extends KosLoggerAware {
+}
+/**
+ * Singleton model that manages trouble action state for beverage dispensing systems.
+ *
+ * The TroubleActionModel monitors active troubles in the system and maintains a
+ * reactive state object that maps trouble types to configured state values. This
+ * enables UI components to respond to trouble conditions without directly coupling
+ * to the trouble system.
+ *
+ * **Key Features:**
+ * - Singleton model ensuring single source of truth for trouble action state
+ * - Automatic synchronization with TroubleContainer changes
+ * - Configurable mapping between trouble types and state representations
+ * - Reactive state updates via KosData observables
+ * - Support for custom state keys and values per trouble type
+ *
+ * **Architecture:**
+ * - Depends on TroubleContainerModel for trouble data
+ * - Uses @kosModelEffect for reactive trouble monitoring
+ * - Maintains internal mapping of trouble definitions to state values
+ *
+ * @example
+ * ```typescript
+ * // Register and create the singleton TroubleActionModel
+ * import { TroubleAction } from '@kosdev-code/kos-ddk-models';
+ *
+ * const troubleActionModel = TroubleAction.instance().options({
+ *   definitions: [
+ *     {
+ *       troubleType: 'InsufficientAgitationTrouble',
+ *       stateKey: 'agitationRequired',
+ *       stateValue: 'true'
+ *     },
+ *     {
+ *       troubleType: 'CartridgeEmptyTrouble',
+ *       stateKey: 'cartridgeStatus',
+ *       stateValue: 'empty'
+ *     }
+ *   ]
+ * }).build();
+ *
+ * // Access state in React components
+ * const agitationRequired = troubleActionModel.state.agitationRequired;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Monitor active trouble in a React component
+ * import { useKosModel } from '@kosdev-code/kos-ui-sdk';
+ * import { TroubleAction } from '@kosdev-code/kos-ddk-models';
+ *
+ * function TroubleIndicator() {
+ *   const troubleAction = useKosModel(TroubleAction);
+ *   const activeTroubleType = troubleAction.activeTroubleType;
+ *
+ *   if (!activeTroubleType) {
+ *     return <div>No active troubles</div>;
+ *   }
+ *
+ *   return <div>Active: {activeTroubleType}</div>;
+ * }
+ * ```
+ *
+ * @category DDK Models
+ * @see {@link TroubleContainerModel} for the underlying trouble data source
+ * @see {@link TroubleActionOptions} for configuration options
+ * @see {@link TroubleActionData} for trouble definition structure
+ */
 export declare class TroubleActionModelImpl implements IKosDataModel, IKosIdentifiable {
+    /**
+     * Registration factory for creating TroubleActionModel instances.
+     *
+     * This static property is automatically populated by the @kosModel decorator
+     * and provides the registration interface for creating and configuring the
+     * singleton TroubleActionModel instance.
+     *
+     * @example
+     * ```typescript
+     * const troubleAction = TroubleActionModelImpl.Registration
+     *   .instance()
+     *   .options({ definitions: [...] })
+     *   .build();
+     * ```
+     *
+     * @category Model Registration
+     */
+    static Registration: SingletonKosModelRegistrationFactory<TroubleActionModel, TroubleActionOptions>;
+    /**
+     * Unique identifier for this model instance.
+     *
+     * Set during construction and used for model lifecycle management
+     * and debugging purposes.
+     *
+     * @category Model Properties
+     */
     id: string;
-    private logger;
+    /**
+     * Dependency on the TroubleContainer singleton model.
+     *
+     * Provides access to the system's active troubles collection. Changes to
+     * the trouble container automatically trigger state updates via the
+     * handleTroubleActions effect.
+     *
+     * @category Dependencies
+     * @see {@link TroubleContainerModel}
+     */
     private troubleContainer;
-    private disposer?;
+    /**
+     * Observable state object mapping trouble state keys to values.
+     *
+     * This reactive state object is automatically updated when troubles are
+     * added or removed from the system. Keys and values are determined by
+     * the trouble action definitions provided during model initialization.
+     *
+     * State keys that no longer have associated active troubles are set to
+     * undefined.
+     *
+     * @example
+     * ```typescript
+     * // Access state values
+     * const isAgitationRequired = troubleActionModel.state.agitationRequired;
+     *
+     * // State is reactive - updates automatically propagate to React components
+     * ```
+     *
+     * @category Model State
+     */
     state: KosData<Record<string, string | undefined>>;
+    /**
+     * Internal mapping of trouble types to their action definitions.
+     *
+     * Built from the definitions array provided in TroubleActionOptions during
+     * construction. Used for efficient lookup when processing trouble changes.
+     *
+     * @category Internal State
+     */
     private troubleActionData;
+    /**
+     * Creates a new TroubleActionModel instance.
+     *
+     * Initializes the model with trouble action definitions that map trouble
+     * types to state key-value pairs. The model begins monitoring the trouble
+     * container immediately upon creation.
+     *
+     * @param modelId - Unique identifier for this model instance
+     * @param options - Configuration options containing trouble action definitions
+     * @param context - KOS creation context providing logger and framework services
+     *
+     * @category Lifecycle
+     */
     constructor(modelId: string, options: TroubleActionOptions, context: KosCreationContext);
+    /**
+     * Gets the first active trouble that has an associated action definition.
+     *
+     * Returns the first trouble found that matches any of the configured trouble
+     * action definitions. If multiple troubles are active, priority is determined
+     * by the order of trouble type keys in the troubleActionData object.
+     *
+     * @returns The active trouble model, or undefined if no matching troubles exist
+     *
+     * @example
+     * ```typescript
+     * const trouble = troubleActionModel.activeTrouble;
+     * if (trouble) {
+     *   console.log(`Active trouble: ${trouble.type}`);
+     *   console.log(`Resolvable: ${trouble.resolvable}`);
+     * }
+     * ```
+     *
+     * @category Trouble Access
+     * @see {@link TroubleContainerModel} for trouble data structure
+     */
     get activeTrouble(): import('../../../../../sdk/kos-ui-sdk/src/index.ts').TroubleModel<any> | undefined;
+    /**
+     * Gets the type of the first active trouble with an associated action definition.
+     *
+     * Convenience getter that extracts the trouble type from the active trouble.
+     * Commonly used for conditional UI rendering based on trouble type.
+     *
+     * @returns The active trouble type string, or undefined if no troubles are active
+     *
+     * @example
+     * ```typescript
+     * const troubleType = troubleActionModel.activeTroubleType;
+     * if (troubleType === 'InsufficientAgitationTrouble') {
+     *   // Show agitation required UI
+     * }
+     * ```
+     *
+     * @category Trouble Access
+     */
     get activeTroubleType(): string | undefined;
-    init(): Promise<void>;
-    unload(): void;
-    load(): Promise<void>;
+    /**
+     * Reactive effect that synchronizes trouble action state with active troubles.
+     *
+     * Automatically called when the trouble container's data changes. Updates the
+     * model's state object to reflect current trouble conditions:
+     * - Adds state entries for newly active troubles
+     * - Removes state entries (sets to undefined) for resolved troubles
+     * - Uses configured stateKey and stateValue from trouble definitions
+     *
+     * The effect dependencies ensure this method runs whenever troubles are added
+     * or removed from the system.
+     *
+     * @remarks
+     * This method is decorated with @kosModelEffect to establish reactive dependencies
+     * on the trouble container's data. It should not be called directly.
+     *
+     * @category Effects
+     * @see {@link kosModelEffect} for reactive effect pattern documentation
+     */
+    handleTroubleActions(): void;
 }
+/**
+ * Singleton registration factory for the TroubleActionModel.
+ *
+ * Use this export to create and configure the TroubleAction singleton model
+ * in your application. The factory provides a fluent interface for instance
+ * creation and configuration.
+ *
+ * @example
+ * ```typescript
+ * import { TroubleAction } from '@kosdev-code/kos-ddk-models';
+ *
+ * const troubleAction = TroubleAction.instance().options({
+ *   definitions: [
+ *     {
+ *       troubleType: 'InsufficientAgitationTrouble',
+ *       stateKey: 'agitationRequired',
+ *       stateValue: 'true'
+ *     }
+ *   ]
+ * }).build();
+ * ```
+ *
+ * @category Model Registration
+ * @see {@link TroubleActionModel} for the model interface
+ * @see {@link TroubleActionOptions} for configuration options
+ */
+export declare const TroubleAction: SingletonKosModelRegistrationFactory<TroubleActionModel, TroubleActionOptions>;
 //# sourceMappingURL=trouble-action-model.d.ts.map

package/lib/trouble-action/trouble-action-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trouble-action-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/trouble-action/trouble-action-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,OAAO,EACP,oBAAoB,EAErB,MAAM,yBAAyB,CAAC;AAQjC,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEvE,eAAO,MAAM,UAAU,yBAAyB,CAAC;AAEjD,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAE9E,qBACa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAGjC,OAAO,CAAC,gBAAgB,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IACnD,OAAO,CAAC,iBAAiB,CAAoC;gBAE3D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,kBAAkB;IAa7B,IAAI,aAAa,oEAgBhB;IAED,IAAI,iBAAiB,uBAEpB;IACK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B3B,MAAM,IAAI,IAAI;IAGR,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}
+{"version":3,"file":"trouble-action-model.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/trouble-action/trouble-action-model.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,OAAO,EACP,cAAc,EACd,oBAAoB,EACpB,oCAAoC,EAErC,MAAM,yBAAyB,CAAC;AASjC,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEvE;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,yBAAyB,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAE9E;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;CAAG;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,qBAEa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,YAAY,EAAE,oCAAoC,CACvD,kBAAkB,EAClB,oBAAoB,CACrB,CAAC;IAEF;;;;;;;OAOG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;;;;;OASG;IAEH,OAAO,CAAC,gBAAgB,CAAyB;IAEjD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAEnD;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB,CAAoC;IAE7D;;;;;;;;;;;;OAYG;gBAED,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,kBAAkB;IAa7B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,aAAa,oEAgBhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,iBAAiB,uBAEpB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IAIH,oBAAoB;CAsBrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,aAAa,gFAAsC,CAAC"}

package/lib/trouble-action/types/index.d.ts

@@ -1,8 +1,103 @@
+/**
+ * Definition for a single trouble action mapping.
+ *
+ * Describes how a specific trouble type should be represented in the
+ * TroubleActionModel's state object. Each definition maps a trouble type
+ * to a state key-value pair that UI components can observe.
+ *
+ * @example
+ * ```typescript
+ * const agitationTroubleAction: TroubleActionData = {
+ *   troubleType: 'InsufficientAgitationTrouble',
+ *   stateKey: 'agitationRequired',
+ *   stateValue: 'true'
+ * };
+ * ```
+ *
+ * @category Trouble Configuration
+ * @see {@link TroubleActionOptions} for how definitions are provided to the model
+ */
 export interface TroubleActionData {
+  /**
+   * The trouble type identifier to monitor.
+   *
+   * Must match the type property of trouble objects in the TroubleContainer.
+   * When a trouble of this type becomes active, the associated state entry
+   * will be created.
+   *
+   * @example "InsufficientAgitationTrouble"
+   * @example "CartridgeEmptyTrouble"
+   */
   troubleType: string;
+
+  /**
+   * The key to use in the state object for this trouble.
+   *
+   * Defines the property name in the TroubleActionModel's state object.
+   * UI components will observe this key to react to the trouble condition.
+   *
+   * @example "agitationRequired"
+   * @example "cartridgeStatus"
+   */
   stateKey: string;
+
+  /**
+   * The value to set in the state object when this trouble is active.
+   *
+   * When the trouble becomes active, this value is assigned to the stateKey.
+   * When the trouble is resolved, the stateKey is set to undefined.
+   *
+   * @example "true"
+   * @example "empty"
+   * @example "maintenance_required"
+   */
   stateValue: string;
 }
+
+/**
+ * Configuration options for the TroubleActionModel.
+ *
+ * Provides the trouble action definitions that configure how the model
+ * maps active troubles to state values. These definitions are processed
+ * during model initialization to establish the trouble monitoring behavior.
+ *
+ * @example
+ * ```typescript
+ * const options: TroubleActionOptions = {
+ *   definitions: [
+ *     {
+ *       troubleType: 'InsufficientAgitationTrouble',
+ *       stateKey: 'agitationRequired',
+ *       stateValue: 'true'
+ *     },
+ *     {
+ *       troubleType: 'CartridgeEmptyTrouble',
+ *       stateKey: 'cartridgeStatus',
+ *       stateValue: 'empty'
+ *     },
+ *     {
+ *       troubleType: 'MaintenanceRequiredTrouble',
+ *       stateKey: 'systemStatus',
+ *       stateValue: 'maintenance'
+ *     }
+ *   ]
+ * };
+ * ```
+ *
+ * @category Model Configuration
+ * @see {@link TroubleActionData} for individual definition structure
+ * @see {@link TroubleActionModel} for how options are used during initialization
+ */
 export interface TroubleActionOptions {
+  /**
+   * Array of trouble action definitions to monitor.
+   *
+   * Each definition maps a specific trouble type to a state representation.
+   * The model will monitor all defined trouble types and update its state
+   * object accordingly when troubles become active or are resolved.
+   *
+   * The order of definitions affects priority when accessing the activeTrouble
+   * getter - the first matching trouble in the array will be returned.
+   */
   definitions: TroubleActionData[];
 }

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@kosdev-code/kos-ddk-models",
-  "version": "0.1.0-dev.5171",
+  "version": "0.1.0-dev.5179",
   "dependencies": {
-    "@kosdev-code/kos-ui-sdk": "0.1.0-dev.5171",
-    "@kosdev-code/kos-dispense-sdk": "0.1.0-dev.5171",
-    "@kosdev-code/kos-freestyle-sdk": "0.1.0-dev.5171"
+    "@kosdev-code/kos-ui-sdk": "0.1.0-dev.5179",
+    "@kosdev-code/kos-dispense-sdk": "0.1.0-dev.5179",
+    "@kosdev-code/kos-freestyle-sdk": "0.1.0-dev.5179"
   },
   "main": "./index.js",
   "module": "./index.mjs",
   "typings": "./index.d.ts",
   "kos": {
     "build": {
-      "gitHash": "1d786a161cc932e527dcb745658df6d6a1c836e5"
+      "gitHash": "3cccaa001498c93157d1c1ba3d006f453b0c061a"
     }
   },
   "publishConfig": {

package/lib/trouble-action/trouble-action-registration.d.ts

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

package/lib/trouble-action/trouble-action-registration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trouble-action-registration.d.ts","sourceRoot":"","sources":["../../../../../../packages/ddk/kos-ddk-models/src/lib/trouble-action/trouble-action-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,aAAa,gFAMxB,CAAC"}