/**
* This file was auto-generated by swagger-to-ts.
* Do not make direct changes to the file.
*/
export declare interface Core {
/**
* Valid ID types
* - "OTHER": Generic document type. Unspecified.
* - "DRIVERS_LICENCE": Driver's licence.
* - "PASSPORT": Passport
* - "VISA": Visa document (not Visa payment card)
* - "IMMIGRATION": Immigration card
* - "NATIONAL_ID": Any national ID card
* - "TAX_ID": Any national tax identifier
* - "NATIONAL_HEALTH_ID": Any national health program ID card (e.g. Medicare, NHS)
* - "CONCESSION": State issued concession card
* - "HEALTH_CONCESSION": State issued health specific concession card
* - "PENSION": State issued pension ID
* - "MILITARY_ID": Military ID
* - "BIRTH_CERT": Birth certificate
* - "CITIZENSHIP": Citizenship certificate
* - "MARRIAGE_CERT": Marriage certificate
* - "DEATH_CERT": Death certificate
* - "NAME_CHANGE": Name chage confirmation
* - "UTILITY_BILL": Regulated utility bill, such as electricity, gas, etc
* - "BANK_STATEMENT": Bank/card statement
* - "BANK_ACCOUNT": Bank account
* - "INTENT_PROOF": A proof of intent. Generally a photo/video, or a scanned letter
* - "ATTESTATION": A document of attestation (e.g. Statutory Declaration)
* - "SELF_IMAGE": A "selfie" used for comparisions
* - "EMAIL_ADDRESS": An email address
* - "MSISDN": A mobile phone number
* - "DEVICE": A device ID
* - "VEHICLE_REGISTRATION": Vehicle registration number
* Business related documentation
* - "EXTERNAL_ADMIN": Details of appointed administrator.
* - "CHARGES": Details of any charges that have been laid against a company or director
* - "PRE_ASIC": Any documents that are Pre-ASIC
* - "ANNUAL_RETURN": Details of a company's annual return
* - "REPORT": Frankie generated report.
* Special document types
* - "CHECK_RESULTS": A special document type for specifying results of checks completed other than through Frankie.
*/
enumIdType: "OTHER" | "DRIVERS_LICENCE" | "PASSPORT" | "VISA" | "IMMIGRATION" | "NATIONAL_ID" | "TAX_ID" | "NATIONAL_HEALTH_ID" | "CONCESSION" | "HEALTH_CONCESSION" | "PENSION" | "MILITARY_ID" | "BIRTH_CERT" | "CITIZENSHIP" | "MARRIAGE_CERT" | "DEATH_CERT" | "NAME_CHANGE" | "MOBILE_PHONE" | "UTILITY_BILL" | "BANK_STATEMENT" | "BANK_ACCOUNT" | "INTENT_PROOF" | "ATTESTATION" | "SELF_IMAGE" | "EMAIL_ADDRESS" | "MSISDN" | "DEVICE" | "VEHICLE_REGISTRATION" | "EXTERNAL_ADMIN" | "CHARGES" | "PRE_ASIC" | "ANNUAL_RETURN" | "REPORT" | "CHECK_RESULTS" | "PROOF_OF_ADDRESS" | "TRUST_DEED" | "PARTNERSHIP_AGREEMENT" | "ADMIN_CHANGE" | "COMPANY_REPORT" | "RENTAL_AGREEMENT" | "TAX_STATEMENT" | "HOUSE_REGISTRATION" | "YELLOW_HOUSE_REGISTRATION" | "WORK_PERMIT" | "EMPLOYMENT_CERTIFICATE" | "NOTARY_PUBLIC_ID";
/**
* Used to describe the contents of the KVP data.
*
* The general.* and raw.* types are pretty much what they say on the tin.
*
* All raw.* fields will be base64 encoded so as to not interfere with JSON structuring. These are useful for returning/storing large quantities of data that doesn't necessarily require processing now, or may be useful to a calling client.
*
* The id.* and pii.* are used to indicate that this is data that can be used to create new document objects, or entities. They should also be treated with the utmost care and attention when it comes to securing them too.
*
* id.external can be used to capture an object's ID on an external service, and can potentially be searchable in the index
* Note - This is different from a result.id.
*
* defunct is used to mark an existing KVP deleted when the value must be retained, for example for audit purposes.
*
* result.* are used to capture response codes and transaction IDs from external services
*
* error.* types can be used when processing a document that returns an error, but doesn't necessarily require a full blown error response.
*/
enumKVPType: "defunct" | "general.string" | "general.integer" | "general.float" | "general.bool" | "general.date" | "general.datetime" | "raw.json.base64" | "raw.xml.base64" | "raw.base64" | "error.code" | "error.message" | "result.code" | "result.id" | "id.external" | "id.number.primary" | "id.number.additional" | "id.msisdn" | "id.email" | "id.device" | "pii.name.full" | "pii.name.familyname" | "pii.name.givenname" | "pii.name.middlename" | "pii.gender" | "pii.address.longform" | "pii.address.street1" | "pii.address.street2" | "pii.address.postalcode" | "pii.address.town" | "pii.address.suburb" | "pii.address.region" | "pii.address.state" | "pii.address.country" | "pii.dob" | "transient.string";
/**
* Valid ID document scan general types.
* - "PHOTO": Any photo
* - "VIDEO": Any video
* - "AUDIO": Any audio
* - "PDF": PDF or PS (may contain text, images or both)
* - "DOC": Word doc, RTF, etc
* - "ZIP": Any compressed file(s)
*/
enumScanType: "PHOTO" | "VIDEO" | "AUDIO" | "PDF" | "DOC" | "ZIP";
/**
* Describes if a scan is of the "F"ront or "B"ack of an ID. If not supplied, Front is always assumed.
*/
enumScanSide: "F" | "B";
/**
* Used to indicate of the entity in question is:
* - "M"ale
* - "F"emale
* - "U"nspecified
* - "O"ther (for want of a better option)
*/
enumGender: "U" | "F" | "M" | "O";
/**
* Used to indicate marital status of the Applicant
* - Single
* - Married
* - Widowed
* - Divorced
*/
enumMaritalStatus: "Single" | "Married" | "Widowed" | "Divorced";
/**
* The standard MIME type of the file being uploaded. We'll double-check to be certain, but this can help speed things up
*/
enumMIMEType: "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/tiff" | "image/bmp" | "application/zip" | "application/x-tar" | "application/x-rar-compressed" | "application/gzip" | "application/x-bzip2" | "application/x-7z-compressed" | "application/pdf" | "application/rtf" | "application/postscript" | "application/json" | "audio/mpeg" | "audio/m4a" | "audio/x-wav" | "audio/amr" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "video/mp4" | "video/webm" | "video/quicktime" | "video/x-msvideo" | "video/x-ms-wmv" | "video/mpeg";
/**
* The reason why the scanData in a response is missing.
* - "NORMAL": The scanData was retrieved and is included. If it is empty then it was never provided or was provided empty.
* - "EXCLUDED": The retrieval request was not for 'full' data, or the object has 'ScanDelete' set so the scanData is not included
* - "FAILED": The scanData could not be retrieved from the secure document store.
*
* The enumScanDataRetrievalState will not usually be set in a request. If a ScannedDocumentObject in a response has a 'FAILED' retrieval state then that object should not be sent back in a future possible update. It should either be omitted or the original data should be resent if it is available from another source. However it is safe to send the object in an update with the state received in a response. Any state other than 'NORMAL' (or '') will cause the blank scanData to be ignored, but other fields in the object will be updated if needed.
*/
enumScanDataRetrievalState: "NORMAL" | "EXCLUDED" | "FAILED";
/**
* Used to indicate what sort address this is, such as residential, business, postal, etc.
*
* RESIDENTIAL1-4 can be used to indicate the reverse chronological order of addresses.
* RESIDENTIAL or RESIDENTIAL1 is the current address
* RESIDENTIAL2 is the previous address, and so on.
*
* For Individual postal/mailing addresses, use POSTAL.
* For Businesses, use OFFICIAL_CORRESPONDANCE
*/
enumAddressType: "OTHER" | "RESIDENTIAL" | "RESIDENTIAL1" | "RESIDENTIAL2" | "RESIDENTIAL3" | "RESIDENTIAL4" | "BUSINESS" | "POSTAL" | "REGISTERED_OFFICE" | "PLACE_OF_BUSINESS" | "PLACE_OF_BIRTH" | "OFFICIAL_CORRESPONDANCE";
/**
* Current status of a document.
* - "INITIALISING": the state whilst you're uploading and updating
* - "SCAN_IN_PROGRESS": the state whilst it's being scanned.
* - "DOC_SCANNED": the document has been scanned and data extracted as best as possible. It's still possible to update the details and add more scans if you wish.
* - "DOC_CHECKED": the document has been used as part of a check that has been finalised in some way. You can no longer update this document and any attempt will generate an error.
*/
enumDocumentStatus: "INITIALISING" | "SCAN_IN_PROGRESS" | "DOC_SCANNED" | "DOC_CHECKED";
/**
* Check state for an individual data point
* - "UNCHECKED": Check has not yet been performed
* - "NOT_SUPPORTED": the requested check type or industry function is not supported by this connector.
* - "CHECKING": Checks are underway.
* - "UNPROCESSABLE": The data supplied was unprocessable.
* - "NO_MATCH": All checks complete, no records found that matched the details supplied
* - "CHECKED_PARTIAL_SUCCESS": All checks complete, but only some succeeded.
* - "CHECKED_SUCCESS_WITH_NOTES": All checks complete, but there are some notes (e.g. PEP or sanctions).
* - "CHECKED_SUCCESS_CLEAR": All checks complete, no additional notes
* - "CHECKED_FAILED": All checks complete, but all failed.
*/
enumCheckResultState: "UNCHECKED" | "CHECKING" | "UNPROCESSABLE" | "NOT_SUPPORTED" | "NO_MATCH" | "CHECKED_PARTIAL_SUCCESS" | "CHECKED_SUCCESS_WITH_NOTES" | "CHECKED_SUCCESS_CLEAR" | "CHECKED_FAILED";
/**
* Different types of checks available.
* Note: WATCHLIST can also cover PEP and/or SANCTION as well, depending on source provider used. GROUP is an internal 'meta-check' to store the group details for an AMLResultSet.
*/
enumBackgroundCheckType: "PEP" | "SANCTION" | "WATCHLIST" | "MEDIA" | "GROUP";
/**
* Current state, based on the most recent check.
* - "CLEAR": The no checks have ever turned up results
* - "PAST_HITS": Past checks have returned hits, but now they're clear.
* - "POSSIBLE_HIT": The most recent checks turned up some results that may be relevant
* - "ACTIVE_HITS": The current checks are returning definitive hits.
*/
enumBackgroundCheckState: "CLEAR" | "PAST_HITS" | "POSSIBLE_HIT" | "ACTIVE_HITS";
/**
* How often these checks run.
*/
enumBackgroundCheckFrequency: "ADHOC" | "YEARLY" | "QUARTERLY" | "MONTHY" | "WEEKLY" | "DAILY";
/**
* Defines how close a match we were able to make based on search results.
* - "LOW": The item does match the minimum criteria given, but is potentially one of a number of possible hits
* - "MEDIUM": The item matches multiple search criteria, but there is still some potential ambiguity with other hits
* - "HIGH": Matches all given search criteria, but there were other potential hits
* - "DEFINITE": Was the only item to match all given search criteria.
*/
enumSearchResultConfidence: "LOW" | "MEDIUM" | "HIGH" | "DEFINITE";
/**
* High level indication of the final disposition of a backgrounded function
* - "COMPLETED": the request completed (not that the final result is a success, just that we completed)
* - "FAILED": the request failed.
* - "INCOMPLETE": could not complete the request.
*/
enumFunctionStatus: "COMPLETED" | "FAILED" | "INCOMPLETE";
/**
* Indicates the type of notification being pushed.
* - "FUNCTION": A request that you previously backgrounded has completed and this is the notification that is it complete (success is another matter)
* - "RESULT": Like the FUNCTION notification, this tells you that a previously backgrounded request has completed, and that there is a set of results in the payload pointer.
* - "EVENT": There has been a stateful change in a document, entity or some other piece of data that we are holding/monitoring for you. This is an indication that you may wish to take some action.
* - "ALERT": Like the EVENT, except that the severity of the notification indicates that action is almost certainly required.
*/
enumNotificationType: "FUNCTION" | "RESULT" | "EVENT" | "ALERT";
/**
* Indicates the status of a check result as set by a user.
* - "UNKNOWN": The user has not decided so the actual check result applies as normal.
* - "TRUE_POSITIVE": The check result has been acknowledged as correct but the final effect (accept/reject) has not been decided.
* - "TRUE_POSITIVE_ACCEPT": The check result is correct but will be ignored. This is also known as 'whitelisting'
* - "TRUE_POSITIVE_REJECT": The check result is correct and will be used.
* - "FALSE_POSITIVE": The check result is not applicable and will be ignored.
* - "STALE": The check result will become invisible, will not be considered
* and will not count towards due diligence requirements.
*/
enumCheckResultManualStatus: "UNKNOWN" | "TRUE_POSITIVE" | "TRUE_POSITIVE_ACCEPT" | "TRUE_POSITIVE_REJECT" | "FALSE_POSITIVE" | "STALE";
/**
* Indicates the type of an entity.
* - "INDIVIDUAL": An individual.
* - "TRUST": A trust.
* - "ORGANISATION": An organisation.
*/
enumEntityType: "INDIVIDUAL" | "TRUST" | "ORGANISATION";
/**
Enum of risk assessment groupings, e.g. customer, device, transaction, AML, PEP as determined by the risk checking service
- CUSTOMER
- DEVICE
- TRANSACTION
- AML
- FRAUD
*/
enumRiskResultType: "CUSTOMER" | "DEVICE" | "TRANSACTION" | "AML" | "FRAUD";
/**
An enumerated list of risk as determined by the checking service
- NONE
- LOW
- MEDIUM
- HIGH
- VERY_HIGH
*/
enumRiskLevelType: "NONE" | "LOW" | "MEDIUM" | "HIGH" | "VERY_HIGH";
/**
The type of payment that the transaction used
- CARD
- BANK
- WIRE
- CRYPTO
- OTHER
*/
enumPaymentType: "CARD" | "BANK" | "WIRE" | "CRYPTO" | "OTHER";
/**
Type of the Activity that has occurred
- REGISTRATION
- LOGIN
- FIAT_WITHDRAWAL
- FIAT_DEPOSIT
- CRYPTO_WITHDRAWAL
- CRYPTO_DEPOSIT
*/
enumActivityType: "REGISTRATION" | "LOGIN" | "FIAT_WITHDRAWAL" | "FIAT_DEPOSIT" | "CRYPTO_WITHDRAWAL" | "CRYPTO_DEPOSIT";
/**
Enum of risk assessment groupings, e.g. customer, device, transaction, AML, PEP as determined by the risk checking service
*/
enumIssueType: "CUSTOMER" | "DEVICE" | "TRANSACTION" | "AML" | "FRAUD";
/**
Current Status of the Case
- PENDING
- APPROVED
- MANUALLY_DECLINED
*/
enumCheckCaseStatus: "PENDING" | "APPROVED" | "MANUALLY_DECLINED";
/**
* Individual key-value pair
*/
KeyValuePairObject: {
/**
* Name of the data
*/
kvpKey?: string;
/**
* Value of the data
*/
kvpValue?: string;
kvpType?: Core["enumKVPType"];
};
/**
* Unique identifier for every request. Can be used for tracking down answers with technical support.
*
* Uses the ULID format (a time-based, sortable UUID)
*
* Note: this will be different for every request.
*/
RequestIDObject: string;
/**
* Provides details of the confidence level we have that this is the item we're looking for.
*/
SearchResultConfidenceObject: {
/**
* Numeric score on a scale of 0 (none) to 100 (as certain as possible) on which the confidence level is based. Whole integers only.
*/
score?: number;
level?: Core["enumSearchResultConfidence"];
/**
* Free-form list of descriptions around any partial matches
*/
notes?: string[];
};
ErrorObject: {
requestId: Core["RequestIDObject"];
/**
* Deprecated:
* HTTP status code. Same as that which is passed back in the header.
*/
httpStatusCode?: number;
/**
* Frankie error code
*/
errorCode: string;
/**
* Will describe the error
*/
errorMsg: string;
/**
* Server version indication
*/
commit?: string;
issues?: {
/**
* Will describe the field or data location of the issue
*/
issueLocation: string;
/**
* Description of the problem
*/
issue?: string;
}[];
};
BasicStatusResultObject: {
requestId: Core["RequestIDObject"];
/**
* Simple message describing the final status of the process. Only to be used in success case responses. Otherwise, use the ErrorObject.
*/
statusMsg: string;
};
/**
* The following fields represent the data you need in order to retrieve the results of the requested function. See the details of the notification API for more.
*/
NotificationResultObject: {
requestId?: Core["RequestIDObject"];
notificationType?: Core["enumNotificationType"];
/**
* Only supplied if the original request was tied to a document. This will be the same ID that was sent in the original acceptance.
*/
documentId?: string;
/**
* Only supplied if the original request was tied to an entity. This will be the same ID that was sent in the original acceptance.
*/
entityId?: string;
/**
* If the entity in entityId above has had an external service ID attached to it in the entity extraData with kvpKey = customer_reference, then this is that kvpValue
*/
entityCustomerReference?: string;
/**
* Short description of the original function called, or function that was triggered.
*/
function?: string;
functionResult?: Core["enumFunctionStatus"];
/**
* If you're calling a processing function of some kind, a check number will be issued. This field will only be present if the function you're calling would normally return a checkId (such as scan, verify, and compare).
*/
checkId?: string;
/**
* URI for resource containing more details about the reason for the notification.
*/
linkReference?: string;
/**
* A brief, human readable message describing the reason for the notification.
*/
message?: string;
/**
* The portal username that initiated the operation that led to this notification. If applicable and available.
*/
username?: string;
};
/**
* When sent a notification or alert, you'll call the /retrive/response/{requestId} function
*
* This will return the original response
*/
RetrievedResponseObject: {
/**
* This will be the HTTP response code that was returned originally (200, 404, etc).
*
* In the case where you're requesting the result of a callback (previously backgrounded call), then this is the response that would have been sent, had you waited for the call to finish.
*/
origHTTPstatus?: number;
/**
* This is a placeholder field. It will actually be a JSON object that is the payload that would have been returned (or was returned) in the original request. You'll need to process this as if it were the original response, and act accordingly.
*/
payload?: {
[key: string]: any;
};
};
/**
* The following fields represent the data you need in order to retrieve the results of the requested function. See the details of the notification API for more.
*/
AcceptedDocumentResultObject: {
requestId?: Core["RequestIDObject"];
/**
* When an ID document is created/uploaded, it is assigned a documentId. You'll see this in a successful response or successfully accepted response. This can then be referenced in subsequent calls if you're uploading more/updated data.
*/
documentId?: string;
/**
* Short description of the function called.
*/
function?: string;
/**
* If you're calling a processing function of some kind, a check number will be issued. This field will only be present if the function you're calling would normally return a checkId (such as scan, verify, and compare).
*/
checkId?: string;
};
/**
* the document to be attached and optionally scanned (if supported)
*/
ScannedDocumentObject: {
/**
* When an document scan is created/uploaded, it is assigned a scanDocId. You'll see this in a successful response or successfully accepted response. This can then be referenced in subsequent calls if you're uploading more/updated data.
*/
scanDocId?: string;
scanType?: Core["enumScanType"];
scanSide?: Core["enumScanSide"];
/**
* If you're uploading a file where it's important to keep the original filename, then you can provide that here. Otherwise the Frankie service will assign an arbitrary name based on the scanDocIdand an extension based on the MIME type
*/
scanFilename?: string;
/**
* If uploading multiple pages - it's handy to keep a track of these. There is no enforcement of these numbers at all. You can have 10 page 1's and a page 29 if you wish.
*/
scanPageNum?: number;
scanMIME?: Core["enumMIMEType"];
/**
* Used as a way of indicating to the service that the original scanned document is not to be kept after it has been processed. We will retain any metadata and the results of processing (where required by regulation or the customer), but the original file uploaded will eventually be remnoved once processing is complete.
*
* If ScanDelete is set to true, any call with /full at the end will still not return the file contents, regardless of whether the file has been deleted yet (the deletion process is a background task that can take a few minutes to occur)
*/
ScanDelete?: boolean;
/**
* Base64 encoded string of a photo or scan of an ID document to be verified. If supplied and of a supported type, the Frankie service will attempt to use OCR tech to extract the data from the scanned doc/image.
*
* In a result message, this field will be left blank, unless the "full" action is requested.
*/
scanData?: string;
scanDataRetrievalState?: Core["enumScanDataRetrievalState"];
/**
* The date and time the scan was created. Not the date of the scanned document, which should be in the idIssued attribute of the document that owns this scan.
*/
scanCreated?: string;
};
IdentityDocumentObject: {
/**
* When an ID document is created/uploaded, it is assigned a documentId. You'll see this in a successful response or successfully accepted response. This can then be referenced in subsequent calls if you're uploading more/updated data.
*/
documentId?: string;
idType: Core["enumIdType"];
/**
* The sub-type of identity document. Very document specific.
*/
idSubType?: string;
/**
* The ISO-3166-alpha3 country code of the issuing national. Once set, this cannot be changed.
*
* See https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes for more
*/
country: string;
/**
* Regional variant of the ID (e.g. VIC drivers licence)
*
* You should always use the local abbreviation for this.
* E.g.
* - VIC for The Australian state of Victoria
* - MA for the US state of Massachusetts
* - etc
*/
region?: string;
/**
* The ID number of the document (if known).
*/
idNumber?: string;
/**
* The expiry date of the document (if known) in YYYY-MM-DD format.
*/
idExpiry?: string;
/**
* The issued date of the document (if known) in YYYY-MM-DD format.
*/
idIssued?: string;
documentStatus?: Core["enumDocumentStatus"];
/**
* This document's data was initially created from scanned and processed images. The value cannot be set manually and any attempt to do so will just be ignored.
*/
createdFromScan?: boolean;
/**
* If this document was originally populated from scanned data, then manually adjusted (e.g. if the scan's results weren't 100% correct or data was missing), then this will be set to true. The value cannot be set manually and any attempt to do so will just be ignored.
*/
manuallyModified?: boolean;
/**
* Set of key-value pairs that provide ID type-specific data. If updating an existing document, then existing values with the same name will be overwritten. New values will be added.
*
* If this document is scanned through OCR or similar processes, then extracted data will be found here (Some may be used to populate other fields like idNumber and idExpiry as well)
*/
extraData?: Core["KeyValuePairObject"][];
/**
* Collection of one or more objects that describe scan(s) that need to be put through OCR or facial recognition. These should all be from the one ID document, such as front/back, or page 1, 2, 3, etc. You can upload multiple scans in a single call, or in multiple calls.
*
* Note: if you do upload over multiple calls, make sure you include the documentId (see above), and indicate that this is happening with a "more_data" checkAction
*/
docScan?: Core["ScannedDocumentObject"][];
};
/**
* This is the document that we want to compare to the original toDocument.
*
* In the case of a selfie-check against a drivers licence:
*
* * compareDocument will be the the selfie
* * toDocument will be the drivers licence photo
*/
ComparisonSet: {
compareDocument?: Core["IdentityDocumentObject"];
toDocument?: Core["IdentityDocumentObject"];
};
/**
* This is the document we wish to verify in some way, along with an entity object that contains some/all of the details we wish to verify.
*
* For example, if we're attempting to verify a drivers licence, we generally need to pass in a name, address, DoB, etc as well. the entity gives the structure to be able to do this.
*
* Note, only the document in the "document" parameter is to be processed. any additional documents found in the entity (there shouldn't be, but given the way this has been defined, there can be) will be ignored. Only the Name, Address, DoB and Gender fields will be potentially used during the verification process.
*
* The EntityObject can take one of two forms.
*
* - It can be a single entityId - in which case the details will be pulled from the database. If using an existing document, then the entity must also own the document or the request will fail.
* - You can supply a "single use" entity with fields, etc. In this case the entity details will be used to verify the document, then will be discarded.
*
* If you wish to save the entity, use the /entity comments instead to create the entity and attach the document there.
*/
DocumentVerify: {
document?: Core["IdentityDocumentObject"];
entityData?: Core["EntityObject"];
};
/**
* Collection of fraud check results for the entity.
*
* Contains fraud list and/or background result arrays. Other fraud check types will appear over time
*/
FraudCheckResultObject: {
fraudListResults?: Core["ProcessResultObject"][];
fraudBackgroundCheckResults?: Core["ProcessResultObject"][];
};
/**
* Stores the generic results of a process (check, scan, compare, verify, etc)
*/
ProcessResultObject: {
checkId?: Core["CheckIDObject"];
/**
* Short indication of the type of check that was done.
*
* When used as a summary, it will the the checkType that was requested
*
* For granular results, it will be the individual check performed.
*/
checkType?: string;
resultState?: Core["enumCheckResultState"];
/**
* Any additional notes that may relate to the state. These are returned as typed KVPs
*/
resultNotes?: Core["KeyValuePairObject"][];
/**
* The date and time the item was checked to provide this result.
*/
checkDate?: string;
/**
* Confidence in the result on a scale of 0 (no match) to 100 (strong/identical match). Whole integers only.
*
* Negative values are used to indicate untrusted results.
*/
confidenceLevel?: number;
/**
* Only supplied in a summary result. Used to indicate the ovall risk score for the entity at this point in time, based on configurable rules.
*
* Some examples might include:
*
* * Current level of ID checks passed
* * Device ID scores
* * Current PEP/Sanctions/etc checks
* * Jurisdictional risk based on addresses, documents and other KVPs
* * Fraud check results
*
* In this case a higher score is a bad thing. General rule of thumb:
*
* * 0 - 30 = Low Risk
* * 31 - 50 = Medium Risk
* * 50 - 75 = High Risk
* * 75+ = Unacceptable
*/
riskLevel?: number;
/**
* Service provider that performed the check. Basically the name of the connector, without the leading con_
*/
checkPerformedBy?: string;
/**
* Code that can be used to determine the underlying nature or data source of the checks performed. This may or may not be known by the connector, or may be a provider specific type (e.g. type "O")
*
* Note, this will actually be normalised by the core service into a standfardised result so that we're not accidentally counting sources twice.
* Original source will then be copied into the KVPs
*/
checkSource?: string;
/**
* The service provider will give us a receipt, transaction id, check number, or some such that gives us a unique id on their side that we can reconcile with
*/
providerCheckID?: string;
};
/**
* The result of a scan will contain 4 parts
*
* * The requestid - that's always there, and is the same that was passed in in the header.
*
* * The results of the process and the meta data around it, including confidence levels, service used and the like
*
* * extractedDocument - this will be an updated version of the document object passed in for scanning with results of the scan inserted. You can subsequently update this data as needed (say after confirmation with the end-consumer) through the various update functions.
*
* * Any additional data extracted from the service that does not fit into the standard identity document fields will be placed into the extraData KVPs.
*
* * extractedEntity - the service will attempt to create the basics of an entity's name, address, DoB, gender from the data returned from the scan.
* You can then use this entity data to create a new entity for a wider check if needed.
*
* * Note if you plan on doing this, make sure you include the extractedDocument reference in the "new" entity.
*
* * EXTRA SPECIAL NOTE: If no useful data was returned in the scan, extractedDocument will be left unchanged, and extractedEntity will be left out
*/
DocumentScanResultObject: {
requestId: Core["RequestIDObject"];
extractedDocument?: Core["IdentityDocumentObject"];
extractedEntity?: Core["EntityObject"];
processResult: Core["ProcessResultObject"];
};
/**
* Contains the details of a check on a given data point
*/
DocumentVerificationResultObject: {
/**
* This is a direct copy from the document object passed in for verifcation.
*/
documentId?: string;
processResult?: Core["ProcessResultObject"];
};
/**
* Contains the results of a given document upload.
*/
DocumentVerifyResultObject: {
requestId: Core["RequestIDObject"];
documentVerificationResults?: Core["DocumentVerificationResultObject"];
};
/**
* Contains the details of a comparison between two documents
*/
DocumentComparisonResultObject: {
/**
* This is a direct copy from the compareDocument object passed in the request. You MUST supply this.
*/
compareDocumentId?: string;
/**
* This is a direct copy from the toDocument object passed in the request. You MUST supply this.
*/
toDocumentId?: string;
processResult?: Core["ProcessResultObject"];
};
/**
* Contains the results of a given document upload.
*/
DocumentCompareResultObject: {
requestId: Core["RequestIDObject"];
documentComparisonResults: Core["DocumentComparisonResultObject"];
};
/**
* Contains the results of a given document upload.
*/
DocumentChecksResultObject: {
requestId: Core["RequestIDObject"];
checkResults?: Core["IdentityDocumentCheckResultObject"];
};
/**
* Contains the individual search results for a document.
*/
DocumentSearchResultListItem: {
confidence?: Core["SearchResultConfidenceObject"];
document?: Core["IdentityDocumentObject"];
};
/**
* Contains the results of a given document search.
*/
DocumentSearchResultObject: {
requestId: Core["RequestIDObject"];
/**
* The list of (potentially) matching documents with confidence levels.
*
* If you are the "owner" of the document - i.e. the same CustomerID and CustomerChildID (if relevant) - then the full details of the document will be returned, except for the contents of any attached scans.
* If you are not the owner of the document, then just the ID and confidence level is returned. You can still use this ID to retrieve any check results (see GET /document/{documentId}/checks)
*/
documentSearchResults?: Core["DocumentSearchResultListItem"][];
};
/**
* Utility industry comparison process result object. Used to wrap up industry-specific resultsets.
*/
DocumentIndustryUtilityProcessResultObject: {
industryProcess?: string;
requestId?: Core["RequestIDObject"];
/**
* The document that was used to generate these results.
*/
documentId?: string;
/**
* The utility comparison service can return either an error response or a result.
*
* One of error or result will be returned in this case, the other will either be a nil value, or not supplied.
*/
utilityCompareResult?: {
error?: Core["ComparisonError"];
result?: Core["ComparisonResponse"];
};
};
/**
* Utility industry explicit consent response object. Used to wrap up industry-specific resultsets.
*/
DocumentIndustryUtilityConsentResultObject: {
industryProcess?: string;
requestId?: Core["RequestIDObject"];
/**
* The document that was used to generate these results.
*/
documentId?: string;
/**
* The utility consent service can return either an error response or a result.
*
* One of error or result will be returned in this case, the other will either be a nil value, or not supplied.
*/
utilityConsentResult?: {
error?: Core["EICError"];
result?: Core["EICResponse"];
};
};
/**
* Utility industry comparison process result object. Used to wrap up industry-specific resultsets.
*/
DocumentIndustryUtilitySwitchResultObject: {
industryProcess?: string;
requestId?: Core["RequestIDObject"];
/**
* The document that was used to generate these results.
*/
documentId?: string;
/**
* The utility switching service can return either an error response or a result.
*
* One of error or result will be returned in this case, the other will either be a nil value, or not supplied.
*/
utilitySwitchResult?: {
error?: Core["SwitchError"];
result?: Core["SwitchResponse"];
};
};
ComparisonError: {
/**
* The correlationId as passed in the request
*/
correlationId: string;
/**
* Timestamp of when the attempted comparison took place
*/
comparisonDate: string;
/**
* * `1000` - Document not recognised (i.e. not valid pdf or image)
* * `1001` - Bill is not SME or Domestic
* * `1004` - Bill is gas (if to be excluded)
* * `1005` - Template Not Found – The document was a pdf but service did not recognise the uploaded document against any of it’s templates
* * `1008` - Unsupported distributor – bill is from jurisdiction that is unsupported
* * `1009` - Unsupported distributor – bill is from jurisdiction that is unsupported
* * `1030` - Invoice from date is missing
* * `1031` - Invoice to date is missing
* * `1033` - Supply address is missing
* * `1039` - NMI is missing
* * `1041` - Bill is a predictive plan making comparison hard
* * `1044` - Bill is on embedded network
* * `1045` - Incompatible charge item – manual comparison needed
* * `1062` - C&I Bill loaded
* * `1080` - API failed to reconcile bill usually meaning that not all cost items were picked up
*/
errorCode: number;
/**
* Description of error that can be displayed as user feedback. e.g. "Uploaded document not a PDF"
*/
message: string;
/**
* Version of the API on which the error took place. This value should be reported with any issue raised.
*/
version: string;
};
ComparisonResponse: {
/**
* The correlationId as passed in the request
*/
correlationId: string;
/**
* Timestamp of when the comparison took place
*/
comparisonDate: string;
/**
* Array of plans, sorted from best to worst saving, for the uploaded bill
*/
plans: Core["Plan"][];
currentBillData: Core["CurrentBillData"];
/**
* What is the maximum saving that can be achieved if the user switches to a new plan. This number may be negative if the user is already on the best plan for their usage and no saving can be found.
*/
maximumSaving: number;
defaultOffer: Core["DefaultOffer"];
/**
* Optional disclaimer statment
*/
marketDisclosure?: {
/**
* Name of this section when rendering
*/
name?: string;
/**
* Disclaimer text
*/
value?: string;
};
/**
* Version of the API on which the comparison took place. This value should be reported with any issue raised.
*/
version: string;
};
EICRequest: {
/**
* Correlation ID as passed to comparison request
*/
correlationId: string;
/**
* Unique ID of plan, selected from comparison results
*/
planId: string;
details?: Core["EICDetails"];
};
EICError: {
/**
* The correlationId as passed in the request
*/
correlationId: string;
/**
* * `400` - The request was malformed
* * `422` - Invalid request parameter
*/
errorCode: number;
/**
* Text to provide more details on errorCode
*/
message: string;
/**
* Version of the API on which the EIC request took place. This value should be reported with any issue raised.
*/
version: string;
};
EICResponse: {
/**
* The correlationId as passed in the request
*/
correlationId: string;
plan: Core["Plan"];
/**
* Hierarchical list of objects for rendering EIC statement and Terms and Conditions
*/
eic: Core["DisplayMarkUp"][];
/**
* Version of the API on which the EIC request took place. This value should be reported with any issue raised.
*/
version: string;
};
SwitchRequest: {
/**
* Correlation ID as passed to comparison request
*/
correlationId: string;
details: Core["SwitchDetails"];
/**
* Array of strings containing all the keys of the elements that required confirmation in the EIC. The absence of any key for a mandatory confirmation will result in an error response.
*/
confirmation?: string[];
};
SwitchError: {
/**
* The correlationId as passed in the request
*/
correlationId: string;
/**
* * `400` - The request was malformed
* * `422` - Invalid request parameter
*/
errorCode: number;
/**
* Text to provide more details on errorCode
*/
message: string;
/**
* Version of the API on which the switch response took place. This value should be reported with any issue raised.
*/
version: string;
};
SwitchResponse: {
/**
* The correlationId as passed in the request
*/
correlationId: string;
/**
* A unique reference for this switch request
*/
reference: string;
/**
* Timestamp of switch request
*/
switchDate: string;
plan: Core["Plan"];
/**
* Hierarchical list of objects for rendering the next steps
*/
nextSteps?: Core["DisplayMarkUp"][];
/**
* Version of the API on which the switch request took place. This value should be reported with any issue raised.
*/
version: string;
};
/**
* All information associated with a given plan
*/
Plan: {
/**
* Unique identifier for this plan. This ID is passed when calling the switch API.
*/
id: number;
/**
* Name of the plan
*/
name: string;
retailer: Core["Retailer"];
/**
* Estimated cost of this plan, based on the usage from uploaded bill, with all conditional discounts applied.
*/
estimatedTotalCost: number;
/**
* Estimated cost of this plan, based on the usage from the uploaded bill, with no conditional discounts applied. If this plan offers no conditional discounts the estimatedTotalCost and the estimatedBaseCost will be the same.
*/
estimatedBaseCost: number;
/**
* The estimated saving the customer could have realised if they had been on this plan during the billing period
*/
estimatedSaving: number;
rates: Core["Rates"];
/**
* The type of energy plan
* * `SR` - Single Rate
* * `TOU` - Time Of Use
*/
type: "SR" | "TOU";
/**
* Link to BPID (Basic Plan Information Document (NSW, SA, QLD, ACT)) or EPFS (Energy Price Fact Sheet (VIC))
*/
url: string;
/**
* Default Offer (DMO/VDO) text to be displayed for this plan
*/
defaultOfferMessage: string;
/**
* Is pay on time required in order to subscribe to this plan
*/
payOnTimeRequired: boolean;
/**
* Is payment by direct debit required in order to subscribe to this plan
*/
directDebitRequired: boolean;
/**
* Conditional discounts that may be applied to plan. These values can be used to modify the estimatedBaseCost for client-side filtering and reordering.
*/
discounts?: {
/**
* Pay On Time discount amount
*/
payOnTime?: number;
/**
* Direct Debit discount amount
*/
directDebit?: number;
};
benefits?: Core["Benefits"];
contract?: Core["Contract"];
conditions?: Core["Conditions"];
paymentOptions?: Core["NameValue"];
greenOptions?: Core["NameValue"];
feesAndCharges?: Core["Fees"];
};
/**
* Data from uploaded bill
*/
CurrentBillData: {
/**
* Customer name.
*/
accountName: string;
/**
* Account (Billing) address.
*/
accountAddress: string;
/**
* Supply address. This may differ from account address if bill payers address is different from account address.
*/
supplyAddress: string;
retailer: Core["Retailer"];
/**
* National Meter identifier (NMI)
*/
nmi: string;
/**
* Customer account number
*/
accountNumber: string;
/**
* * `E` - Electricity
*/
fuelType: "E";
/**
* Start date for billing period
*/
billDateFrom: string;
/**
* End date for billing period
*/
billDateTo: string;
/**
* Number of days in billing period (billDateTo - billDateFrom)
*/
days: number;
/**
* Recalculated cost of the plan based on users comsumption and plan rates including discounts, rebates, concessions etc... Additional fees such as credit card processing fees are ignored.
*/
actualPlanTotalCost: number;
/**
* Total value of all unconditional discounts applied to the bill
*/
discount: number;
/**
* Rates and charges for each period on the bill
*/
periods: Core["Period"][];
/**
* Array of rates and charges for solar on the bill, by period. If no solar is present on the uploaded bill this object will not be present.
*/
solar?: {
/**
* Solar rate from bill
*/
rate?: number;
/**
* Solar value from bill
*/
value?: number;
}[];
};
/**
* A comparison to the default offer (VDO/DMO) must displayed for each plan. This object contains the title and the message for that presentation. Please refer to the layout guidelines for more information.
*/
DefaultOffer: {
/**
* Title/Header for the default offer when presented to the user.
*/
name?: "Default Market Offer (DMO)" | "Victorial Default Offer (VDO)";
/**
* Text containing the default offer comparison with the current plan
*/
value?: string;
};
/**
* Retailer details
*/
Retailer: {
/**
* Unique identifier for the retailer
*/
id: number;
/**
* Name of the retailer
*/
name: string;
/**
* Contact phone number for retailer customer support/queries
*/
phone?: string;
/**
* Contact email address for retailer cusomter support/queries
*/
email?: string;
};
/**
* Plan benefits to be displayed to customer
*/
Benefits: {
/**
* Name of this section when rendering
*/
name: string;
/**
* Discounts available for this plan
*/
discounts: {
/**
* Name of the discount.
*/
name?: string;
/**
* Value of the discount. This can either be a dollar amount (starting with $) or a percentage (ending with %)
*/
value?: string;
/**
* Conditions applied to discount
*/
condition?: string;
}[];
/**
* Inventives available for this plan
*/
incentives: {
/**
* Name of the incentive
*/
name?: string;
/**
* Description of incentive
*/
value?: string;
}[];
};
/**
* Plan conditions to be displayed to customer
*/
Conditions: {
name: string;
value: Core["NameValue"][];
};
/**
* Plan fees and other charges to be displayed to customer
*/
Fees: {
/**
* Name of this section when rendering
*/
name: string;
/**
* Fee information for the plan
*/
value: Core["NameValueDescription"][];
/**
* Any additional fee information for the plan
*/
additionalFeeInfo?: string;
};
/**
* Plan rates to be displayed to customer
*/
Rates: {
/**
* Name of this section when rendering
*/
name?: string;
/**
* Rates for this plan
*/
value?: Core["NameValueUnit"][];
};
/**
* Plan contract details to be displayed to customer
*/
Contract: {
/**
* Name of this section when rendering
*/
name: string;
/**
* Contract details for this plan
*/
value: Core["NameValue"][];
};
RateValue: {
rate: number;
value: number;
};
/**
* Name/Value pair
*/
NameValue: {
name: string;
value: string[];
};
/**
* Name/Value pair
*/
NameValueDescription: {
name: string;
value: string;
description: string;
};
NameValueUnit: {
/**
* Name of this property.
*/
name: string;
/**
* Value of this property.
*/
value: string;
/**
* Unit of measure for this property.
*/
unit: string;
};
/**
* Rates, by period, for the uploaded bill
*/
Period: {
peak?: Core["RateValue"];
peakStep1?: Core["RateValue"];
peakStep2?: Core["RateValue"];
peakStep3?: Core["RateValue"];
offPeak?: Core["RateValue"];
offPeakStep1?: Core["RateValue"];
offPeakStep2?: Core["RateValue"];
shoulder?: Core["RateValue"];
controlledLoad1?: Core["RateValue"];
controlledLoad2?: Core["RateValue"];
supplyCharge?: Core["RateValue"];
};
DisplayMarkUp: {
/**
* Type of component to be used for rendering
*/
type?: "text" | "unorderedlist" | "orderedlist";
/**
* Text to display as header/title of value.
*/
name?: string;
/**
* Data to be rendered. This data can contain data bindings (contained in {{ }}). If present in the string the parameters object will contain a key with the same name and the associated data (e.g a link).
{
"type": "text",
"value": "I accept the {{Terms and Conditions}}.",
"parameters": {
"Terms and Conditions": {
"type": "link",
"value": "https://www.accurassi.com.au/sample-terms-and-conditions/"
}
}
}
*/
value?: string;
/**
* For elements that require confirmation, the key of each element that the user has accepted must be send in the switch request. The absence of any mandatory confirmation will result in an error response from the switch request.
*/
key?: string;
/**
* Comma seperated list of attributes to apply to value when rendering.
*/
attribute?: "bold";
/**
* Does this statement need to be confirmed (with a checkbox)? Confirmation can be mandatory or optional. When the confirmation element is present a key element must also be present. The keys of all confirmed statements must be sent in the switch request. The absence of any mandatory confirmation will result in an error response from the switch request.
*/
confirmation?: "optional" | "mandatory";
/**
* Optional element which has a keyvalue pair associated with every data binding contained in the value element of the current object.
*/
parameters?: {
[key: string]: object;
};
/**
* Children of element. This data structure is recursive with a DisplayMarkup element having 0 or more DisplayMarkup children
*/
children?: Core["DisplayMarkUp"][];
};
/**
* Information for the residents of the property being supplied
*/
EICDetails: {
/**
* Vulnerability information for residents of the property being supplied
*/
vulnerabilities?: {
/**
* Is anyone in the property dependent on electricity for life support equipment?
*/
dependencyType: "Life Support" | "Sensitive Load";
};
/**
* Customer concession card details
*/
concessionCard?: {
/**
* Customer Reference Number (CRN) on the concession card
*/
customerReferenceNumber: string;
/**
* The type of evidence used to prove eligibility for concessions
*/
concessionEvidenceType: "Pensioner Concession Card" | "Gold Repatriation Health Card" | "Health Care Card" | "NSW Life Support Rebate Without Concession Card" | "Queensland Seniors Card";
/**
* Concession card start date
*/
startDate: string;
/**
* Concession card end expiry date
*/
endDate: string;
/**
* First name on the concession card
*/
firstName: string;
/**
* Last name on the concession card
*/
lastName: string;
/**
* Concessions linked to the customer's concession card
*/
concessionType: "Life Support" | "Medical Cooling" | "Service to Property Charge" | "Off-Peak Electricity" | "Annual Electricity" | "Transfer Fee Waiver" | "Excess Electricity" | "Controlled Load" | "Low Income Household" | "Medical Energy" | "NSW Government Life Support Rebate" | "Queensland Electricity Rebate" | "Winter Gas" | "Excess Gas Consumption";
};
};
Passport: {
/**
* Document identifier
*/
type: "passport";
/**
* Passport Number
*/
number: string;
/**
* Country of Issue
*/
country: string;
/**
* Expiry date of passport
*/
expiryDate?: string;
};
DriversLicence: {
/**
* Document identifier
*/
type: "driverslicence";
/**
* Drivers Licence Number
*/
number: string;
/**
* State of Issue
*/
state: string;
/**
* Expiry date of drivers licence
*/
expiryDate?: string;
};
MedicareCard: {
/**
* Document identifier
*/
type: "medicare";
/**
* Medicare Card Number
*/
number: string;
/**
* Medicare Card Reference Number
*/
referenceNumber?: string;
/**
* Middle Name on Card
*/
middleName?: string;
/**
* Expiry date of drivers licence
*/
expiryDate: string;
/**
* Card color
*/
cardColor?: "green" | "blue" | "yellow";
};
/**
* Details required to switch retailers
*/
SwitchDetails: {
/**
* Customer's details required to switch retailers
*/
customerDetails: {
/**
* Name of customer switching
*/
name: {
/**
* Customers title (e.g. Mr, Mrs, Miss, Dr)
*/
title: string;
/**
* Customer's first name
*/
first: string;
/**
* Customer's middle name
*/
middle?: string;
/**
* Customer's last name
*/
last: string;
};
/**
* Customer's supply address address. If no address is passed, the supply address as read off the bill will be used
*/
address?: string;
/**
* Customer's email address
*/
email: string;
/**
* Customer's phone number
*/
mobile: string;
/**
* Customer's date of birth
*/
dateOfBirth: string;
/**
* Allows a user to select one of the following forms of ID to validate against:
*
* - Passport
* - Drivers Licence
* - Medicare card
*/
evidenceOfIdentity: {
Passport?: Core["Passport"];
DriversLicence?: Core["DriversLicence"];
MedicareCard?: Core["MedicareCard"];
};
};
};
/**
* Contains the results of a given document upload.
*/
DocumentResultObject: {
requestId: Core["RequestIDObject"];
document: Core["IdentityDocumentObject"];
};
/**
* The following fields represent the data you need in order to retrieve the results of the requested function. See the details of the notification API for more.
*/
AcceptedEntityResultObject: {
requestId?: Core["RequestIDObject"];
/**
* When an entity is created/uploaded, or generated from a document scan, it is assigned an entityId. This can then be referenced in subsequent calls if you're uploading more/updated data.
*/
entityId?: string;
/**
* Short description of the function called.
*/
function?: string;
/**
* If you're calling a processing function of some kind, a check number will be issued. This field will only be present if the function you're calling would normally return a checkId (such as scan, verify, and compare).
*/
checkId?: string;
/**
* Optional link that can be returned - used by the Push To Mobile service to allow API users to manage the use of the onboarding link themselves.
*/
linkURL?: string;
};
/**
* Similar to a KVP, the flag has a key (the flag you're indicating) and an integer value.
*
* Values are tied to the specific flag (see table below). Generally they're true (1)/false(0) indicators.
*
* | flag | values | Description |
* | ------- | -------- | -------- |
* | ongoing_pep | 0, 1, 2 | 0 = no, 1 = pep/sanctions, 2 = 1+media |
* | | | |
*/
EntityFlagObject: {
/**
* Name of the flag
*/
flag?: string;
/**
* flag value.
*/
value?: number;
};
PersonalNameObject: {
/**
* Mr/Ms/Dr/Dame/Dato/etc.
*/
honourific?: string;
/**
* Family name / Surname of the individual.
*/
familyName: string;
/**
* First / Given name
*/
givenName?: string;
/**
* Middle name(s) / Initials
*/
middleName?: string;
/**
* In some cases, the name will need to be supplied in "long form", such as when it is determined from a document scan, or is un-parsable in some way.
* The service will attempt to convert it to it's constituent parts where possible.
*/
displayName?: string;
};
DOBObject: {
/**
* Year of birth or "unknown". This will be autoextracted if dateOfBirth is supplied.
*/
yearOfBirth?: string;
/**
* Date of Birth in YYYY-MM-DD format
*/
dateOfBirth?: string;
/**
* Place of birth other than country If locality is given, then country must also be provided.
*/
locality?: string;
/**
* ISO-3166-1 code for the country of birth. You must use the alpha3 country code (e.g. AUS, USA, IDR, KOR, etc) We'll convert as needed.
*
* See https://en.wikipedia.org/wiki/ISO_3166-1
*/
country?: string;
};
AddressObject: {
/**
* As addresses are added to an entity, they're assigned an id to assist with tracking.
*
* If you're adjusting an address, you will need to include the addressId so as to be able to reference it correctly in the list.
*/
addressId?: string;
addressType?: Core["enumAddressType"];
/**
* The date this address first because active. Used mostly with business addresses.
*/
startDate?: string;
/**
* The date this address was no longer used (if available). Used mostly with business addresses.
*/
endDate?: string;
/**
* Individual or business name at this address if not the same as the name of the entity to which this address belongs.
*/
careOf?: string;
/**
* Unit/Apartment/Flat/Suite/etc number
*/
unitNumber?: string;
/**
* The number on the street. Generally a number, but can also be alphanumeric (e.g. 3A)
*/
streetNumber?: string;
/**
* The name of the street
*
* This field can in fact be a bit flexible, potentially containing the streetNumber and streetType as well. Most services in use can work it out.
*
* If this field has been auto-populated by Google (see writeup here:
* https://help.frankiefinancial.com/hc/en-au/articles/900001754546-Additional-Data-Notes-Addresses
*
* If you can avoid it though, please try and keep things separate.
*/
streetName?: string;
/**
* The street "type" - e.g. Road, St, Ave, Circuit, etc
*/
streetType?: string;
/**
* The name of the building, apartment block, condo, etc
*/
buildingName?: string;
/**
* The suburb in the town/city. Only use this if you require a suburb AND a town/city, otherwise, just use the "town" parameter.
*/
suburb?: string;
/**
* The town/village/suburb/city
*/
town?: string;
/**
* The county, province, cantonment
*/
region?: string;
/**
* The state. Use local abbreviations, such as VIC(toria) or TX (Texas)
*/
state?: string;
/**
* The ISO-3166-1 country. You must use the alpha3 country code (e.g. AUS, USA, IDR, KOR, etc) We'll convert as needed.
*
* See: https://en.wikipedia.org/wiki/ISO_3166-1
*/
country: string;
/**
* The post code of the address.
*/
postalCode?: string;
/**
* In some cases, the address will need to be supplied in "long form", such as when it is determined from a document scan, or is un-parsable in some way.
* The service will attempt to convert it to it's constituent parts where possible.
*
* WARNING: Use of longForm is not guaranteed to produce perfect results, due to the variety of potential formats. You've been warned.
* Failure to break down or disambiguate the address will result in an error.
*/
longForm?: string;
};
/**
* Describes all of the data being used to verify an entity.
*/
EntityObject: {
/**
* When an entity is first created, it is assigned an ID. When updating an entity, make sure you set the entityId
* One exception to this is when an entity is created from a document object. It is expected that this object would be passed into a /check or /entity call to set it.
*/
entityId?: string;
entityType?: Core["enumEntityType"];
/**
* If the entity is using the new profiles feature, then their profile name will be found here.
*
* Note: If setting a profile, you must ensure that the profile matches a known configuration.
*
* Please contact Frankie developer support if you're unsure as to what valid values are.
*/
entityProfile?: string;
name?: Core["PersonalNameObject"];
dateOfBirth?: Core["DOBObject"];
gender?: Core["enumGender"];
/**
* Collection of address objects.
*/
addresses?: Core["AddressObject"][];
/**
* Used to set additional information flags with regards to this entity and for ongoing processing.
*
* Flags might include having the entity (not) participate in regular pep/sanctions screening
* Others will follow over time.
*/
flags?: Core["EntityFlagObject"][];
/**
* Set of key-value pairs that provide arbitrary additional type-specific data. You can use these fields to store external IDs, or other non-identity related items if you need to.
* If updating an existing entity, then existing values with the same name will be overwritten. New values will be added.
*
* See here for more information about possible values you can use:
* https://help.frankiefinancial.com/hc/en-au/articles/900001758123-Entity-extraData-Specific-Examples
*/
extraData?: Core["KeyValuePairObject"][];
/**
* Collection of identity documents (photos, scans, selfies, etc)
*/
identityDocs?: Core["IdentityDocumentObject"][];
organisationData?: Core["OrganisationDataObject"];
};
/**
* Contains any/all details we want to pass on to the device/biometric checking service as part of an activity / transaction. A transaction isn't just a payment, but can represent a number of different interaction types. See below for more.
*/
DeviceCheckDetailsObject: {
/**
* Describes the type of check service we need to verify with. Choices are:
*
* - DEVICE: Services that will be checking device characteristics
* - BIOMETRIC: Services that will be checking biomentric characteristics
*/
checkType?: "DEVICE" | "BIOMETRIC";
/**
* The type of activity we're checking. Choices are:
*
* - SIGNUP: Used when an entity is signing up to your service
* - LOGIN: Used when an already registered entity is logging in to your service
* - PAYMENT: Used when you wish to check that all is well for a payment
* - CONFIRMATION: User has confirmed an action and you wish to double check they're still legitimate
*
* You can also supply vendor specific activityTypes if you know them. To do this, make the first character an underscore _.
* So for example, to use BioCatch's LOGIN_3 type, you can send "_LOGIN_3" as a value. Note, if you do this, there is no error checking on the Frankie side, and thus if you supply an incorrect value, the call will fail.
*/
activityType?: "SIGNUP" | "LOGIN" | "PAYMENT" | "CONFIRMATION" | "_";
/**
* the unique session based ID that will be checked against the service.
*/
checkSessionKey?: string;
/**
* Collection of additional data points you wish to add to the activity check. These are defined in conjunction with the Customer and the device checking service being used.
*
* Standard values are supplied upon request:
*
* | kvpKey | kvpType | kvpValue |
* | ------- | -------- | -------- |
* | detectedIp | general.string | The IP address you detect the transaction coming from |
* | accountId.src | id.external | Your account identifier. Can be a SHA hash or similar |
* | accountId.dst | id.external | Target/payee account identifier. Can be a SHA hash or similar |
* | entityId | id.external | Use this to override the Frankie entityID that would be used to identify |
* | amount | general.float | Amount involved in the transaction |
* | platform | general.string | One of APP, WEB, MOBILE_WEB. Assumes APP if not supplied |
* | | |
*
*
* Like the activityType, you can also specify vendor specific additional data parameters by adding a leading underscore "_" to the kvpKey. You can set the kvpType to one of the available types, or just use general.string (recommended)
*/
additionalData?: Core["KeyValuePairObject"][];
};
/**
* Contains all the details we'll check regarding an Entity. It is assumed that this will grow over time.
*
* Current supported check parameters:
*
* - entity: The Entity we're checking. This must be supplied.
* - deviceCheckDetails: |
* An optional array of parameters for us to check the device and biometric characteristics against. This may map to a session key or device identifier, along with additional information that we can use to check against services like ThreatMetrix, BioCatch (or whatever has been configured for the Customer)
*/
EntityCheckDetailsObject: {
entity: Core["EntityObject"];
deviceCheckDetails?: Core["DeviceCheckDetailsObject"][];
};
/**
* Contains all the details we need to create/update an entity and generate an IDV token
*/
EntityIDVDetailsObject: {
entity: Core["EntityObject"];
/**
* The applicantId previously supplied when creating a token for the first time for an entity.
* Only required if re-submitting for a fresh token on a previously created applicant.
*/
applicantId?: string;
/**
* If this is for a native application SDK, then we need the applicationId as reported by the SDK. This will then be tied to the token so it cannot be used in another application or handset.
*
* You must send either an applicationID or a referrer (see below)
*/
applicationId?: string;
/**
* If this is for a web SDK, then you need to supply the referrer domain so that the token can be validated by the IDV service
*
* You must send either a referrer or an applicationID (see above)
*/
referrer?: string;
};
/**
* Contains the results of a check against an entity profile.
*
* The entityProfileResult will be returned instead of a checkSummary to provide the full details of the verification process.
*/
EntityProfileResultObject: {
/**
* Unique ID for the entity.
*/
entityId?: string;
checkId?: Core["CheckIDObject"];
/**
* The name of the profile used for this check.
*/
profileName?: string;
/**
* The name of the policy within the profile used for this check. This may or may not incorporate the 'riskPolicy' that is also an attribute in this object.
*/
policyName?: string;
/**
* The date and time of the last check that contributed to this result.
*/
latestCheckDate?: string;
/**
* Comma separated list of checks required for the entity profile.
*/
checkType?: string;
/**
* The basic result for each check type required for the profile.
*
* The results are listed in the order they are run so you can also see how far progressed through a check process you are.
*/
checkResults?: Core["EntityProfileCheckResultMessage"][];
/**
* The recommended onboarding action for this entity after the profile check this result refers to. The action can also be an entity state set by you.
* - UNCHECKED: New entity with no checks applied
* - PASS
* - FAIL
* - PASS_MANUAL: Manual intervention was applied to achieve a pass
* - FAIL_MANUAL: Manual intervention was applied but the entity still fails
* - REFER: Manual intervention required
* - WAIT: Externally applied state, waiting for more entity details
* - ARCHIVED: Externally applied state, entity hidden from on onboarding list
* - INACTIVE: Externally applied state, entity hidden from on onboarding list, indexes and further changes will be blocked.
*/
actionRecommended?: string;
issueList?: string[];
/**
* Indicates if any manual actions have been involved in the check result.
*/
manualIntervention?: boolean;
/**
* List of vendors from failed credit header sources.
*/
creditHeaderFailures?: string[];
/**
* Risk level. One of:
* - LOW,
* - MEDIUM,
* - HIGH,
* - UACCEPTABLE
* - or UNKNOWN
*/
riskLevel?: string;
/**
* Risk policy. Contents depend on account configuration but would typically be one of:
* - SDD,
* - CDD,
* - EDD
* - or FAIL
*/
riskPolicy?: string;
/**
* Summary of KYC match counts.
*/
kycResults?: Core["EntityProfileKYCMatchResultObject"][];
/**
* KYC match counts for each checked document, whether matched or not. The keys in this map are the document IDs. The match type in the value will be either "gov_id" or "other_id". The resultant structure would look like:
*
* documentResults: {
* "documentId" : {
* "matchType": "gov_id",
* "matchCount": 5,
* "verified": true
* },
* "documentId": {
* "matchType": "other_id",
* "matchCount": 5,
* "verified": true
* }
* }
*/
documentResults?: {
[key: string]: Core["EntityProfileItemMatchResultObject"];
};
/**
* KYC match counts for each checked address, whether matched or not. The keys in this map are the address IDs. The match type in the value will be either "curr_addr" or "prev_addr". The resultant structure would look like:
*
* "addressResults": {
* "addressId": {
* "matchType": "curr_addr",
* "matchCount": 5,
* "verified": true
* },
* "addressId": {
* "matchType": "prev_addr",
* "matchCount": 5,
* "verified": true
* }
* }
*/
addressResults?: {
[key: string]: Core["EntityProfileItemMatchResultObject"];
};
};
EntityProfileCheckResultMessage: {
/**
* A single check type that this result message applies to.
*/
checkType?: string;
/**
* The current state of the check. One of:
* - PASS
* - FAIL
* - UNCHECKED: Not attempted or service not available. For example AML not attempted if KYC fails.
* - NA: Not required. For example Visa check when there is no visa document and your account configuration indicates the check can be skipped.
*/
result?: string;
/**
* Short description of why not passed
*/
message?: string;
/**
* Alphanumeric code that is unique for each failure message to simplify result processing and display. Values to be decided.
*/
code?: string;
};
/**
* Match summary for a single checked address or document
*/
EntityProfileItemMatchResultObject: {
/**
* The match type that this count and result refer to. For document matches this will be "gov_id" or "other_id". For addresses ir will be "curr_addr" or "prev_addr" depending on the status of the address at the time of the check.
*/
matchType?: string;
/**
* The number of distinct sources that matched this address or document
*/
matchCount?: number;
/**
* List of sources that matched. The matchCount will be the number of entries in this list.
*/
matchSources?: string[];
/**
* True if an attempt was made to verify
*/
checked?: boolean;
/**
* True if there is at least one match
*/
verified?: boolean;
};
/**
* Summary of all KYC matches
*/
EntityProfileKYCMatchResultObject: {
/**
* The match types that this overall count and result refer to. Currently one or more of:
* - name
* - address
* - dob
* - gender
* - gov_id
* - other_id
*
* These will be keys in a map whose values hold the values for the individual match types. The resultant structure would look like the following. Here dob has zero matches and is not verfied but it was check, so other than the checked flag the value object is simply empty. A completely empty object would imply that match type was not checked.
*
* "matchTypes": {
* "address": {
* "matchCount": 1,
* "matchSources": [ "au-elec-roll" ],
* "checked": true,
* "verified": true
* },
* "dob": {
* "checked": true
* }
* }
*
* So for a one_plus KYC check there will be two EntityProfileKYCMatchResultObject records. One for 'name' and one for 'address, dob' (like the sample above).
*/
matchTypes?: {
[key: string]: object;
};
/**
* Number of matches for this set of match types. In other words the sum of the matchCounts in the matchTypes map. Note that for match sets that include government ID (gov_id) this will not neccessaily be the count of matched sources.
*/
matchCount?: number;
/**
* Number of distinct matches (sources and/or matched government ID documents) required for this set of match types.
*/
matchCountRequired?: number;
/**
* True if there are enough matches to meet the requirement
*/
verified?: boolean;
};
/**
* Contains the results of a given document entity create/update or GET request.
*/
EntityResultObject: {
requestId: Core["RequestIDObject"];
entity: Core["EntityObject"];
};
/**
* Contains the results of a given document entity create/update and IDV token details.
*/
EntityIDVResultObject: {
requestId: Core["RequestIDObject"];
entity: Core["EntityObject"];
/**
* Token to be used in the SDK to authenticate the applicant and application/referrer.
*
* Tokens are time limited (1 hour) and can only be used with the applicantId supplied.
*/
token: string;
/**
* The applicantId is either the same one that was supplied in the request for a fresh token, or a new one.
* This ID must be supplied along with the token to your SDK so that it knows who any uploaded documents are for.
*
* The latest applicant will also be written to the extraData of the entity as well for safe keeping. Older applicantIds will be overwritten.
*/
applicantId: string;
};
/**
* Contains the individual search results for an entity.
*/
EntitySearchResultListItem: {
confidence?: Core["SearchResultConfidenceObject"];
entity?: Core["EntityObject"];
/**
* If this entity has any level of name match then this is an array of document IDs for the entity where the document has an entity name and it doesn't match any entity names being sought.
*/
documentNameMismatches?: string[];
/**
* Array of descriptons of entity field matches used to score this search.
*/
entityMatchTypes?: string[];
/**
* Array of descriptons of document field matches used to score this search. This is a summary for all the documents for the matched entity.
*/
documentMatchTypes?: string[];
};
/**
* Contains the results of a given entity search.
*/
EntitySearchResultObject: {
requestId: Core["RequestIDObject"];
/**
* The list of (potentially) matching entities with confidence levels.
*
* If you are the "owner" of the entity - i.e. the same CustomerID and CustomerChildID (if relevant) - then the full details of the entity and any owned documents will be returned, except for the contents of any attached scans.
*
* If you are not the owner of the entity (or linked documents), then just the ID and confidence level is returned. You can still use this ID to retrieve any check results (see GET /entity/{entityId}/checks and GET /document/{documentId}/checks)
*/
entitySearchResults?: Core["EntitySearchResultListItem"][];
};
/**
* Details of the status changes to be made to a check result.
*/
CheckResultUpdateObject: {
comment: string;
status?: Core["enumCheckResultManualStatus"];
checkClassIds?: string[];
};
/**
* Unique identifier for every check/comparison/verification. Make sure you reference this ID whenever updating check details. This ID will also be used when pushing check results back to you.
*/
CheckIDObject: string;
/**
* Contains the details of a check on a given data point
*/
generalCheckResultObject: {
checkProcessResults?: Core["ProcessResultObject"];
/**
* Who performed the check. If it was the calling customer, the value will be "You".
* If it was another institution that has previously validated this data, then a generic description of their industry will be provided, such as "Bank", "Insurance", "Other FI".
*/
checkRequestedBy?: string;
};
/**
* An array in reverse chronological order of all checks done on this data point for the given entity. Older checks may have been previously done by you or another institution, and if so, these will be listed.
*/
generalCheckResultArray: Core["generalCheckResultObject"][];
/**
* Wraps up a BCRO with its internal ID.
*/
backgroundCheckResultObjectContainer: {
/**
* Internal ID of this BCRO. Use this if you need to set the status.
*/
id?: string;
bcro?: Core["backgroundCheckResultObject"];
};
/**
* Contains the details of a background check for a given entity. Background checks include Politically Exposed Person (PEP), sanctions lists, watchlists and adverse media.
*/
backgroundCheckResultObject: {
checkId?: Core["CheckIDObject"];
backgroundCheckType?: Core["enumBackgroundCheckType"];
currentState?: Core["enumBackgroundCheckState"];
/**
* The date and time the item was first checked.
*/
firstCheckDate?: string;
/**
* The date and time the item was last checked to provide this result.
*/
latestCheckDate?: string;
checkFrequency?: Core["enumBackgroundCheckFrequency"];
/**
* Confidence in the current results on a scale of 0 (none) to 100 (as certain as possible). Whole integers only.
*/
confidenceLevel?: number;
/**
* Service provider that performed the check. Basically the name of the connector, without the leading con_
*/
checkPerformedBy?: string;
/**
* Code that can be used to determine the underlying nature or data source of the checks performed. This may or may not be known by the connector, or may be a provider specific type (e.g. type "O")
*/
checkSource?: string;
/**
* Any additional notes that may relate to the state. Free form notes that may contain JSON blobs needing further interpretation.
*/
checkDetails?: Core["KeyValuePairObject"][];
};
PersonalNameCheckResultObject: {
name?: Core["PersonalNameObject"];
checkResult?: Core["generalCheckResultArray"];
};
DOBCheckResultObject: {
dob?: Core["DOBObject"];
checkResult?: Core["generalCheckResultArray"];
};
GenderCheckResultObject: {
gender?: Core["enumGender"];
checkResult?: Core["generalCheckResultArray"];
};
/**
* This object holds the address that was checked and the results associated with said checks.
* You can also leave the checkResult blank/nil if there are no results for that address if you wish.
* This is useful for returning results on a freshly crerated entity where the API user would want to confirm that the data has indeed been stored, and be able to capture relevant addressIDs - perhaps to address issues as to why it wasn't checked.
*/
AddressCheckResultObject: {
address?: Core["AddressObject"];
checkResult?: Core["generalCheckResultArray"];
};
/**
* This object holds the identityDocument that was checked and the results associated with said checks.
* You can also leave the checkResult blank/nil if there are no results for that identityDocument if you wish.
* This is useful for returning results on a freshly crerated entity where the API user would want to confirm that the data has indeed been stored, and be able to capture relevant documentIds - perhaps to address issues as to why it wasn't checked.
*/
IdentityDocumentCheckResultObject: {
idDocument?: Core["IdentityDocumentObject"];
checkResult?: Core["generalCheckResultArray"];
};
/**
* Wrapper object to contain a single set of AML check results.
*/
AMLResultSet: {
groupDetails?: Core["backgroundCheckResultObjectContainer"];
/**
* Collection of check results for the entity being a Politically Exposed Person
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
checkResultsListPEP?: Core["backgroundCheckResultObjectContainer"][];
/**
* Collection of check results for the entity being on a sanctions list
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
checkResultsListSanctions?: Core["backgroundCheckResultObjectContainer"][];
/**
* Collection of check results for the entity being on a watchlist
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
checkResultsListWatchlists?: Core["backgroundCheckResultObjectContainer"][];
/**
* Collection of check results for the entity being found in any adverse media
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
checkResultsListMedia?: Core["backgroundCheckResultObjectContainer"][];
};
/**
* Describes all of the checks that were carried out against an entity as part of our cascading check process. Because there are a number of steps involved in checking an entity, (including the use of past checks done by you or others), there is an overall summary check result that will tell you the final disposition of the the check you requested.
*
* So if you requested a 2+2+governmentID+pep/sanctions/etc (i.e. everything) then there would have been several checks done in order to meet this requirement. Some may have even failed, but eventually we got there. The summary gives the final assessment, based on all available data.
*
* Detailed writeups on how this all works can be found here:
* https://help.frankiefinancial.com/hc/en-au/articles/900001758203-Non-Profile-Entity-Verify-Understanding-the-Results
* and here:
* https://help.frankiefinancial.com/hc/en-au/articles/900001758243-Non-Profile-Entity-Verify-Interpreting-the-Results
*/
CheckEntityCheckResultObject: {
requestId?: Core["RequestIDObject"];
checkSummary?: Core["ProcessResultObject"];
/**
* Contains a list of all checkSummary records (one for each check)
*/
checkResultsListSummaries?: Core["ProcessResultObject"][];
checkRisk?: Core["ProcessResultObject"];
/**
* This will hold all of the check results that were performed against the
*/
entityResult?: {
/**
* Unique ID for the entity.
*/
entityId?: string;
nameCheck?: Core["PersonalNameCheckResultObject"];
dateOfBirthCheck?: Core["DOBCheckResultObject"];
genderCheck?: Core["GenderCheckResultObject"];
/**
* Collection of address objects.
*/
addressesCheck?: Core["AddressCheckResultObject"][];
/**
* Collection of identity documents (photos, scans, selfies, etc), and their check results
*/
identityDocsCheck?: Core["IdentityDocumentCheckResultObject"][];
/**
* !!!!! DEPRECATED !!!!!
* Please use the multi-result AMLResultSets structure instead.
*
* Note: This single check result structure will be retired in v1.3
* !!!!! DEPRECATED !!!!!
*
* Collection of check results for the entity being a Politically Exposed Person
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
pepCheck?: Core["backgroundCheckResultObject"][];
/**
* !!!!! DEPRECATED !!!!!
* Please use the multi-result AMLResultSets structure instead.
*
* Note: This single check result structure will be retired in v1.3
* !!!!! DEPRECATED !!!!!
*
* Collection of check results for the entity being on a sanctions list
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
sanctionsCheck?: Core["backgroundCheckResultObject"][];
/**
* !!!!! DEPRECATED !!!!!
* Please use the multi-result AMLResultSets structure instead.
*
* Note: This single check result structure will be retired in v1.3
* !!!!! DEPRECATED !!!!!
*
* Collection of check results for the entity being on a watchlist
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
watchlistCheck?: Core["backgroundCheckResultObject"][];
/**
* !!!!! DEPRECATED !!!!!
* Please use the multi-result AMLResultSets structure instead.
*
* Note: This single check result structure will be retired in v1.3
* !!!!! DEPRECATED !!!!!
*
* Collection of check results for the entity being found in any adverse media
*
* An array sorted by type, then reverse chronological order of some/all background checks done on this entity. Older checks may have been previously done by you or another institution, and if so, these will be listed and appropriately anonymised/obfuscated.
*/
adverseMediaCheck?: Core["backgroundCheckResultObject"][];
/**
* An array of Collections of PEP/Sanctions/WL/Media objects, as AML providers can return multiple results
*/
amlResultSets?: Core["AMLResultSet"][];
};
entityProfileResult?: Core["EntityProfileResultObject"];
/**
* Collection of check results for the entity having previously been checked.
*
* An array of matched checked entities sorted by match confidence level (highest first).
*/
duplicateCheckResults?: Core["ProcessResultObject"][];
/**
* Collection of check results for the entity having been previously blacklisted.
*
* An array of matched blacklisted entities sorted by match confidence level (highest first).
*/
blacklistCheckResults?: Core["ProcessResultObject"][];
/**
* Collection of check results for the manual KYC.
*
* An array of one entry with the manual check result.
*/
manualCheckResults?: Core["ProcessResultObject"][];
fraudCheckResults?: Core["FraudCheckResultObject"];
/**
* We can perform a number of device checks on an entity, such as those from ThreatMetrix and/or BioCatch. If one of these checks was incorporated into the ID check, then these will appear here.
*/
deviceCheckResults?: Core["ProcessResultObject"][];
};
/**
* All valid customers get a puppy. Otherwise, no puppy for you!
*/
PuppyObject: {
puppy: boolean;
/**
* Server version indication
*/
commit?: string;
};
/**
* A common pairing of a short code and a long description.
*/
CodeDescription: {
code?: string;
description?: string;
};
/**
* Details of a shareholding as returned from an ASIC report.
*/
ShareholdingObject: {
docNumber?: string;
docNumberQualifier?: string;
shareCapitalClassCode?: string;
numberHeld?: number;
beneficiallyOwned?: boolean;
fullyPaid?: boolean;
members?: string[];
};
/**
* Officer court details as returned from an ASIC report.
*/
CourtDetailsObject: {
type?: Core["CodeDescription"];
state?: string;
country?: string;
applicationNumber?: string;
applicationYear?: number;
};
/**
* Officer details as returned from an ASIC report.
*/
OfficerObject: {
entityId?: string;
type?: string;
typeDescription?: string;
status?: string;
docNumber?: string;
docNumberQualifier?: string;
appointmentDate?: string;
courtDetails?: Core["CourtDetailsObject"];
};
/**
* Describes a collection of shares of a particular type and their attributes,
* One or more ShareStructures make up a company's shares that are then parcelled out as shareholdings.
*/
ShareStructureObject: {
status?: string;
docNumber?: string;
docNumberQualifier?: string;
classCode?: string;
classTitle?: string;
sharesIssued?: number;
amountPaid?: number;
amountDue?: number;
};
/**
* Organisation details for entities. Returned from an ASIC report.
*/
OrganisationDataObject: {
registeredName?: string;
registration?: {
state?: string;
previousNumber?: string;
date?: string;
};
type?: Core["CodeDescription"];
class?: Core["CodeDescription"];
subclass?: Core["CodeDescription"];
status?: Core["CodeDescription"];
shareStructure?: Core["ShareStructureObject"][];
disclosingEntityIndicator?: boolean;
kycCustomerType?: string;
includesNonBeneficiallyHeld?: boolean;
lastCheckDate?: string;
ownershipResolved?: boolean;
adverseCreditDataPresent?: boolean;
startDate?: string;
};
BeneficialOwnerObject: {
/**
* The entityId of the owner.
*/
entityId?: string;
percentageHeld?: {
beneficially?: number;
nonBeneficially?: number;
jointly?: number;
total?: number;
};
};
StaticOfficerObject: {
addedBy: string;
appointmentDate: string;
entityId: string;
type: string;
typeDescription: string;
};
StaticBeneficialOwnerObject: {
addedBy: string;
entityId: string;
percentageHeld?: {
beneficially?: number;
jointly?: number;
nonBeneficially?: number;
total?: number;
};
};
/**
* Details of the organisation for which ownership should be queried. This should at least contain the ACN in the externalIds.
*/
OwnershipQuery: {
organisation: Core["EntityObject"];
};
/**
* Frankie internal use only.
*
* The result of an /business/ownership/query call as returned by a suitable service connector.
*/
OwnershipQueryResponseObject: {
requestId?: Core["RequestIDObject"];
checkId?: string;
/**
* If a result is provided in this response then this is the date and time the service provided that result.
*/
checkDate?: string;
/**
* Unique identifier provided by the service.
*/
providerCheckId?: string;
ownershipQueryResult?: Core["OwnershipQueryResultObject"];
};
/**
* The data that was initially supplied to check in the batch file
*/
SuppliedData: {
/**
* The name of the company to be verified
*/
name: string;
/**
* The type of company on file. Use the ABR's company types, as given here:
*
* https://abr.business.gov.au/Documentation/ReferenceData (entity types)
*/
company_type: "PRV" | "PUB";
/**
* Australian Company Number on file - MUST be zero left-padded to 9 digits
*/
acn: string;
/**
* Australian Business Number - MUST be 11 digits. Can be supplied in lieu of the ACN
*/
abn: string;
/**
* Your reference number for this company
*/
customer_reference: string;
};
/**
* The results of the comparison of the supplied data (above) to that found on file with the ABR.
* If the value is missing, then the comparison was not run. There will likely be an issue highlighted in the issues_list
*/
SuppliedDataMatches: {
/**
* Did the supplied name match (or closely match) the name on file with the ABR
*/
matched_name: boolean;
/**
* Did the supplied ACN match the ACN on file with the ABR? Only truly relevant if ABN is supplied as well.
*/
matched_acn: boolean;
/**
* Did the supplied company type match the company type on file with the ABR?
*/
matched_company_type: boolean;
};
/**
* A key/value pair of strings that describe the location of the issue (key) and an issue description (value). Also inclused is a severity
*/
IssueListItems: {
/**
* Where the issue occured. It will describe a location in the response structure
*/
issue_location?: string;
/**
* Human readable description of the issue
*/
issue_description?: string;
/**
* The impact of the issue on the process.
*
* Is it just informational, such as a trivial different in a name match?
* Is it a warning to highlight something that is important, but did not prevent the process from completing?
* Is it a critical issue that prevented the check from completing successfully?
* Is it a stop condition that prevented the checks from being run at all?
*/
issue_severity?: "INFO" | "WARN" | "CRIT" | "STOP";
};
/**
* If a company is listed, then this object will be populated with whatever data has been determined.
*/
StockExchangeData: {
exchange?: string;
exchange_ticker?: string;
approved_exchange?: boolean;
supporting_evidence_in_pdf?: boolean;
supporting_document_links?: string[];
};
/**
* The results of a safe harbour KYC check of an individual
*/
KYCScreeningResult: {
/**
* The disposition of the 2+2 Safe Harbour check
*/
check_result?: "NOT_SCREENED" | "PASS" | "REFER" | "FAIL";
/**
* The number of name matches
*/
name_match_count: number;
/**
* The number of date of birth matches
*/
dob_match_count: number;
/**
* The number of address matches
*/
address_match_count: number;
/**
* The is of matching data sources that produced a success match for the person being screened
* Example given is not indicative of the actual sources available.
*/
matching_sources?: string[];
};
/**
* The results of any AML/Adverse media screening undertaken
*/
AMLScreeningResult: {
/**
* The overall result
*/
check_result?: "NOT_SCREENED" | "CLEAR" | "POSSIBLE_HIT";
/**
* The number of adverse media hits.
*/
media_hit_count?: number;
};
/**
* Contains the results (if any) of the KYC and AML/Media checks performed
*/
ScreeningResult: {
kyc_result?: Core["KYCScreeningResult"];
aml_result?: Core["AMLScreeningResult"];
};
RegulatoryInformation: {
regulatory_body?: string;
licence_details?: string;
licence_number?: string;
licence_verified?: boolean;
};
/**
* The details of the company being checked
*/
BusinessDetails: {
/**
* Frankie's unique identifier for the business.
*
* Uses a non-versioned UUID format
*/
entity_id?: string;
registered_name: string;
business_names?: string[];
trading_names?: string[];
ABN: string;
ACN: string;
ARBN: string;
asic_company_type?: string;
public_company?: boolean;
registered_office?: Core["AddressObject"];
place_of_business?: Core["AddressObject"];
date_registered_with_asic?: string;
state_registered_with_asic?: string;
giin: string;
anzsic_code: string;
stock_exchange_data?: Core["StockExchangeData"];
regulatory_information?: Core["RegulatoryInformation"];
};
/**
* x
*/
IndividualData: {
/**
* Name of the individual
*/
name?: string;
/**
* If this individual has a role as an officeholder, such as director, then this will be described here. May be blank.
*/
role: string;
/**
* If describing an (ultimate) beneficial owner, the percentage of the company owned by this Individual
*/
percent_owned: number;
/**
* If describing an (ultimate) beneficial owner, then if any of the shared held are not benefially held, this field will be set to "false"
*/
beneficially_held: boolean;
/**
* RFC3339 formatted date
*/
date_of_birth?: string;
/**
* List of all found addresses associated with this person
*/
addresses?: Core["AddressObject"][];
screening_result?: Core["ScreeningResult"];
};
/**
* x
*/
NonIndividualBeneficialOwner: {
/**
* Name of the company/entity
*/
name?: string;
/**
* The ASIC type of the company/entity
*/
entity_type?: string;
/**
* If describing an (ultimate) beneficial owner, the percentage of the company owned
*/
percent_owned: number;
/**
* If describing an (ultimate) beneficial owner, then if any of the shared held are not benefially held, this field will be set to "false"
*/
beneficially_held: boolean;
stock_exchange_data?: Core["StockExchangeData"];
};
UBOResponse: {
/**
* Only populated if there was an error whilst trying to initiate the UBO check.
*
* Signifies that no other result data will be supplied
*/
error_message?: string;
/**
* If an ASIC search was conducted, what was the date/time in RFC-3339 format
*/
asic_search_timestamp?: string;
/**
* The full URI of the UBO report PDF created as a part of this process (if requested)
*/
ubo_report?: string;
supplied_data: Core["SuppliedData"];
supplied_data_matches?: Core["SuppliedDataMatches"];
/**
* A list of issues encountered whilst processing the UBO request and subsequent KYC/AML checks.
*/
issues_list?: Core["IssueListItems"][];
business_details?: Core["BusinessDetails"];
business_screening_result?: Core["ScreeningResult"];
/**
* A list of individuals who have been determined to own, either directly or indirectly, 25% or more of the company
*/
ultimate_beneficial_owners?: Core["IndividualData"][];
/**
* A list of organisations who have been determined to own a (potentially) beneficial interest the company.
*
* The presence of non_individual_beneficial_owners indicates that not all individual ultimate beneficial owners could be determined.
* Examples may include public companies, listed companies, foreign companies, corporate trusts or other entities whose beneficial owners are not readily available.
*/
non_individual_beneficial_owners?: Core["NonIndividualBeneficialOwner"][];
/**
* A list of individuals who serve as current office holders the company
*/
officeholders?: Core["IndividualData"][];
};
/**
* The result of an /business/ownership/query call retrieved via GET /retrieve/response/{requestId} after you receive a notification that the result is ready.
*/
OrganisationCheckResponseObject: {
requestId?: Core["RequestIDObject"];
/**
* Unique identifier for the ownership check.
*/
ownershipCheckId?: string;
/**
* If an ownership result is provided in this response then this is the date and time the service provided that result.
*/
ownershipCheckDate?: string;
/**
* Batch identifier for the KYC/AML check results if any.
*/
organisationCheckId?: string;
uboResponse?: Core["UBOResponse"];
ownershipQueryResult?: Core["OwnershipQueryResultObject"];
organisationCheckResult?: Core["OrganisationCheckResultObject"];
ownershipQueryError?: Core["ErrorObject"];
/**
* Used to set additional information flags for this response.
*/
flags?: Core["EntityFlagObject"][];
reportResult?: Core["BusinessReportResultObject"];
reportError?: Core["ErrorObject"];
};
/**
* The positive result of a report generation request if any.
*/
BusinessReportResultObject: {
location?: string;
documentId?: string;
scanDocId?: string;
};
OwnershipQueryResultObject: {
/**
* The entityId of the organisation for which this result was created. The details will be in the ownershipDetails map with this ID as the key.
*/
entityId?: string;
/**
* List of all entities (both individuals and organisations) associated with this ownership result. These objects will be referenced by entityId in the shareholdings and officers lists in the following ownership details.
*/
associatedEntities?: {
[key: string]: Core["EntityObject"];
};
/**
* List of entity IDs (that should be in the associatedEntities list) who blocked the ultimate beneficial ownership tree traversal. These are likely to be entities that cannot be checked automatically (such as trusts) or who have no UBO's of their own, such as public companies.
*
* The presence of data in this array also signifies that the full UBO list is not complete.
*/
blockingEntityIds?: string[];
/**
* A map of entityId to ownershipDetailsObjects with at least one entry being for the root organisation that the overall result relates to. Any remaining entries will be for further results for organisational owners referenced in the root ownershipDetailsObject and so on.
*/
ownershipDetails?: {
[key: string]: Core["OwnershipDetailsObject"];
};
};
/**
* The ownership details for one organisation.
*/
OwnershipDetailsObject: {
organisation?: Core["EntityObject"];
/**
* Parcels of shares held by one or more shareholders.
*/
shareholdings?: Core["ShareholdingObject"][];
/**
* Company office holders.
*/
officers?: Core["OfficerObject"][];
/**
* The ultimate beneficial owners of the company.
*/
ultimateBeneficialOwners?: Core["BeneficialOwnerObject"][];
/**
* The beneficial owners of the company, who aren't necessarily UBO's.
*/
beneficialOwners?: Core["BeneficialOwnerObject"][];
staticOfficers?: Core["StaticOfficerObject"][];
staticBeneficialOwners?: Core["StaticBeneficialOwnerObject"][];
};
/**
* The results of KYC/AML check on a organisation with a prior ownership query. This will be retrived via GET /retrieve/response/{requestId} after you receive a notification that the results are ready.
*/
OrganisationCheckResultObject: {
/**
* The entityId of the organisation for which this result was created.
*/
entityId?: string;
/**
* The unique ID for grouping all new KYC/AML checks in this result. This is only for Frankie internal use.
*/
groupId?: string;
/**
* A map of the entity categories that were selected for checks and an array of the entity IDs for each. The results for each entity ID will be in either the entityCheckResults or entityCheckErrors maps. Entities may appear in more than one category.
*/
entityCategories?: {
[key: string]: string[];
};
/**
* List of all entities check results (both individuals and organisations) other than outright errors. These objects will be referenced by entity ID in the entity category map.
*/
entityCheckResults?: {
[key: string]: Core["CheckEntityCheckResultObject"];
};
/**
* A map of outright errors (failure to generate any kind of result). These objects will be referenced by entity ID in the entity category map.
*/
entityCheckErrors?: {
[key: string]: Core["ErrorObject"];
};
};
BusinessReportResponseDetails: {
requestId?: Core["RequestIDObject"];
/**
* Unique identifier for the report operation.
*/
checkId?: string;
/**
* The entity after it has been added/updated in the service
*/
entity?: Core["EntityObject"];
/**
* The collection of requested business reports.
*/
reports?: Array;
};
BusinessReportResponseObject: {
details?: Core["BusinessReportDetailsObject"];
/**
* The requested report object. This will be one of: - ReportCreditScore - ReportCreditReport
*/
report?: any;
};
BusinessReportDetailsObject: {
/**
* The name of the requested report
*/
reportName?: string;
/**
* If the report provider generated an ID or recipt number for the report, it goes here
*/
reportId?: string;
/**
* The ISO UTC date and time the report was generated
*/
reportDateTime?: Date;
/**
* The name of the service provider that generated the report.
*/
reportProvider?: string;
/**
* Whether the report was successfully run or not
*/
reportRun?: boolean;
/**
* Any details of what is happening with the report of not run. Will be one of: - OK (the report was run) - LATER (the report will be sent later as a response notification) - An error message as to why the report did not work
*/
reportStatus?: string;
};
/**
* Contains any data required for biometric checks.
*/
RiskTokenObject: {
sessionKey: string;
userId: string;
};
/**
* The Amount described in the Transaction Risk Check
*/
AmountObject: {
value: string;
currCode: string;
};
/**
* Summary list of Issues that were flagged as part of this Transaction
*/
RiskCheckIssueObject: {
/**
* Enum of risk assessment groupings, e.g. customer, device, transaction, AML, PEP as determined by the risk checking service
*/
name?: Core["enumRiskResultType"];
/**
* An enumerated list of risk as determined by the checking service.
*/
level?: Core['enumRiskLevelType'];
};
/**
* Summary list of Issues that were flagged as part of this Transaction
*/
RiskCheckCaseObject: {
checkId?: string;
resultId?: string;
riskToken?: Core['RiskTokenObject'];
/**
* Date time that the Transaction Occurred
*/
transactionTimestamp?: string;
/**
* Date time that the Check Case was Created
*/
timeStamp?: string;
/**
* Date time that the Check Case was last updated
*/
lastUpdated?: string;
/**
* Current Status of the Case
*/
status?: Core['enumCheckCaseStatus'];
/**
An enumerated list of risk as determined by the checking service
- NONE
- LOW
- MEDIUM
- HIGH
- VERY_HIGH
*/
riskLevel?: Core['enumRiskLevelType'];
/**
Type of the Activity that has occurred
- REGISTRATION
- LOGIN
- FIAT_WITHDRAWAL
- FIAT_DEPOSIT
- CRYPTO_WITHDRAWAL
- CRYPTO_DEPOSIT
*/
activityType?: Core['enumActivityType'];
/**
The type of payment that the transaction used
- CARD
- BANK
- WIRE
- CRYPTO
- OTHER
*/
paymentType?: Core['enumPaymentType'];
/**
Identifier for the payment type
*/
paymentId?: string;
/**
Identifier of the Device that was used for this check, this would be provided from the initial request data
*/
deviceId?: string;
/**
Current Frankie Portal user that is assigned to this user
*/
assignedTo?: string;
/**
The Amount described in the Transaction Risk Check
*/
amount?: Core['AmountObject'];
/**
Enum of risk assessment groupings, e.g. customer, device, transaction, AML, PEP as determined by the risk checking service
*/
issueType?: Core['enumIssueType'];
};
TransactionCasesData: {
data: Core['RiskCheckCaseObject'];
/**
* Identifier for the Next Page of Results, if not populated there is no more results to paginate for
*/
nextPageToken: string;
};
}
//# sourceMappingURL=Core.d.ts.map