@elliemae/pui-scripting-object 1.8.0 → 1.10.0

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

@@ -0,0 +1,295 @@
+/**
+ * user type context
+ */
+export declare enum OriginContext {
+    /**
+     * user interface is being presented to a user in a lending enterprise
+     */
+    LENDER = "lender",
+    /**
+     * user interface is being presented to a consumer/borrower
+     */
+    CONSUMER = "consumer"
+}
+/**
+ * transaction origination context
+ */
+export declare type OriginInfo = {
+    /**
+     * Temporary session token that grants authorization for a partner
+     * integration to access transaction origination information via the REST API's /partner/v2/origins/:id endpoint
+     */
+    partnerAccessToken: string;
+    /**
+     * Unique identifier for the transaction origination information snapshot accessible
+     * via the REST API's /partner/v2/origins/:id endpoint
+     */
+    id: string;
+    /**
+     * Unique identifier for the transaction in whose context the
+     * partner integrations user-interface is being launched.
+     * This is only available in the situation where your integration
+     * is being launched in the context of an existing transaction,
+     * and can be used to decide the appropriate view to display to users
+     */
+    transactionId?: string;
+    /**
+     * The user type in whose context your integration is being launched
+     */
+    context: OriginContext;
+};
+/**
+ * details about the transaction that is created / updated
+ */
+export declare type TransactionInfo = {
+    /**
+     * unique identifier for the transaction
+     */
+    id: string | null;
+};
+/**
+ * file attachment information
+ */
+export declare type TransactionResource = {
+    /**
+     * unique identifier for the file attachment
+     */
+    id: string;
+    /**
+     * name of the file attachment
+     */
+    name: string;
+    /**
+     * mime type of the file attachment
+     */
+    mimeType: string;
+};
+/**
+ * information about the transaction to be initiated
+ */
+export declare type TransactionOptions = {
+    request: {
+        /**
+         * The type of transaction request being initiated for the subject product.
+         * This must be one of the supported values for the request type that your application
+         * is configured to support - based on which its data entitlements are scoped.
+         */
+        type: string;
+        /**
+         * The specific set of selectable options that apply to the specific
+         * type of transaction request, as modeled by your application
+         */
+        options?: Record<string, string | boolean | number>;
+        /**
+         * The collection of file attachments - referred to as resource objects in the
+         * EPC API - to be attached to the transaction request.
+         * The id, name, and mimeType attribute needed for each resource object
+         * in the collection can be created in one of two ways:
+         *  Your application utilized the transaction.createResource method to build a custom file upload experience, and the user invoked this functionality and uploaded a file from their local drive.
+         *  Your application utilized the application.performAction("getAvailableResources") method to launch the host application's file explorer, and the user invoked this functionality and attached a file[s] from the host application.
+         * Once the resource objects are collected from these methods,
+         * be sure to echo them back to the EPC platform when creating a transaction!
+         */
+        resources: Array<TransactionResource>;
+    };
+};
+/**
+ * resource name to be uploaded
+ */
+export declare type TransactionResourceFile = {
+    /**
+     * name of the file
+     */
+    name: string;
+};
+/**
+ * response object of createResource method
+ */
+export declare type TransactionResourceResponse = {
+    /**
+     * resource id
+     */
+    id: string;
+    /**
+     * urn of the target upload location
+     */
+    respository: string;
+    /**
+     * name of the resource
+     */
+    name: string;
+    /**
+     * url to stream the resource
+     */
+    location: string;
+    /**
+     * authorization header to upload the resource
+     */
+    authorizationHeader: string;
+};
+export declare type TransactionEvent = {
+    /**
+     * event name
+     */
+    text: string;
+    /**
+     * urn representing the event type
+     */
+    type: string;
+    /**
+     * comments related to event
+     */
+    comments: string;
+    /**
+     * list of file attachments related to event
+     */
+    resources: Array<TransactionResource>;
+};
+/**
+ * Provides your applications lender/borrower-facing view with the necessary handles to model your application's
+ * transactional interaction with the EPC platform.
+ * Allows access to an interactive session's origination context,
+ * create a new transaction,
+ * update an existing transaction,
+ * create events/messages for a transaction, and more.
+ */
+export interface ITransaction {
+    /**
+     * Provide the necessary information for your application's user-interface to:
+     *  Access transaction origination information and bootstrap its user interaction
+     *  Know if it was launched in the context of an existing transaction, so it can present the relevant view
+     *
+     * @returns transaction origination information
+     */
+    getOrigin(): Promise<OriginInfo>;
+    /**
+     * Refresh your application's transaction origination context - if your current one expires.
+     * This method returns a new originId and partnerAccessToken - which your application back-end can use to retrieve a refreshed transaction origin:
+     *  A fresh snapshot of the loan data your application is entitled to receive in a transaction origin
+     *  A a fresh snapshot of the user's credential set configured by their Administrator for use with your application
+     *
+     * @returns transaction origination information
+     */
+    refreshOrigin(): Promise<OriginInfo>;
+    /**
+     * Allow Lenders to use your integration to upload files from their
+     * local drive as an attachment to a new transaction.
+     * This method returns a URL and authorization token,
+     * which are to be used to stream the selected file as binary content to the EPC platform
+     *
+     * @param options details of the resource to be uploaded
+     * @returns location and authorization header to upload the resource
+     */
+    createResource(options: TransactionResourceFile): Promise<TransactionResourceResponse>;
+    /**
+     * initiate a new transaction with your integration
+     *
+     * @param options details of the transaction to be initiated
+     * @returns transaction id
+     */
+    create(options: TransactionOptions): Promise<TransactionInfo>;
+    /**
+     * Set the transaction in whose context you want to invoke methods that operate on an existing transaction.
+     * The subject transaction must be one that was created for the current loan and EPC product.
+     * The methods that currently fall into this category are:
+     * transaction.update
+     * transaction.createEvent
+     *
+     * Although integrations are free to set the transactional context they are operating in,
+     * which may be necessary when providing views that allow users to switch between
+     * and perform actions on multiple transactions, the host application implicitly
+     * alters the transactional context in certain scenarios:
+     *
+     * Implicit transaction context setting!
+     * If your integration is launched by a user in the context of an existing transaction,
+     * such as from the services page on Loan Officer Connect, the document icon
+     * on the services side-nav in Encompass Desktop or when returning to a
+     * loan application in Consumer Connect, the transactional context is implicitly set to said transaction
+     * Every time a new transaction is created during a user's interaction with your integration,
+     * the context is set to the last created transaction
+     * If the integration was initially launched in the context of an existing transaction,
+     * transaction.getOrigin will always return the original transactionId the integration was launched
+     * in the context of, no matter how many times the transaction is set in the current interaction.
+     * You can leverage this to track the initial transaction context for a user interaction
+     *
+     * The current transactional context that your integration is operating in can be queried using the transaction.get method.
+     *
+     * @param options transaction details
+     * @returns transaction that has been set
+     */
+    set(options: TransactionInfo): Promise<TransactionInfo>;
+    /**
+     * Retrieve the transaction in whose context your integration is operating in, utilized by methods that operate on an existing transaction.
+     * The methods that currently fall into this category are:
+     * transaction.update
+     * transaction.createEvent
+     * Although integrations are free to set the transactional context they are operating in
+     * (using the transaction.set method) , which may be necessary when providing views that
+     * allow users to switch between and perform actions on multiple transactions,
+     * the host application implicitly alters the transactional context in certain scenarios:
+     *
+     * Implicit transaction context setting!
+     * If your integration is launched by a user in the context of an existing transaction,
+     * such as from the services page on Loan Officer Connect, the document icon on the services
+     * side-nav in Encompass Desktop or on a loan application in Consumer Connect is set to said transaction.
+     * Every time a new transaction is created during a user's interaction with your integration,
+     * the context is set to the last created transaction.
+     * If the integration was initially launched in the context of an existing transaction,
+     * the transaction.getOrigin method will always return the original transactionId the integration was launched
+     * in the context of, no matter how many times the transaction is set in the current interaction.
+     * You can leverage this to track the initial transaction context for a user interaction
+     *
+     * The current transactional context your integration operates in can be queried using the transaction.get method
+     *
+     * @returns transaction id details
+     */
+    get(): Promise<TransactionInfo>;
+    /**
+     * Allow Lenders to update an existing transaction by attaching new resources or updating
+     * the request options associated with the transaction.
+     * A transaction update will trigger an updated webhook event on the urn:elli:epc:transaction REST resource,
+     * indicating an updated transaction request is ready for your application to retrieve.
+     * The updated transaction request will contain:
+     * An updated options object, if set in this method
+     * An updated resources array, with the resources set in this method appended to the previously attached set
+     * By default, a fresh snapshot of the loan data your application is entitled to receive in the transaction request
+     * By default, a fresh snapshot of the user's credential set configured by their Administrator for use with your application
+     *
+     * Request type immutability
+     * The type for a lender initiated transaction request can not be updated once created.
+     * If you need to support the ability for a lender to change the request type for a transaction they have initiated,
+     * the initial transaction must be canceled via a transaction response status update (using the REST API),
+     * and the lender must initiate a new transaction request with the updated type
+     *
+     * @param options transaction details
+     * @returns transaction id
+     */
+    update(options: TransactionOptions): Promise<TransactionInfo>;
+    /**
+     * Allow Lenders to initiate an event/message for the subject transaction with your integration
+     *
+     * @param options details of the event/message to be initiated
+     * @returns transaction event id
+     */
+    createEvent(options: TransactionEvent): Promise<TransactionInfo>;
+    /**
+     * Navigate your users back to where they left off in the host Encompass application,
+     * after they are done interacting with your application's user-interface
+     */
+    close(): Promise<void>;
+    /**
+     * Navigate your users back to where they left off in the host Encompass application,
+     * after they have canceled an interaction with your application's user-interface without having
+     * initiated a transaction request (or any other related task) that they were working on.
+     * This signals a cancelation outcome to the host Encompass application -
+     * how this is handled by the host upon user navigation can vary across applications
+     */
+    cancel(): Promise<void>;
+    /**
+     * Navigate your users back to where they left off in the host Encompass application,
+     * after their has been an error (application error or workflow error) on your integrations user-interface.
+     * This signals an error outcome to the host Encompass application -
+     * how this is handled by the host upon user navigation can vary across applications
+     */
+    error(): Promise<void>;
+}

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

@@ -0,0 +1,76 @@
+/**
+ * Transaction request object
+ */
+export declare type TransactionRequest = {
+    /**
+     * The type of transaction request being templated for the subject product.
+     * This must be one of the supported values for the request type that your application is configured to support,
+     * based on which its data entitlements are scoped
+     */
+    type: string;
+    /**
+     * The specific set of selectable options that apply to the specific type of transaction request,
+     * as modeled by your application, being templated by the Lender administrator.
+     * This can be used to select from which bureaus to order a borrower's credit score for a Credit integration,
+     * or how many days of income information to pull for a borrower in the case of a Verification of Income/Employment integration
+     */
+    options?: Record<string, any>;
+};
+/**
+ * Transaction Template object
+ *
+ * Note:
+ * Remember, the transactionTemplate object is only accessible to the administrator-facing view of a Partner application,
+ * registered as the $.adminInterfaceUrl property in the product configuration.
+ * This object encapsulates functionality that is only relevant for products that support 1-click/automated ordering workflows
+ * (as specified by the $.tags.workflows tag in the product configuration), and is only applicable
+ * when an administrator is trying to create a 1-click/automated service ordering setup
+ * in the Loan Officer Connect services management section.
+ * This object is therefore not accessible to an integration's service ordering views
+ * (registered as the $.interfaceUrl property in the product configuration),
+ * wherein the transaction and application objects are available for use as applicable.
+ */
+export declare type TransactionTemplateDetails = {
+    /**
+     * The listed name for the transaction template - as auto-generated, or as provided
+     * by the lender administrator when the template was created
+     */
+    name: string;
+    request: Array<TransactionRequest>;
+};
+/**
+ * Provides application's administrator-facing view with the necessary handles
+ * for enabling Lender administrators to create transaction request templates,
+ * which they can associate with a 1-click/automated ordering business condition set.
+ */
+export interface ITransactionTemplate {
+    /**
+     * Discover if your administrator-facing view has been rendered in the context of an existing
+     * transaction request template (in edit mode) or a new transaction request template (in create mode).
+     *
+     * If your application is launched in the context of an existing transaction template,
+     * this method will return the previously created transactionTemplate object, containing
+     * the associated request type and set of request options, which your application
+     * user-interface can use to render the applicable view for the administrator (such as pre-filling the form entries).
+     *
+     * Otherwise, if your application is launched in the context of a new transaction request template,
+     * this method will return a null response.
+     *
+     * @returns transactionTemplate object in edit mode, or null in create mode
+     */
+    get(): Promise<TransactionTemplateDetails | null>;
+    /**
+     * Create a new transaction request template, containing a defined request type and set of request options,
+     * that Lender administrators can associate with a 1-click/automated ordering business condition set.
+     *
+     * @param options details of the transaction template to be created
+     * @returns success
+     */
+    save(options: TransactionTemplateDetails): Promise<string>;
+    /**
+     * Navigate the administrator users back to where they left off in the
+     * Loan Officer Connect services management application, after they are done interacting
+     * with your application's administrator-facing user-interface
+     */
+    close(): Promise<void>;
+}

package/dist/types/{userAccessRights.d.ts → objects/userAccessRights.d.ts}

@@ -1,3 +1,6 @@
+/**
+ * user access rights object
+ */
 export declare type UserAccessRights = {
     access: string[];
     additionalServices: AdditionalServices;

package/dist/types/{view.d.ts → objects/view.d.ts}

@@ -7,15 +7,7 @@ export declare type ViewportSize = {
     height: number;
 };
 /**
- * parent window resize event handler
- */
-export declare type ResizeEventListener = (entries: ResizeObserverEntry) => void;
-/**
- * parent window breakpoint change event handler
- */
-export declare type BreakpointChangeEventListener = (breakpoint: BreakPoint) => void;
-/**
- * Methods and events to view, modify & get notified about parent's window attributes
+ * Methods view, modify parent's window attributes
  */
 export interface IView {
     /**
@@ -26,16 +18,26 @@ export interface IView {
      * Get the current viewport size of the parent window
      */
     getViewPortSize(): Promise<ViewportSize>;
+}
+/**
+ * parent window resize event handler
+ *
+ * @param entries details about the resize event
+ */
+export declare type ResizeEventListener = (entries: ResizeObserverEntry) => void;
+/**
+ * parent window breakpoint change event handler
+ *
+ * @param breakpoint current breakpoint of the parent window
+ */
+export declare type BreakpointChangeEventListener = (breakpoint: BreakPoint) => void;
+export declare type ViewEvents = {
     /**
-     * parent window resize event
-     *
-     * @param eventHandler event handler to be called when the parent window is resized
+     * eent is fired when the parent window is resized
      */
-    onResizeEvent(eventHandler: ResizeEventListener): string;
+    'view.resize': ResizeEventListener;
     /**
-     * parent window breakpoint change event
-     *
-     * @param eventHandler event handler to be called when the parent window's breakpoint changes
+     * event is fired when the parent window's breakpoint changes
      */
-    onBreakpointChangeEvent(eventHandler: BreakpointChangeEventListener): string;
-}
+    'view.breakpointChange': BreakpointChangeEventListener;
+};

package/dist/types/scriptingObjectTypes.d.ts

@@ -1,24 +1,34 @@
-import { ILoan } from './loan.js';
-import { ILoanV2 } from './loanv2.js';
-import { IApplication } from './application.js';
-import { IAuth } from './auth.js';
-import { ISession } from './session.js';
-import { ITransaction } from './transaction.js';
-import { ITransactionTemplate } from './transactiontemplate.js';
-import { IForm } from './form.js';
-import { IGlobal } from './global.js';
-import { IHttp } from './http.js';
-import { IAnalytics } from './analytics.js';
+import { ILoan } from './objects/loan.js';
+import { ILoanV2 } from './objects/loanv2.js';
+import { IApplication } from './objects/application.js';
+import { IAuth } from './objects/auth.js';
+import { ISession } from './objects/session.js';
+import { ITransaction } from './objects/transaction.js';
+import { ITransactionTemplate } from './objects/transactionTemplate.js';
+import { IForm } from './objects/form.js';
+import { IGlobal } from './objects/global.js';
+import { IHttp } from './objects/http.js';
+import { IAnalytics } from './objects/analytics.js';
+import { IMemStorage } from './objects/memStorage.js';
+import { IView } from './objects/view.js';
+import { IRoute } from './objects/route.js';
+import { IModule } from './objects/module.js';
+import { IService } from './objects/service.js';
 export declare type ScriptingObjectTypes = {
-    Application: IApplication;
     Analytics: IAnalytics;
+    Application: IApplication;
     Auth: IAuth;
     Form: IForm;
     Global: IGlobal;
     Http: IHttp;
     Loan: ILoan;
     LoanV2: ILoanV2;
+    MemStorage: IMemStorage;
+    Module: IModule;
+    Route: IRoute;
+    Service: IService;
     Session: ISession;
     Transaction: ITransaction;
     TransactionTemplate: ITransactionTemplate;
+    View: IView;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/pui-scripting-object",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Typescript defintions for Scripting Objects",
   "sideEffects": false,
   "main": "./dist/cjs/index.js",
@@ -58,7 +58,7 @@
   },
   "devDependencies": {
     "@elliemae/browserslist-config-elliemae-latest-browsers": "~1.5.0",
-    "@elliemae/pui-cli": "~7.9.0",
+    "@elliemae/pui-cli": "~7.10.3",
     "@elliemae/pui-doc-gen": "~1.3.0",
     "@elliemae/pui-theme": "~2.6.0",
     "@types/styled-components": "~5.1.26",

package/dist/cjs/transactiontemplate.js

@@ -1,16 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var transactiontemplate_exports = {};
-module.exports = __toCommonJS(transactiontemplate_exports);

package/dist/types/auth.d.ts

@@ -1,43 +0,0 @@
-import { UserAccessRights } from './userAccessRights';
-export declare type Personas = {
-    entityId: string;
-    entityType: string;
-    entityName: string;
-};
-export declare type User = {
-    id: string;
-    realm: string;
-    firstName: string;
-    lastName: string;
-    phone: string;
-    cellPhone: string;
-    personas: Array<Personas>;
-    clientId: string;
-    email: string;
-};
-export declare enum TokenType {
-    BEARER = "Bearer"
-}
-export declare type PluginInfo = {
-    clientId: string;
-    redirectUrl: string;
-    scope: TokenType;
-};
-export declare type TokenInfo = {
-    accessToken: string;
-    tokenType: TokenType;
-    apiBaseUrl: string;
-};
-export interface IAuth {
-    tokenUrl: string;
-    createAuthCode(clientId: string): Promise<string>;
-    getAccessToken(appInfo: PluginInfo): Promise<TokenInfo>;
-    getUser(): Promise<User>;
-    /**
-     * Get access rights for the current user
-     *
-     * @returns user access rights
-     * @throws {Error} if operation fails
-     */
-    getUserAccessRights(): Promise<UserAccessRights>;
-}

package/dist/types/form.d.ts

@@ -1,10 +0,0 @@
-export declare type FormDescriptor = {
-    id: string;
-    name: string;
-};
-export interface IForm {
-    getDescriptor(): Promise<FormDescriptor>;
-    getControl(id: string): Promise<any>;
-}
-export declare type FormLoadListener = (id: string) => void;
-export declare type FormUnloadListener = (id: string) => void;

package/dist/types/global.d.ts

@@ -1,5 +0,0 @@
-export interface IGlobal {
-    set(key: string, value: string): Promise<void>;
-    get(key: string): Promise<string>;
-}
-export declare type GlobalStateChangeListener = (key: string) => void;

package/dist/types/http.d.ts

@@ -1,7 +0,0 @@
-export interface IHttp {
-    get(url: string, headersOrAccessToken?: HeadersInit | string): Promise<Response>;
-    post(url: string, content: string | Record<string, string>, headersOrAccessToken?: HeadersInit | string): Promise<Response>;
-    patch(url: string, content: string | Record<string, string>, headersOrAccessToken?: HeadersInit | string): Promise<Response>;
-    put(url: string, content: string | Record<string, string>, headersOrAccessToken?: HeadersInit | string): Promise<Response>;
-    delete(url: string, headersOrAccessToken?: HeadersInit | string): Promise<Response>;
-}

package/dist/types/module.d.ts

@@ -1,16 +0,0 @@
-export declare enum LogLevel {
-    TRACE = "TRACE",
-    DEBUG = "DEBUG",
-    INFO = "INFO",
-    AUDIT = "AUDIT",
-    WARN = "WARN",
-    ERROR = "ERROR",
-    FATAL = "FATAL"
-}
-export interface IModule {
-    getCapabilities(): Promise<Record<string, string>>;
-    getParameters(): Promise<Record<string, string>>;
-    unload(): Promise<void>;
-    log(message: string, logLevel: LogLevel): Promise<void>;
-}
-export declare type ModuleUnLoadingListener = (id: string) => boolean;

package/dist/types/transaction.d.ts

@@ -1,53 +0,0 @@
-export declare type OriginInfo = {
-    partnerAccessToken: string;
-    id: string;
-    transactionId?: string;
-};
-export declare type TransactionInfo = {
-    id: string | null;
-};
-export declare type TransactionResource = {
-    id: string;
-    name: string;
-    repository: string;
-    mimeType: string;
-};
-export declare type TransactionOptions = {
-    scope?: Array<string>;
-    request: {
-        type: string;
-        options?: Record<string, string>;
-        resources: Array<TransactionResource>;
-    };
-};
-export declare type TransactionResourceFile = {
-    name: string;
-    source: string;
-};
-export declare type TransactionResourceResponse = {
-    id: string;
-    respository: string;
-    name: string;
-    location: string;
-    authorizationHeader: string;
-    mimeType: string;
-};
-export declare type TransactionEvent = {
-    text: string;
-    type: string;
-    comments: string;
-    resources: Array<TransactionResource>;
-};
-export interface ITransaction {
-    getOrigin(): Promise<OriginInfo>;
-    refreshOrigin(): Promise<OriginInfo>;
-    get(): Promise<TransactionInfo>;
-    set(options: TransactionInfo): Promise<void>;
-    create(options: TransactionOptions): Promise<TransactionInfo>;
-    update(options: TransactionOptions): Promise<TransactionInfo>;
-    createResource(options: TransactionResourceFile): Promise<TransactionResourceResponse>;
-    createEvent(options: TransactionEvent): Promise<TransactionInfo>;
-    close(): Promise<void>;
-    cancel(): Promise<void>;
-    error(): Promise<void>;
-}

package/dist/types/transactiontemplate.d.ts

@@ -1,12 +0,0 @@
-export declare type TransactionRequest = {
-    type: string;
-    options?: Record<string, string>;
-};
-export declare type TransactionTemplateOptions = {
-    request: Array<TransactionRequest>;
-};
-export interface ITransactionTemplate {
-    get(): Promise<TransactionTemplateOptions | null>;
-    save(options: TransactionTemplateOptions): Promise<string>;
-    close(): Promise<string>;
-}