@trulioo/kyc-documents 3.0.43-beta.0

package/236.js

@@ -0,0 +1 @@
+"use strict";(globalThis.webpackChunkui=globalThis.webpackChunkui||[]).push([[236],{236:e=>{e.exports=function(){throw new Error("ws does not work in the browser. Browser clients must use the native WebSocket object")}}}]);

package/LICENSE.md

@@ -0,0 +1,13 @@
+BY DOWNLOADING, INSTALLING, ACCESSING, OR OTHERWISE USING THE IMAGE CAPTURE SDK (DEFINED BELOW) PROVIDED OR MADE AVAILABLE BY TRULIOO INFORMATION SERVICES INC. (“**us**,” “**we**,” or “**our**”), YOU HEREBY AGREE TO BE BOUND BY THE TERMS AND CONDITIONS SET FORTH BELOW (“**Terms**”). IF YOU DO NOT AGREE TO THESE TERMS, THEN YOU DO NOT HAVE OUR PERMISSION TO USE THE IMAGE CAPTURE SDK. THESE TERMS DO NOT GRANT YOU OR ANY USER OF YOUR APPLICATION (AS DEFINED BELOW) THE RIGHT TO ACCESS OR USE ANY OF OUR OTHER PRODUCTS AND SERVICES (“**Services**”), AND ANY ACCESS TO OR USE OF THE SERVICES IS SUBJECT TO THE CUSTOMER AGREEMENT ENTERED INTO BETWEEN YOU AND US (IF ANY) GOVERNING SUCH ACCESS AND USE (“**Customer Agreement**”). IF THE IMAGE CAPTURE SDK IS BEING USED ON BEHALF OF A COMPANY, ORGANIZATION, OR OTHER ENTITY, THEN ALL REFERENCES TO “YOU,” OR “YOUR” REFER TO SUCH ENTITY AND ITS AFFILIATES, AND THE INDIVIDUAL AGREEING TO THESE TERMS ON YOUR BEHALF REPRESENTS AND WARRANTS THAT THEY HAVE AUTHORITY TO BIND YOU TO THESE TERMS.
+
+1. <u>License; License Keys</u>. Subject to your compliance with these Terms, we hereby grant you a limited, non-exclusive, non-sublicensable, non-transferable, royalty-free, fully paid-up license, exercisable by and through your employees and contractors, to internally use and reproduce a reasonable number of copies of the software development kit (including any portion thereof) provided or made available by us to you under these Terms (“**Image Capture SDK**”) for the sole purpose of your internal development and testing of a software application developed by you or on your behalf that interoperates with Services (“**Application**”). Any use of the Image Capture SDK in a production format of your Application, for commercial purposes, or for any other purpose not expressly permitted by this Section 1 requires a license key provided by us to you pursuant to the Customer Agreement (“**License Key(s)**”). You hereby acknowledge and agree that: (a) the Image Capture SDK, the License Keys, and any know-how and trade secrets relating thereto are our sole and exclusive property and are confidential and proprietary to us; and (b) you will protect each of them using the same degree of care, but no less than a reasonable degree of care, as you use to protect your own confidential information.       
+
+2. <u>Restrictions</u>. Except to the extent otherwise permitted under these Terms or under applicable law, you will not, nor will you permit any third party to: (a) implement the Image Capture SDK in any software other than your Application or for any purpose other than its interoperation with the Services; (b) modify, translate, or create a derivative work of any portion of the Image Capture SDK; (c) sell, lease, loan, provide, distribute, disclose, expose, or otherwise transfer any portion of the Image Capture SDK (including any License Keys) to any third party (except for the limited right to distribute, in object code format, any source code (modified or unmodified) or object code provided with the Image Capture SDK solely as integrated components of your Application); (d) reverse engineer, disassemble, decompile, or otherwise attempt to gain access to the source code of the Services or the Image Capture SDK; (e) remove, alter, or obscure any copyright notices or other proprietary rights notices displayed on any portion of the Image Capture SDK; (f) use the Image Capture SDK or the License Keys to develop any software (including your Application) or other technology that (1) can be used with any service or product other than the Services, or (2) is competitive, directly or indirectly, with the Services; (g) interfere with the normal operation and security of the Image Capture SDK or the Services; (h) release or commercially distribute to third parties an Application in production format that is (1) not fully compatible with the Image Capture SDK and the Services, or (2) integrated or interoperable with any application programming interface not provided with the Image Capture SDK; or (i) circumvent or disable any technological, usage, or security features, restrictions, or limitations of any portion of the Image Capture SDK (including any License Keys).   
+
+3. <u>Other Terms</u>. The Image Capture SDK is licensed, not sold, to you.  All rights not expressly granted herein are reserved by us.  No additional rights whatsoever are granted to you by implication, estoppel or otherwise. The Image Capture SDK may incorporate third-party open-source software (“OSS”), as specified by us in the Image Capture SDK documentation or upon your prior written request, and any use of OSS on a stand-alone basis will be subject to the terms of the applicable OSS license and not these Terms. We reserve the right to modify or discontinue our provision of all or any portion of the Image Capture SDK at any time, temporarily or permanently, without notice to you. These Terms and the rights and licenses granted hereunder: (a) can be terminated by us at any time for any reason or for no reason at all, without notice to you; and (b) will automatically terminate if you breach any provision of these Terms. Upon any termination of these Terms, you must immediately cease all use of the Image Capture SDK and destroy all copies of the Image Capture SDK in your control or possession. If you have entered into a Customer Agreement with us or have otherwise agreed to other policies, guidelines, or terms and conditions (click-through, click-wrap, or otherwise) with us, they may contain additional rights, restrictions, and obligations relating to your access to and use of the Image Capture SDK that are not expressly set forth herein, and you are responsible for complying with them.  
+
+4. <u>Disclaimer</u>. THE IMAGE CAPTURE SDK AND ALL INTELLECTUAL PROPERTY MADE AVAILABLE OR LICENSED BY US UNDER THESE TERMS ARE PROVIDED “AS IS” WITHOUT ANY REPRESENTATION OR WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY, NON INFRINGEMENT, QUALITY, ACCURACY, AND FITNESS FOR A PARTICULAR PURPOSE.  ANY USE OF THE IMAGE CAPTURE SDK IS AT YOUR OWN RISK.
+
+5. <u>Limitation of Liability</u>. TO THE FULLEST EXTENT PERMITTED BY LAW, IN NO EVENT WILL WE, UNDER THESE TERMS, HAVE ANY (a) LIABILITY TO YOU OR TO ANY THIRD PARTY HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE), or (b) OBLIGATION TO INDEMNIFY, DEFEND, OR HOLD YOU OR ANY THIRD PARTY HARMLESS. TO THE EXTENT THAT A COURT HOLDS THAT THESE TERMS ARE INVALID OR UNENFORCEABLE AS A RESULT OF OUR DISCLAIMING ALL LIABILITY AND DAMAGES UNDER THESE TERMS PURSUANT TO THIS SECTION 5, THEN, TO THE FULLEST EXTENT PERMITTED BY LAW, OUR TOTAL LIABILITY TO YOU HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) WILL NOT EXCEED $50.00 (USD).   
+
+6. <u>Miscellaneous</u>. These Terms are governed by the laws of British Columbia, Canada without regard to conflict of law principles. You may not assign or transfer these Terms or your rights hereunder, in whole or in part, by operation of law, change of control, or otherwise, without our prior written consent. Any attempted assignment by you in violation of this Section will be null and void. If any part of these Terms is held to be invalid or unenforceable, then the unenforceable part will be given effect to the greatest extent possible, and the remaining parts will remain in full force and effect.

package/README.md

@@ -0,0 +1,95 @@
+# @trulioo/kyc-documents
+
+Trulioo KYC-Documents Javascript SDK
+
+For more information, see our [Documentation](https://docs.verification.trulioo.com/sdk/web-3.0/index.html).
+
+<hr />
+
+## Info
+
+Some US states impose obligations on businesses that collect and use “biometric identifiers” and/or “biometric information”, which may include facial scan data extracted from photos during a document verification transaction. One such law is the Illinois Biometric Information Privacy Act (“BIPA”). A business required to comply with BIPA is under obligations to, among other things, ensure that it informs the individual of the purpose of the collection and obtain consent. Accordingly, we require a notice and consent mechanism be implemented for all document verification transactions, and our customers using our API must provide us with confirmation via API whether an individual is located in the United States and has consented to the transaction in the prescribed manner. We also strongly encourage all of our customers to consult with legal counsel to ensure their own compliance with such laws.
+
+For more information about the required notice and consent mechanism, please refer to our [Service Specific Terms for Document Verification](https://www.trulioo.com/legal/SST).
+
+## Install and Usage
+
+#### HTML
+Create an HTML element where the SDK UI should be rendered:
+```html
+<div id="trulioo-sdk"></div>
+```
+
+#### JS
+Import the Javascript modules and set up the SDK:
+
+```javascript showLineNumbers
+import {Trulioo, EventBuilder, ListenerCallback, Response} from "@trulioo/kyc-documents"
+
+const elementID = "trulioo-sdk" // The HTML element id to attach to
+const shortCode = "sample-short-code" // Set the obtained short code from the Trulioo Customer API
+
+// Set up callbacks to get results and debugging errors
+const callbacks = new ListenerCallback({
+    onComplete: (success: Response.Success) => {
+        console.info(`Verification Successful: ${success.transactionId} `)
+    },
+    onError: (error: Response.Error) => {
+        console.error(`Verification Failed with Error Code: ${error.code}, Reason: ${error.message}`)
+    },
+    onException: (exception: Response.Exception) => {
+        console.error("Verification Failed with Exception:", exception)
+    }
+})
+
+const events = new EventBuilder()
+const callbackOption = events.setCallbacks(callbacks)
+
+// Initialize the SDK with the shortcode
+const trulioo = new Trulioo()
+trulioo.initialize(shortCode)
+    .then(complete => {
+        console.info("Initialize complete:", complete)
+        // Launch the UI with the provided HTML element ID
+        trulioo.launch(elementID, callbackOption)
+            .then(success => {
+                console.info("Launch success:", success)
+            })
+    })
+    .catch(error =>
+        console.error("Error:", error)
+    )
+
+```
+**Note**: The SDK will import additional css files automatically. Be sure to not exclude the css files contained in the @trulioo/kyc-documents node_modules
+directory from your web app configuration if you are using webpack css-loader or something similar.
+
+------
+## Customization
+
+The SDK supports customization options that allow you to tailor the user experience. You can configure settings such as language locale and themes.
+All customization is managed through the **Customer API** at the time you create a transaction. Once the short code is provided to the SDK, it will automatically render using the configured locale and theme.
+
+For details on how to configure these options, see the [Customer API documentation](https://docs.verification.trulioo.com/api/customer/2.5/index.html#tag/Transaction/operation/post-transactions).
+
+------
+## Desktop to Mobile Workflow
+
+The SDK also supports cross-device document capture.  
+When a user begins the verification flow on a desktop browser, they will be shown a QR code that can be scanned with their mobile phone. 
+This allows them to seamlessly continue the capture process using their phone’s camera.
+After completing the document capture on mobile, the user is automatically redirected back to their desktop session to continue and complete the verification flow.
+
+For details on how to configure these options, see the [Customer API documentation](https://docs.verification.trulioo.com/api/customer/2.5/index.html#tag/Transaction/operation/post-transactions).
+
+------
+## Utilize the SDK from a CDN
+
+In your project, you can import the Trulioo SDK:
+```javascript
+import truliooKYC from "https://cdn.jsdelivr.net/npm/@trulioo/kyc-documents/+esm"
+```
+
+You will now have full access to the SDK via your import, without any extra configuration steps needed.
+The above URL will get you the latest version of the SDK. If you want to use a more specific version for the SDK,
+you can do https://cdn.jsdelivr.net/npm/@trulioo/kyc-documents@VERSION_NUMBER/+esm and replace the VERSION_NUMBER to your choice.

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@trulioo/kyc-documents",
+  "version": "3.0.43-beta.0",
+  "main": "trulioo-kyc-documents.js",
+  "types": "trulioo-kyc-documents.d.ts",
+  "devDependencies": {
+    "webpack": "5.94.0",
+    "webpack-cli": "5.1.4",
+    "kotlin-web-helpers": "2.0.0",
+    "typescript": "5.5.4",
+    "source-map-loader": "5.0.0",
+    "webpack-dev-server": "4.15.2",
+    "lottie-web": "5.12.2",
+    "hash.js": "1.1.7",
+    "@js-joda/core": "3.2.0",
+    "format-util": "^1.0.5",
+    "ws": "8.18.0"
+  },
+  "dependencies": {},
+  "peerDependencies": {},
+  "optionalDependencies": {},
+  "bundledDependencies": [],
+  "license": "SEE LICENSE IN LICENSE.md"
+}

package/trulioo-kyc-documents.d.ts

@@ -0,0 +1,281 @@
+type Nullable<T> = T | null | undefined
+/** @deprecated  */
+export declare const initHook: { get(): any; };
+export declare class CameraProps {
+    constructor(backgroundColor?: string);
+    get backgroundColor(): string;
+    shouldShowAnimation(): boolean;
+    copy(backgroundColor?: string): CameraProps;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare class Coordinates {
+    constructor(topLeft: ScreenPoint, bottomRight: ScreenPoint, center: ScreenPoint);
+    get topLeft(): ScreenPoint;
+    get bottomRight(): ScreenPoint;
+    get center(): ScreenPoint;
+    copy(topLeft?: ScreenPoint, bottomRight?: ScreenPoint, center?: ScreenPoint): Coordinates;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare class ScreenPoint {
+    constructor(x: number, y: number);
+    get x(): number;
+    get y(): number;
+    copy(x?: number, y?: number): ScreenPoint;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare interface ITruliooImageFeedback {
+    readonly imageId: string;
+    readonly detectionType: DetectionType;
+    readonly imageFeedbacks: Array<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.sdk.capture.contract.ITruliooImageFeedback": unique symbol;
+    };
+}
+export declare interface ITruliooVerifyFeedback {
+    readonly isVerifyAttemptAvailable: boolean;
+    readonly verifyResponses: Array<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.sdk.capture.contract.ITruliooVerifyFeedback": unique symbol;
+    };
+}
+export declare class TruliooCameraConfig {
+    constructor(detectionType?: DetectionType);
+    get detectionType(): DetectionType;
+    copy(detectionType?: DetectionType): TruliooCameraConfig;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare abstract class DetectionType {
+    private constructor();
+    static get DOCUMENT(): DetectionType & {
+        get name(): "DOCUMENT";
+        get ordinal(): 0;
+    };
+    static get BIOMETRIC_SELFIE(): DetectionType & {
+        get name(): "BIOMETRIC_SELFIE";
+        get ordinal(): 1;
+    };
+    get name(): "DOCUMENT" | "BIOMETRIC_SELFIE";
+    get ordinal(): 0 | 1;
+    static values(): Array<DetectionType>;
+    static valueOf(value: string): DetectionType;
+}
+export declare class TruliooCameraProps {
+    constructor(backgroundColor?: string);
+    get backgroundColor(): string;
+    shouldShowAnimation(): boolean;
+    copy(backgroundColor?: string): TruliooCameraProps;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare class TruliooError /* extends Error */ {
+    private constructor();
+    get code(): number;
+    get errorMessage(): string;
+    static get GeneralError(): {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & TruliooError;
+    static get FeedbackManuallyStopped(): {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & TruliooError;
+    static get CameraIsNotReady(): {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & TruliooError;
+    static get SdkIsNotInitialized(): {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & TruliooError;
+    static get ParentElementNotFound(): {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & TruliooError;
+    static get CameraPermissionDenied(): {
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & TruliooError;
+}
+export declare namespace TruliooError {
+    class UnexpectedError extends TruliooError {
+        constructor();
+    }
+}
+export declare interface ITruliooCamera {
+    readonly id: string;
+    readonly detectionType: DetectionType;
+    render(parentElementId: string, cameraProps?: Nullable<TruliooCameraProps>): Promise<any>;
+    onCaptureRegion(onRegionChange: (p0: Coordinates) => void): void;
+    startFeedback(): Promise<ITruliooCaptureResponse>;
+    startFeedbackWithFilter(filter: (p0: ITruliooImageFeedback) => boolean): Promise<ITruliooCaptureResponse>;
+    stopFeedback(): void;
+    onFeedbackState(feedback: (p0: string) => void): void;
+    captureLatestFrame(): Promise<ITruliooManualCaptureResponse>;
+    remove(): void;
+    resume(): void;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.sdk.capture.ITruliooCamera": unique symbol;
+    };
+}
+export declare interface ITruliooCaptureResponse extends ICaptureResponse, ITruliooImageFeedback {
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.sdk.capture.ITruliooCaptureResponse": unique symbol;
+    } & ICaptureResponse["__doNotUseOrImplementIt"] & ITruliooImageFeedback["__doNotUseOrImplementIt"];
+}
+export declare interface ITruliooManualCaptureResponse extends ICaptureResponse {
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.sdk.capture.ITruliooManualCaptureResponse": unique symbol;
+    } & ICaptureResponse["__doNotUseOrImplementIt"];
+}
+export declare interface ICaptureResponse {
+    readonly imageId: string;
+    acceptImage(): Promise<any>;
+    verifyImage(): Promise<ITruliooVerifyFeedback>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.sdk.capture.ICaptureResponse": unique symbol;
+    };
+}
+export declare interface ITruliooCapture {
+    initialize(shortCode: string): Promise<string>;
+    createTruliooCamera(config?: Nullable<TruliooCameraConfig>): ITruliooCamera;
+    submit(): Promise<any>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.sdk.capture.ITruliooCapture": unique symbol;
+    };
+}
+export declare class TruliooCamera implements ITruliooCamera {
+    constructor(detectionType: DetectionType, id?: string, viewModel?: any/* ICameraViewModel */, cameraView?: any/* IWebCameraView */, cameraDispatcher?: any/* CoroutineDispatcher */);
+    get detectionType(): DetectionType;
+    get id(): string;
+    render(parentElementId: string, cameraProps?: Nullable<TruliooCameraProps>): Promise<any>;
+    onCaptureRegion(onRegionChange: (p0: Coordinates) => void): void;
+    startFeedback(): Promise<ITruliooCaptureResponse>;
+    startFeedbackWithFilter(filter: (p0: ITruliooImageFeedback) => boolean): Promise<ITruliooCaptureResponse>;
+    stopFeedback(): void;
+    onFeedbackState(feedback: (p0: string) => void): void;
+    captureLatestFrame(): Promise<ITruliooManualCaptureResponse>;
+    resume(): void;
+    remove(): void;
+    readonly __doNotUseOrImplementIt: ITruliooCamera["__doNotUseOrImplementIt"];
+}
+export declare const TruliooCapture: {
+    getInstance(): {
+        initialize(shortCode: string): Promise<string>;
+        createTruliooCamera(config?: Nullable<TruliooCameraConfig>): ITruliooCamera;
+        submit(): Promise<any>;
+        readonly __doNotUseOrImplementIt: ITruliooCapture["__doNotUseOrImplementIt"];
+    } & ITruliooCapture;
+};
+export declare class TruliooCaptureResponse implements ITruliooCaptureResponse {
+    constructor(detectionType: DetectionType, imageDecision: any/* IImageDecision */, cameraFlow: any/* ISDKCameraBridge */);
+    get detectionType(): DetectionType;
+    get imageId(): string;
+    get imageFeedbacks(): Array<string>;
+    acceptImage(): Promise<any>;
+    verifyImage(): Promise<ITruliooVerifyFeedback>;
+    readonly __doNotUseOrImplementIt: ITruliooCaptureResponse["__doNotUseOrImplementIt"];
+}
+export declare class TruliooManualCaptureResponse implements ITruliooManualCaptureResponse {
+    constructor(imageId: string, cameraFlow: any/* ISDKCameraBridge */);
+    get imageId(): string;
+    acceptImage(): Promise<any>;
+    verifyImage(): Promise<ITruliooVerifyFeedback>;
+    readonly __doNotUseOrImplementIt: ITruliooManualCaptureResponse["__doNotUseOrImplementIt"];
+}
+export declare class Trulioo implements ITrulioo {
+    constructor();
+    initialize(shortcode: string): Promise<TruliooResult.Authorized>;
+    launch(parentId: string, eventBuilder: EventBuilder): Promise<TruliooResult>;
+    readonly __doNotUseOrImplementIt: ITrulioo["__doNotUseOrImplementIt"];
+}
+export declare interface ITrulioo {
+    initialize(shortcode: string): Promise<TruliooResult.Authorized>;
+    launch(parentId: string, eventBuilder: EventBuilder): Promise<TruliooResult>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "com.trulioo.docv.ui.contract.ITrulioo": unique symbol;
+    };
+}
+export declare abstract class TruliooResult {
+    protected constructor();
+    static get Complete(): {
+    } & TruliooResult;
+}
+export declare namespace TruliooResult {
+    class Authorized extends TruliooResult {
+        constructor(transactionId: string);
+        get transactionId(): string;
+        copy(transactionId?: string): TruliooResult.Authorized;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class Error extends TruliooResult {
+        constructor(message: string, code?: Nullable<number>, transactionId?: Nullable<string>);
+        get message(): string;
+        get code(): Nullable<number>;
+        get transactionId(): Nullable<string>;
+        toString(): string;
+        copy(message?: string, code?: Nullable<number>, transactionId?: Nullable<string>): TruliooResult.Error;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare abstract class Response {
+    protected constructor();
+    abstract asJs(): any;
+}
+export declare namespace Response {
+    class Success extends Response {
+        constructor(transactionId: Nullable<string>);
+        get transactionId(): Nullable<string>;
+        asJs(): any;
+        copy(transactionId?: Nullable<string>): Response.Success;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class Error extends Response {
+        constructor(code: number, message: Nullable<string>);
+        get code(): number;
+        get message(): Nullable<string>;
+        asJs(): any;
+        copy(code?: number, message?: Nullable<string>): Response.Error;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    class Exception extends Response {
+        constructor(message: Nullable<string>);
+        get message(): Nullable<string>;
+        asJs(): any;
+        copy(message?: Nullable<string>): Response.Exception;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare class EventBuilder {
+    constructor();
+    setCallbacks(obj: Nullable<ListenerCallback>): EventBuilder;
+}
+export declare class ListenerCallback {
+    constructor(obj?: any);
+    get onComplete(): (p0: Response.Success) => void;
+    get onError(): (p0: Response.Error) => void;
+    get onException(): (p0: Response.Exception) => void;
+}