@elliemae/pui-scripting-object 1.15.0 → 1.16.1

package/dist/types/event.d.ts

@@ -5,8 +5,8 @@ import { IScriptingObjectProxy, IScriptingObject } from './scriptingObject.js';
 export declare type Listener<SO extends IScriptingObjectProxy, Params extends Record<string, unknown>, Options extends Record<string, unknown>, ReturnType> = ({ obj, eventName, eventParams, eventOptions, }: {
     obj: SO;
     eventName: string;
-    eventParams?: Params;
-    eventOptions?: Options;
+    eventParams: Params;
+    eventOptions: Options;
 }) => ReturnType;
 /**
  * base class for events
@@ -35,7 +35,7 @@ export interface IEvent {
     /**
      * subscribe to the event
      */
-    subscribe: (callback: Listener<IScriptingObject, Record<string, unknown>, Record<string, unknown>, unknown>) => string;
+    subscribe: (callback: Listener<IScriptingObject, Record<string, unknown>, Record<string, unknown>, any>) => string;
     /**
      * unsubscribe from the event
      */

package/dist/types/objects/application.d.ts

@@ -1,5 +1,8 @@
 import { IEvent, Listener } from '../event.js';
 import { IScriptingObject } from '../scriptingObject.js';
+/**
+ * Log levels
+ */
 export declare enum LogLevel {
     TRACE = "TRACE",
     DEBUG = "DEBUG",
@@ -9,18 +12,39 @@ export declare enum LogLevel {
     ERROR = "ERROR",
     FATAL = "FATAL"
 }
+/**
+ * metadata about the application
+ */
 export declare type AppInfo = {
     id: string;
     name: string;
 };
+/**
+ * Application extension type
+ */
 export declare enum ApplicationExtensionType {
     TOOL = "TOOL",
     MENU = "MENU"
 }
+/**
+ * metadata about the application extension
+ */
 export declare type ApplicationExtension = {
+    /**
+     * type of application extension
+     */
     type: ApplicationExtensionType;
+    /**
+     * display text of the application extension
+     */
     text: string;
+    /**
+     * url where the application extension is hosted
+     */
     url: string;
+    /**
+     * custom options for the application extension
+     */
     options?: Record<string, string>;
 };
 /**
@@ -38,9 +62,6 @@ export declare enum NavigationType {
  * navigation options
  */
 export declare type NavigationOptions = {
-    /**
-     *
-     */
     target: string;
     type: NavigationType;
     context?: Record<string, string>;
@@ -49,6 +70,9 @@ export declare type OpenOptions = {
     target: string;
     type?: string;
 };
+/**
+ * size of the modal
+ */
 export declare enum ModalSize {
     SMALL = "sm",
     MEDIUM = "md",
@@ -86,21 +110,75 @@ export declare type PrintOptions = {
      */
     blob: Blob;
 };
+declare type UserInfo = {
+    /**
+     * user id
+     */
+    userId: string;
+};
+declare type ActionInfo = {
+    /**
+     * name of the action
+     */
+    name: string;
+};
+/**
+ * event handler that handles user login event
+ */
+export declare type ApplicationLoginListener = Listener<IApplication, UserInfo, Record<string, unknown>, void>;
 /**
  * event fired when the user logs in
  */
-export interface ApplicationLoginEvent extends IEvent {
+export interface IApplicationLoginEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Login';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Application';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: UserInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: ApplicationLoginListener) => string;
 }
+/**
+ * event handler that handles action completed event
+ */
+export declare type ApplicationActionCompletedListener = Listener<IApplication, ActionInfo, Record<string, unknown>, void>;
 /**
  * event fired when an action is completed. actions are executed through the performAction method
  */
-export interface ApplicationActionCompletedEvent extends IEvent {
+export interface IApplicationActionCompletedEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'ActionCompleted';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Application';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: ActionInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: ApplicationActionCompletedListener) => string;
 }
 /**
  * Allows access to application-level UI elements, behaviors and events
@@ -109,11 +187,11 @@ export interface IApplication extends IScriptingObject {
     /**
      * notifies user login
      */
-    readonly Login: ApplicationLoginEvent;
+    readonly Login: IApplicationLoginEvent;
     /**
      * notifies action completion
      */
-    readonly ActionCompleted: ApplicationActionCompletedEvent;
+    readonly ActionCompleted: IApplicationActionCompletedEvent;
     /**
      * Gets descriptor for the Application
      *
@@ -216,19 +294,4 @@ export interface IApplication extends IScriptingObject {
      */
     log(message: string, logLevel: LogLevel): Promise<void>;
 }
-/**
- * event handler that handles user login event
- *
- * @param userId unique identifier of the user
- */
-export declare type ApplicationLoginListener = Listener<IApplication, {
-    userId: string;
-}, Record<string, unknown>, void>;
-/**
- * event handler that handles action completed event
- *
- * @param name action name
- */
-export declare type ApplicationActionCompletedListener = Listener<IApplication, {
-    name: string;
-}, Record<string, unknown>, void>;
+export {};

package/dist/types/objects/form.d.ts

@@ -4,21 +4,69 @@ export declare type FormDescriptor = {
     id: string;
     name: string;
 };
+declare type FormInfo = {
+    /**
+     * unique id of the form
+     */
+    id: string;
+};
+/**
+ * event handler for form load event
+ */
+export declare type FormLoadListener = Listener<IForm, FormInfo, Record<string, unknown>, void>;
+/**
+ * event handler for form unload event
+ */
+export declare type FormUnLoadListener = Listener<IForm, FormInfo, Record<string, unknown>, void>;
 /**
  * event to notify form load operation
  */
-export interface FormLoadEvent extends IEvent {
+export interface IFormLoadEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Load';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Form';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: FormInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: FormLoadListener) => string;
 }
 /**
  * event to notify form unload operation
  */
-export interface FormUnLoadEvent extends IEvent {
+export interface IFormUnLoadEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'UnLoad';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Form';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: FormInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: FormUnLoadListener) => string;
 }
 /**
  * Methods to get information about the custom form
@@ -27,11 +75,11 @@ export interface IForm extends IScriptingObject {
     /**
      * event fired when the form is loaded
      */
-    readonly Load: FormLoadEvent;
+    readonly Load: IFormLoadEvent;
     /**
      * event fired when the form is unloaded
      */
-    readonly UnLoad: FormUnLoadEvent;
+    readonly UnLoad: IFormUnLoadEvent;
     /**
      * get metadata of the form
      *
@@ -46,19 +94,4 @@ export interface IForm extends IScriptingObject {
      */
     getControl(id: string): Promise<unknown>;
 }
-/**
- * event handler for form load event
- *
- * @param id unique id of the form that is loaded
- */
-export declare type FormLoadListener = Listener<IForm, {
-    id: string;
-}, Record<string, unknown>, void>;
-/**
- * event handler for form unload event
- *
- * @param id unique id of the form that is unloaded
- */
-export declare type FormUnLoadListener = Listener<IForm, {
-    id: string;
-}, Record<string, unknown>, void>;
+export {};

package/dist/types/objects/global.d.ts

@@ -1,12 +1,39 @@
 import { IEvent, Listener } from '../event.js';
 import { IScriptingObject } from '../scriptingObject.js';
+declare type StateInfo = {
+    /**
+     * name of the key for which the value changed
+     */
+    key: string;
+};
+/**
+ * event handler for global state change event
+ */
+export declare type GlobalChangeListener = Listener<IGlobal, StateInfo, Record<string, unknown>, void>;
 /**
  * event to notify change in global state
  */
-export interface GlobalChangeEvent extends IEvent {
+export interface IGlobalChangeEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Change';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Global';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: StateInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: GlobalChangeListener) => string;
 }
 /**
  * The Global object allows for data to be shared between custom forms/tools/plugins within a user's session.
@@ -28,7 +55,7 @@ export interface IGlobal extends IScriptingObject {
     /**
      * event fired when the global state changes
      */
-    readonly Change: GlobalChangeEvent;
+    readonly Change: IGlobalChangeEvent;
     /**
      * set a value in the global store
      *
@@ -44,11 +71,4 @@ export interface IGlobal extends IScriptingObject {
      */
     get(key: string): Promise<unknown>;
 }
-/**
- * event handler for global state change event
- *
- * @param key name of the key for which the value changed
- */
-export declare type GlobalChangeListener = Listener<IGlobal, {
-    key: string;
-}, Record<string, unknown>, void>;
+export {};

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

@@ -23,77 +23,285 @@ export declare enum LoanLevelActions {
     COPY_ITEMIZATION_TO_STATE_DISCLOSURE = "copyItemizationToStateDisclosure",
     CALCULATE_EEM_MORTGAGE = "calculateEEMMortgage"
 }
+declare type CommitInfo = {
+    /**
+     * cause of commit event
+     */
+    cause: string;
+};
+/**
+ * event handler for loan precommit event
+ *
+ * @returns true if precommit is allowed, false otherwise
+ */
+export declare type LoanPreCommitListener = Listener<ILoan, CommitInfo, Record<string, unknown>, boolean>;
 /**
  * event to notify loan precommit operation
  */
-export interface LoanPreCommitEvent extends IEvent {
+export interface ILoanPreCommitEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'PreCommit';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event requires feedback from listeners
+     */
     readonly requiresFeedback: true;
+    /**
+     * event parameters
+     */
+    readonly params: CommitInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanPreCommitListener) => string;
 }
+/**
+ * event handler for loan commited event
+ *
+ */
+export declare type LoanCommittedListener = Listener<ILoan, CommitInfo, Record<string, unknown>, void>;
 /**
  * event to notify loan committed operation
  */
-export interface LoanCommittedEvent extends IEvent {
+export interface ILoanCommittedEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Committed';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: CommitInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanCommittedListener) => string;
 }
+/**
+ * event handler for loan data change event
+ */
+export declare type LoanChangeListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
 /**
  * event to notify loan change operation
  */
-export interface LoanChangeEvent extends IEvent {
+export interface ILoanChangeEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Chanage';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: Record<string, never>;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanChangeListener) => string;
 }
+/**
+ * event handler for loan sync event
+ */
+export declare type LoanSyncListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
 /**
  * event to notify loan sync operation
  */
-export interface LoanSyncEvent extends IEvent {
+export interface ILoanSyncEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Sync';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: Record<string, never>;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanSyncListener) => string;
 }
+/**
+ * event handler for loan open event
+ */
+export declare type LoanOpenListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
 /**
  * event to notify loan open operation
  */
-export interface LoanOpenEvent extends IEvent {
+export interface ILoanOpenEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Open';
+    /**
+     *  scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: Record<string, never>;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanOpenListener) => string;
 }
+/**
+ * event handler for loan close event
+ *
+ * @returns true if loan close is allowed, false otherwise
+ */
+export declare type LoanCloseListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
 /**
  * event to notify loan close operation
  */
-export interface LoanCloseEvent extends IEvent {
+export interface ILoanCloseEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Close';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: Record<string, never>;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanCloseListener) => string;
 }
+declare type MilestoneInfo = {
+    /**
+     * milestone name
+     */
+    name: string;
+};
+/**
+ * event handler for loan milestone completed event
+ */
+export declare type LoanMilestoneCompletedListener = Listener<ILoan, MilestoneInfo, Record<string, unknown>, void>;
 /**
  * event to notify loan milestone completed operation
  */
-export interface LoanMilestoneCompletedEvent extends IEvent {
+export interface ILoanMilestoneCompletedEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'MilestoneCompleted';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: MilestoneInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanMilestoneCompletedListener) => string;
 }
+/**
+ * event handler for loan pre milestone complete event
+ *
+ * @returns true if milestone complete is allowed, false otherwise
+ */
+export declare type LoanPreMilestoneCompleteListener = Listener<ILoan, MilestoneInfo, Record<string, unknown>, boolean>;
 /**
  * event to notify loan pre milestone complete operation
  */
-export interface LoanPreMilestoneCompleteEvent extends IEvent {
+export interface ILoanPreMilestoneCompleteEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'PreMilestoneComplete';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event requires feedback from listeners
+     */
     readonly requiresFeedback: true;
+    /**
+     * event parameters
+     */
+    readonly params: MilestoneInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanPreMilestoneCompleteListener) => string;
 }
+/**
+ * event handler for loan application selected event
+ */
+export declare type LoanApplicationSelectedListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
 /**
  * event to notify loan application selected operation
  */
-export interface LoanApplicationSelectedEvent extends IEvent {
+export interface ILoanApplicationSelectedEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'ApplicationSelected';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'Loan';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: Record<string, never>;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: LoanApplicationSelectedListener) => string;
 }
 /**
  * Methods for interacting with an open loan in the application
@@ -102,39 +310,39 @@ export interface ILoan extends IScriptingObject {
     /**
      * event fired when the loan is ready to commit
      */
-    readonly PreCommit: LoanPreCommitEvent;
+    readonly PreCommit: ILoanPreCommitEvent;
     /**
      * event fired when the loan is committed
      */
-    readonly Committed: LoanCommittedEvent;
+    readonly Committed: ILoanCommittedEvent;
     /**
      * event fired when the loan is changed
      */
-    readonly Change: LoanChangeEvent;
+    readonly Change: ILoanChangeEvent;
     /**
      * event fired when the loan is synced
      */
-    readonly Sync: LoanSyncEvent;
+    readonly Sync: ILoanSyncEvent;
     /**
      * event fired when the loan is opened
      */
-    readonly Open: LoanOpenEvent;
+    readonly Open: ILoanOpenEvent;
     /**
      * event fired when the loan is closed
      */
-    readonly Close: LoanCloseEvent;
+    readonly Close: ILoanCloseEvent;
     /**
      * event fired when the loan milestone is completed
      */
-    readonly MilestoneCompleted: LoanMilestoneCompletedEvent;
+    readonly MilestoneCompleted: ILoanMilestoneCompletedEvent;
     /**
      * event fired when the loan is ready to complete milestone
      */
-    readonly PreMilestoneComplete: LoanPreMilestoneCompleteEvent;
+    readonly PreMilestoneComplete: ILoanPreMilestoneCompleteEvent;
     /**
      * event fired when the loan application is selected
      */
-    readonly ApplicationSelected: LoanApplicationSelectedEvent;
+    readonly ApplicationSelected: ILoanApplicationSelectedEvent;
     /**
      * Get complete Loan object
      *
@@ -253,58 +461,4 @@ export interface ILoan extends IScriptingObject {
     getCollection(name: string): Promise<Record<string, string>>;
     getLockSnapshot(): Promise<Record<string, string>>;
 }
-/**
- * event handler for loan precommit event
- *
- * @param cause cause of precommit event
- * @returns true if precommit is allowed, false otherwise
- */
-export declare type LoanPreCommitListener = Listener<ILoan, {
-    cause: string;
-}, Record<string, unknown>, boolean>;
-/**
- * event handler for loan commited event
- *
- * @param cause cause of commit event
- */
-export declare type LoanCommittedListener = Listener<ILoan, {
-    cause: string;
-}, Record<string, unknown>, void>;
-/**
- * event handler for loan data change event
- */
-export declare type LoanChangeListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
-/**
- * event handler for loan sync event
- */
-export declare type LoanSyncListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
-/**
- * event handler for loan open event
- */
-export declare type LoanOpenListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
-/**
- * event handler for loan close event
- *
- * @returns true if loan close is allowed, false otherwise
- */
-export declare type LoanCloseListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
-/**
- * event handler for loan milestone completed event
- *
- * @param name milestone name
- */
-export declare type LoanMilestoneCompletedListener = Listener<ILoan, {
-    name: string;
-}, Record<string, unknown>, void>;
-/**
- * event handler for loan pre milestone complete event
- *
- * @returns true if milestone complete is allowed, false otherwise
- */
-export declare type LoanPreMilestoneCompleteListener = Listener<ILoan, {
-    name: string;
-}, Record<string, unknown>, boolean>;
-/**
- * event handler for loan application selected event
- */
-export declare type LoanApplicationSelectedListener = Listener<ILoan, Record<string, never>, Record<string, unknown>, void>;
+export {};

package/dist/types/objects/module.d.ts

@@ -1,12 +1,36 @@
 import { IEvent, Listener } from '../event.js';
 import { IScriptingObject } from '../scriptingObject.js';
+/**
+ * event handler that handles module unload event
+ *
+ * @param id unique id of the app that is being unloaded
+ * @returns true if the module can be unloaded, false otherwise
+ */
+export declare type ModuleUnLoadingListener = Listener<IModule, Record<string, never>, Record<string, unknown>, boolean>;
 /**
  * Module unloading event
  */
-export interface ModuleUnloadingEvent extends IEvent {
+export interface IModuleUnloadingEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Unloading';
+    /**
+     * scripting object from where the event was triggered
+     */
     readonly objectId: 'Module';
+    /**
+     * response needed from event listeners
+     */
     readonly requiresFeedback: true;
+    /**
+     * event parameters
+     */
+    readonly params: Record<string, never>;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: ModuleUnLoadingListener) => string;
 }
 /**
  * Exposes MicroApp module specific methods
@@ -19,7 +43,7 @@ export interface IModule extends IScriptingObject {
      *
      * @returns true if the module can be unloaded, false otherwise
      */
-    readonly Unloading: ModuleUnloadingEvent;
+    readonly Unloading: IModuleUnloadingEvent;
     /**
      * get microapp module-specific capabilities or settings defined by the host application. Helps to define the style and/or behavior of the module
      *
@@ -39,10 +63,3 @@ export interface IModule extends IScriptingObject {
      */
     unload(): Promise<void>;
 }
-/**
- * event handler that handles module unload event
- *
- * @param id unique id of the app that is being unloaded
- * @returns true if the module can be unloaded, false otherwise
- */
-export declare type ModuleUnLoadingListener = Listener<IModule, Record<string, never>, Record<string, unknown>, boolean>;

package/dist/types/objects/view.d.ts

@@ -8,21 +8,75 @@ export declare type ViewportSize = {
     width: number;
     height: number;
 };
+declare type ViewportSizeInfo = {
+    /**
+     * details about the resize event
+     */
+    entires: ResizeObserverEntry;
+};
+/**
+ * parent window resize event handler
+ */
+export declare type ViewResizeListener = Listener<IView, ViewportSizeInfo, Record<string, unknown>, void>;
 /**
  * event to notify window viewport resize operation
  */
-export interface ViewResizeEvent extends IEvent {
+export interface IViewResizeEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'Resize';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'View';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: ViewportSizeInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: ViewResizeListener) => string;
 }
+declare type BreakpointInfo = {
+    /**
+     * current breakpoint of the parent window
+     */
+    breakpoint: BreakPoint;
+};
+/**
+ * parent window breakpoint change event handler
+ */
+export declare type BreakpointChangeListener = Listener<IView, BreakpointInfo, Record<string, unknown>, void>;
 /**
  * event to notify window viewport breakpoint change
  */
-export interface ViewBreakpointChangeEvent extends IEvent {
+export interface IViewBreakpointChangeEvent extends IEvent {
+    /**
+     * event name
+     */
     readonly name: 'BreakpointChange';
+    /**
+     * scripting object from where the event is fired
+     */
     readonly objectId: 'View';
+    /**
+     * event does not require feedback from listeners
+     */
     readonly requiresFeedback: false;
+    /**
+     * event parameters
+     */
+    readonly params: BreakpointInfo;
+    /**
+     * subscribe to the event
+     */
+    subscribe: (callback: BreakpointChangeListener) => string;
 }
 /**
  * Methods view, modify parent's window attributes
@@ -31,11 +85,11 @@ export interface IView extends IScriptingObject {
     /**
      * event fired when the window is resized
      */
-    readonly Resize: ViewResizeEvent;
+    readonly Resize: IViewResizeEvent;
     /**
      * event fired when the window breakpoint changes
      */
-    readonly BreakpointChange: ViewBreakpointChangeEvent;
+    readonly BreakpointChange: IViewBreakpointChangeEvent;
     /**
      * Get the current breakpoint of the parent window
      */
@@ -45,19 +99,4 @@ export interface IView extends IScriptingObject {
      */
     getViewPortSize(): Promise<ViewportSize>;
 }
-/**
- * parent window resize event handler
- *
- * @param entries details about the resize event
- */
-export declare type ResizeEventListener = Listener<IView, {
-    entires: ResizeObserverEntry;
-}, Record<string, unknown>, void>;
-/**
- * parent window breakpoint change event handler
- *
- * @param breakpoint current breakpoint of the parent window
- */
-export declare type BreakpointChangeEventListener = Listener<IView, {
-    breakpoint: BreakPoint;
-}, Record<string, unknown>, void>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/pui-scripting-object",
-  "version": "1.15.0",
+  "version": "1.16.1",
   "description": "Typescript defintions for Scripting Objects",
   "sideEffects": false,
   "main": "./dist/cjs/index.js",