@elliemae/pui-scripting-object 1.51.3 → 1.55.0

package/dist/types/lib/objects/loan.d.ts

@@ -251,6 +251,21 @@ export type LoanChangeListener = (params: {
     eventParams: LoanChangeEventInfo;
     eventOptions?: Record<string, unknown>;
 }) => void;
+/**
+ * Event handler for synchronous loan field change event
+ * @param params event parameters
+ * @param params.obj loan object reference
+ * @param params.eventName event name
+ * @param params.eventParams loan field change info
+ * @param params.eventOptions additional options related to the event
+ * @returns true to continue the field change, false to cancel it
+ */
+export type LoanFieldChangeSyncListener = (params: {
+    obj: ILoan;
+    eventName: string;
+    eventParams: LoanChangeEventInfo;
+    eventOptions?: Record<string, unknown>;
+}) => boolean;
 /**
  * Event handler for loan sync event
  * @param params event parameters
@@ -503,7 +518,33 @@ export type EditModeOptions = {
     moduleId: string;
 };
 /**
- * Events supported by Loan scripting object
+ * Event types available for loan-related operations.
+ *
+ * This type defines all the events that can be emitted during a loan's lifecycle,
+ * from opening and editing to committing and closing. Each event type maps to its
+ * corresponding listener type that handles the event.
+ * @remarks
+ * Events are fired at different stages of loan processing:
+ * - Application selection and opening (`loan.applicationselected`, `loan.open`)
+ * - User interactions and changes (`loan.change`, `loan.fieldChangeSync`, `loan.editModeChange`)
+ * - Pre-commit validation (`loan.precommit`)
+ * - Committing changes (`loan.committed`)
+ * - Milestone operations (`loan.premilestonecomplete`, `loan.milestoneCompleted`)
+ * - Synchronization (`loan.sync`)
+ * - Closing (`loan.close`)
+ * ```
+ *
+ * @see {@link LoanApplicationSelectedListener}
+ * @see {@link LoanChangeListener}
+ * @see {@link LoanCommittedListener}
+ * @see {@link LoanCloseListener}
+ * @see {@link LoanEditModeChangeListener}
+ * @see {@link LoanFieldChangeSyncListener}
+ * @see {@link LoanMilestoneCompletedListener}
+ * @see {@link LoanOpenListener}
+ * @see {@link LoanPreCommitListener}
+ * @see {@link LoanPreMilestoneCompleteListener}
+ * @see {@link LoanSyncListener}
  */
 export type LoanEvents = {
     /**
@@ -541,6 +582,13 @@ export type LoanEvents = {
      *
      */
     'loan.editModeChange': LoanEditModeChangeListener;
+    /**
+     * Event is fired when a loan field is changed
+     *
+     * Use {@link LoanFieldChangeSyncListener} to handle this event
+     *
+     */
+    'loan.fieldChangeSync': LoanFieldChangeSyncListener;
     /**
      * Event is fired after a milestone is completed by the user and committed to the server
      *
@@ -704,6 +752,35 @@ export interface ILoan extends IScriptingObject {
      * ```
      */
     readonly EditModeChange: IEvent;
+    /**
+     * event fired when a loan field is changed
+     * return true to further process the field change, false to cancel the field change
+     *
+     * Use {@link LoanFieldChangeSyncListener} to handle this event
+     * @example
+     * with v2 SSF
+     * ```ts
+     * guest.subscribe({
+     *  eventId: 'loan.fieldChangeSync',
+     *  callback: ({ eventParams }) => {
+     *    console.log('Loan field changed', eventParams);
+     *    return true;
+     *  });
+     *  criteria: {
+     *   fieldId: { eq: 4000 }
+     *  }
+     * });
+     * ```
+     * @example
+     * with v1 SSF
+     * ```ts
+     * elli.script.subscribe('loan', 'fieldChangeSync', ({ eventParams }) => {
+     *  console.log('Loan field changed', eventParams);
+     *  return true;
+     * });
+     * ```
+     */
+    readonly FieldChangeSync: IEvent;
     /**
      * event fired when the loan milestone is completed
      *

package/dist/types/lib/objects/memStorage.d.ts

@@ -1,24 +1,26 @@
 import { IScriptingObject } from '../scriptingObject.js';
 /**
- * get or set values in host application javascript memory
- * values stored in memory are not persisted across sessions
- *
- * Host application implemeting this scripting object ensures,
- * there are no collisions with keys from other microapp guest applications
- * that means, two microapps can use same key to store different values. Thier values will not collide.
+ * Get or set values in host application javascript memory.
+ * Values stored in memory are not persisted across sessions.
  *
+ * Host application implementing this scripting object ensures
+ * there are no collisions with keys from other microapp guest applications.
+ * This means two microapps can use the same key to store different values, and their values will not collide.
  */
 export interface IMemStorage extends IScriptingObject {
     /**
-     * get a value from memory for given key and microapp id
-     * @param key unique key to retrieve the value
-     * @returns value stored in memory
+     * Get a value from memory for the given key and microapp id
+     * @param key Unique key to retrieve the value
+     * @param isGlobal Optional flag to indicate if the value should be retrieved from global storage across all microapps. Defaults to false
+     * @returns Promise resolving to the value stored in memory, or undefined if key doesn't exist
      */
-    get(key: string): Promise<unknown>;
+    get(key: string, isGlobal?: boolean): Promise<unknown>;
     /**
-     * set a value in memory for given key
-     * @param key unique key to store the value
-     * @param value value to be stored. value should be JSON serializable
+     * Set a value in memory for the given key
+     * @param key Unique key to store the value
+     * @param value Value to be stored. Value should be JSON serializable
+     * @param isGlobal Optional flag to indicate if the value should be stored in global storage accessible across all microapps. Defaults to false
+     * @returns Promise that resolves when the value has been stored
      */
-    set(key: string, value: unknown): Promise<void>;
+    set(key: string, value: unknown, isGlobal?: boolean): Promise<void>;
 }

package/dist/types/lib/objects/service.d.ts

@@ -31,6 +31,20 @@ export type ServiceSetup = {
      */
     category: ServiceSetupCategory;
 };
+export type FilterOperator = {
+    eq: any;
+} | {
+    in: any[];
+} | {
+    includes: any;
+} | {
+    gt: number;
+} | {
+    lt: number;
+} | {
+    regex: string;
+};
+export type FilterOption = Record<string, FilterOperator>;
 /**
  * options to launch service order integration by category
  */
@@ -80,6 +94,10 @@ export type LaunchCategoryOptions = {
      * flag to exclude EVP providers from the service orders
      */
     excludeEVPProviders?: boolean;
+    /**
+     * filter criteria to narrow down available service options
+     */
+    criteria?: FilterOption;
 };
 /**
  * options to launch service order integration by specific service setup

package/dist/types/lib/objects/styling.d.ts

@@ -0,0 +1,174 @@
+import { IScriptingObject } from '../scriptingObject.js';
+/**
+ * Condition operators for style criteria matching
+ */
+export type ConditionOperator = {
+    /** Equals operator - value must equal this value */
+    eq: unknown;
+} | {
+    /** In operator - value must be in this array */
+    in: unknown[];
+} | {
+    /** Includes operator - array value must include this item */
+    includes: unknown;
+} | {
+    /** Greater than operator - numeric value must be greater than this */
+    gt: number;
+} | {
+    /** Less than operator - numeric value must be less than this */
+    lt: number;
+} | {
+    /** Regex operator - value must match this regular expression */
+    regex: string;
+};
+/**
+ * Criteria for conditional styling of table rows
+ * Maps table column name/key to condition operators that determine when styles should be applied
+ * @example
+ * ```typescript
+ * const criteria: TableRowCriteria = {
+ *   status: { eq: 'active' },
+ *   amount: { gt: 1000 },
+ *   type: { in: ['urgent', 'critical'] },
+ *   description: { regex: '^Important.*' }
+ * };
+ * ```
+ */
+export type TableRowCriteria = Record<string, ConditionOperator>;
+/**
+ * CSS style properties that can be applied to fields and table rows
+ * All color values should be valid CSS color strings (hex, rgb, named colors, etc.)
+ */
+export type StyleOptions = {
+    /** Text color (CSS color value) */
+    color?: string;
+    /** Border color (CSS color value) */
+    borderColor?: string;
+    /** Background color (CSS color value) */
+    backgroundColor?: string;
+};
+/**
+ * Style configuration for table rows with conditional criteria
+ * Styles are applied to rows that match all specified criteria
+ */
+export type TableRowStyleOptions = {
+    /**
+     * Criteria to match for applying styles
+     * Each key corresponds to a column in the table
+     * and the value is a condition operator that must match
+     * For example: `{ status: { eq: 'active' } }`
+     */
+    criteria: TableRowCriteria;
+    /** Style properties to apply when criteria match */
+    styles: StyleOptions;
+};
+/**
+ * Interface for managing dynamic styling of fields and table rows
+ * Allows conditional styling based on field values and criteria
+ */
+export interface IStyling extends IScriptingObject {
+    /**
+     * Get style configurations for all fields that have custom styles applied
+     * @returns Promise resolving to array of field styles with their IDs, or undefined if no fields have custom styles
+     * @example
+     * ```typescript
+     * const allStyles = await styling.getAllFieldStyles();
+     * if (allStyles) {
+     *   allStyles.forEach(style => {
+     *     console.log(`Field ${style.fieldId} has color ${style.color}`);
+     *   });
+     * }
+     * ```
+     */
+    getAllFieldStyles(): Promise<Array<StyleOptions & {
+        fieldId: string;
+    }> | undefined>;
+    /**
+     * Get style configurations for all tables that have row-level conditional styling
+     * @returns Promise resolving to array of table row styles with their table IDs, or undefined if no tables have custom row styles
+     * @example
+     * ```typescript
+     * const allRowStyles = await styling.getAllTableRowStyles();
+     * if (allRowStyles) {
+     *   allRowStyles.forEach(rowStyle => {
+     *     console.log(`Table ${rowStyle.tableId} has ${Object.keys(rowStyle.criteria).length} criteria`);
+     *   });
+     * }
+     * ```
+     */
+    getAllTableRowStyles(): Promise<Array<TableRowStyleOptions & {
+        tableId: string;
+    }> | undefined>;
+    /**
+     * Get style configuration for a specific field
+     * @param fieldId Field identifier to retrieve styles for
+     * @returns Promise resolving to field style configuration or undefined if not found
+     * @example
+     * ```typescript
+     * const style = await styling.getFieldStyle('field1');
+     * if (style) {
+     *   console.log('Field color:', style.color);
+     * }
+     * ```
+     */
+    getFieldStyle(fieldId: string): Promise<StyleOptions | undefined>;
+    /**
+     * Get conditional row style configuration for a specific table
+     * @param tableId Unique identifier for the table (case-sensitive, URN format recommended)
+     * @returns Promise resolving to table row style configuration with criteria and styles, or undefined if no custom row styles are configured for this table
+     * @example
+     * ```typescript
+     * const rowStyle = await styling.getTableRowStyle('urn:loan:pipeline');
+     * if (rowStyle) {
+     *   console.log('Row criteria:', rowStyle.criteria);
+     *   console.log('Styles to apply:', rowStyle.styles);
+     * }
+     * ```
+     */
+    getTableRowStyle(tableId: string): Promise<TableRowStyleOptions | undefined>;
+    /**
+     * Set or update style configuration for a specific field
+     * @param fieldId Unique identifier for the field to style
+     * @param options Style properties to apply (color, borderColor, backgroundColor)
+     * @returns Promise that resolves when styles have been successfully applied
+     * @example
+     * ```typescript
+     * // Apply multiple style properties to a field
+     * await styling.setFieldStyle('loanAmount', {
+     *   color: 'red',
+     *   backgroundColor: '#ffe0e0',
+     *   borderColor: '#ff0000'
+     * });
+     * ```
+     */
+    setFieldStyle(fieldId: string, options: StyleOptions): Promise<void>;
+    /**
+     * Set or update conditional styling rules for table rows
+     * Multiple style rules can be defined, each with different criteria. Rows matching any rule's criteria will have those styles applied
+     * @param tableId Unique identifier for the table (case-sensitive, URN format recommended, e.g., 'urn:loan:pipeline')
+     * @param options Array of style configurations, each with criteria that determine when to apply the styles
+     * @returns Promise that resolves when style rules have been successfully configured
+     * @example
+     * ```typescript
+     * // Apply different styles based on multiple conditions
+     * await styling.setTableRowStyle('urn:loan:pipeline', [
+     *   {
+     *     // Highlight high-value loans in red
+     *     criteria: { amount: { gt: 1000000 } },
+     *     styles: { color: 'red', backgroundColor: '#ffe0e0' }
+     *   },
+     *   {
+     *     // Highlight urgent items with red border
+     *     criteria: { priority: { in: ['urgent', 'critical'] } },
+     *     styles: { borderColor: 'red' }
+     *   },
+     *   {
+     *     // Highlight active items with green background
+     *     criteria: { status: { eq: 'active' } },
+     *     styles: { backgroundColor: '#e0ffe0' }
+     *   }
+     * ]);
+     * ```
+     */
+    setTableRowStyle(tableId: string, options: Array<TableRowStyleOptions>): Promise<void>;
+}

package/dist/types/lib/scriptingObjectList.d.ts

@@ -11,6 +11,7 @@ import { IAnalytics } from './objects/analytics.js';
 import { IMemStorage } from './objects/memStorage.js';
 import { IModule } from './objects/module.js';
 import { IService } from './objects/service.js';
+import { IStyling } from './objects/styling.js';
 /**
  * list of scripting object names and their types
  */
@@ -26,6 +27,7 @@ export type ScriptingObjectTypes = {
     module: IModule;
     service: IService;
     session: ISession;
+    styling: IStyling;
     transaction: ITransaction;
     transactiontemplate: ITransactionTemplate;
 };
@@ -42,6 +44,7 @@ export declare const enum ScriptingObjectNames {
     Module = "module",
     Service = "service",
     Session = "session",
+    Styling = "styling",
     Transaction = "transaction",
     TransactionTemplate = "transactiontemplate"
 }