import { loadPrivIdModule } from '@privateid/cryptonets-web-sdk';
// load PrivModules accepts the following:
interface apiUrlProps {
  collections: {
    default: {
      named_urls: {
        base_url: string,
        predict?: string,
        enroll?: string,
        validate_api_key?: string
      };
    };
  };
}

interface loadModulesProps {
  api_url: apiUrlProps; // collection or collections of api url
  api_key?: string; // api key
  api_orchestration_url?: string; // if orchestration will be use and env is not available
  cache_config?: boolean; // if cace_config will be use and env is not available
}
const isSupported = await loadPrivIdModule({
    api_url: {
        collections: {
            default: {
                base_url: process.env.REACT_APP_API_URL,
            }
        }
    },
    // incase ENV variable is not available in your app provide your api key here
    api_key: "API KEY"
}:loadModulesProps);

{
    support: boolean,
    message: string,
}

import { openCamera } from '@privateid/cryptonets-web-sdk';

const { devices, faceMode } = await openCamera(element);

import { switchCamera } from '@privateid/cryptonets-web-sdk';

switchCamera(deviceID);

import { switchCamera } from '@privateid/cryptonets-web-sdk';

switchCamera('front');

import { closeCamera } from '@privateid/cryptonets-web-sdk';

closeCamera(element); // Will specifically look for the element id and will close that camera
closeCamera(); // By default will close opened camera using openCamera

import { isValid } from '@privateid/cryptonets-web-sdk';

 await isValid(callback, imageData, config);

import { predictAge } from '@privateid/cryptonets-web-sdk';

await predictAge(predictAgeCallback);

import { enroll1FA } from '@privateid/cryptonets-web-sdk';

const image: ImageData | null = enroll1FA(callback, {enroll_token:"token"});

import { predict1FA } from '@privateid/cryptonets-web-sdk';

await predict1FA(callback)

import { faceLogin } from '@privateid/cryptonets-web-sdk';

await faceLogin(callback)

import { continuousAuthentication } from '@privateid/cryptonets-web-sdk';

continuousAuthentication(callback, configuration, element)

import { isValidPhotoID } from '@privateid/cryptonets-web-sdk';

//Front of DL scan 
const { imageData, croppedDocument, croppedMugshot } = isValidPhotoID("PHOTO_ID_FRONT", documentCallback);

// Back of DL barcode scan
const { croppedBarcode, croppedDocument } = isValidPhotoID("PHOTO_ID_BACK", callback)

{
    "error": number,
    "payload_type": "face_id",
    "image_width": number,
    "image_height": number,
    "doc_center_x": number,
    "doc_center_y": number,
    "doc_x1": number,
    "doc_y1": number,
    "doc_x2": number,
    "doc_y2": number,
    "doc_x3": number,
    "doc_y3": number,
    "doc_x4": number,
    "doc_y4": number,
    "conf_level": number,
    "cropped_doc_width": number,
    "cropped_doc_height": number,
    "cropped_doc_channels": number,
    "doc_validation_status": number,
    "op_message": string,
    "predict_status": number,
    "face_valid": number,
    "op_status": number,
    "cropped_face_width": number,
    "cropped_face_height": number,
    "cropped_face_size": number,
    "cropped_face_channels": number,
    "status_message": string
}

{
    "op_status": number,
    "op_message": "",
    "payload_type": "barcode",
    "image_width": number,
    "image_height": number,
    "barcode_conf_score": number,
    "barcode_c_x0": number,
    "barcode_c_y0": number,
    "barcode_x1": number,
    "barcode_y1": number,
    "barcode_x2": number,
    "barcode_y2": number,
    "barcode_x3": number,
    "barcode_y3": number,
    "barcode_x4": number,
    "barcode_y4": number,
    "crop_img_topleft_x": number,
    "crop_img_topleft_y": number,
    "crop_img_botright_x": number,
    "crop_img_botright_y": number,
    "crop_doc_width": number,
    "crop_doc_height": number,
    "crop_doc_bytes": number,
    "crop_doc_channels": number,
    "crop_barcode_width": number,
    "crop_barcode_height": number,
    "crop_barcode_bytes": number,
    "crop_barcode_channels": number,
    "type": string,
    "format": string,
    "documentId": string,
    "customerId": string,
    "firstName": string,
    "lastName": string,
    "middleName": string,
    "expirationDate": string,
    "issueDate": string,
    "dateOfBirth": string,
    "gender": string,
    "eyeColor": string,
    "hairColor": string,
    "height": string,
    "streetAddress1": string,
    "streetAddress2": string,
    "RestStreetAddress1": string,
    "RestStreetAddress2": string,
    "city": string,
    "state": string,
    "postCode": string,
    "issuingCountry": string,
    "firstNameTruncation": string,
    "placeOfBirth": string,
    "auditInformation": string,
    "inventoryControlNumber": string,
    "lastNameAlias": string,
    "firstNameAlias": string,
    "suffixAlias": string,
    "nameSuffix": string,
    "namePrefix": string,
    "barcode_key_string": string,
    "barcode_key_string_encoding": string,
    "barcodeHash64_string": string,
    "barcodeHash128_string": string,
    "status_message": string
}

import { convertCroppedImage } from '@privateid/cryptonets-web-sdk';

// FRONT DL SCAN and BACK DL SCAN
// For converting InputImage returned data FRONT DL SCAN and from BACK DL SCAN.
const InputImageBase64String = convertCroppedImage(inputImage, image_height, image_width);

// FRONT DL SCAN
// For converting croppedDocument returned data from FRONT DL SCAN.
// (Note: We would need other variables that is returned in the callback data. crop_doc_width, crop_doc_height)
const FrontCroppedDocumentBase64String = convertCroppedImage(croppedDocument, crop_doc_width, crop_doc_height);

// For converting croppedMugshot returned data from FRONT DL SCAN.
// (Note: We would need other variables that is returned in the callback data. cropped_face_width and cropped_face_height)
const FrontCroppedMugshotBase64String = convertCroppedImage(croppedMugshot, cropped_face_width and cropped_face_height);

// BACK DL SCAN
// For converting croppedBarcode returned data from BACK DL SCAN.
// (Note: We would need other variables that is returned in the callback data. crop_barcode_width and crop_barcode_width)
const CroppedBarcodeBase64String = convertCroppedImage(croppedBarcode, crop_barcode_width, crop_barcode_height);

// For converting croppedDocument returned data from BACK DL SCAN.
// (Note: We would need other variables that is returned in the callback data. crop_doc_width and crop_doc_height)
const CroppedDocumentBase64String = convertCroppedImage(croppedDocument, crop_doc_width, crop_doc_height);

import { faceCompareLocal } from '@privateid/cryptonets-web-sdk';

faceCompareLocal(callback, imageData1, imageData2, { input_image_format: "rgba" });

{
    "error": number,
    "distance_max": number,
    "distance_mean": number,
    "distance_min": number,
    "conf_score": number,
    "face_thresholds_count": number,
    "face_thresholds": [
        number,
        number,
        number
    ],
    "result": number,
    "valid_flag_a": number,
    "valid_flag_b": number
}

import { deleteUser } from "@privateid/cryptonets-web-sdk";

deleteUser(uuid, callback)

import { checkPackageSupport } from "@privateid/cryptonets-web-sdk";

checkPackageSupport();

import { createUser } from '@privateid/cryptonets-web-sdk';

createUser(parmas)

params = {
    id?: string; // (CID or GAN Unique ID/PlayerID)
    guid?: string;
    phone: string;
    phoneVerified?: boolean;
    email?: string;
    emailVerified?: boolean;
    ssn4?: string;
    ssn9?: string;
    userConsent: boolean;
    userConsentDate: string;
    userFaceEnrollConsent?: boolean;
    consentVersion: string;
    portrait?: string;
};

import { sendEnrollSms } from '@privateid/cryptonets-web-sdk';

sendEnrollSms({ id })

{
    id: string; // (CID or GAN Unique ID/PlayerID)
}

import { verifyToken } from '@privateid/cryptonets-web-sdk';

verifyToken({ code, type })

{
    code: string; // verification code
    type: ['phone', 'email']; 
}

import { uploadPortrait } from '@privateid/cryptonets-web-sdk';

uploadPortrait({ id, portrait })

{
    id: string; // (CID or GAN Unique ID/PlayerID)
    portrait: string // Base64 
}

import { uploadDL } from '@privateid/cryptonets-web-sdk';

// Uploading Front DL images
uploadDl({ id, type, image })
    id: string //Required
    type: "frontDLoriginal", "frontDLheadshot", "frontDLcropped"
    image: string // Base64 //Require
 
// Uploading Back DL image
uploadDl({ id, type, image })
    id: string //Required
    type: "backDLoriginal", "backDLbarcode"
    image: string // Base64 //Required 
 
// Uploading Back DL barcode JSON
uploadDl({ id, type, barcode})
    id : string //Required
    type:  "barcodeJson"
    barcode: string //Required

import { updateUser } from '@privateid/cryptonets-web-sdk';

updateUser({ id, attributes })

{
    id: string; // (CID or GAN Unique ID/PlayerID)
    attributes: {...}; // 
}

import { getUserStatus } from '@privateid/cryptonets-web-sdk';

getUserStatus({ id  })

{
    id: string; // (CID or GAN Unique ID/PlayerID)
}

import { validateSecurityToken } from '@privateid/cryptonets-web-sdk';

validateSecurityToken({ uuid, token })

{
    puid: string; // UUID of the user
    token: string; // Token from the api call i.e. enroll1Fa/predict1Fa
}

import { clearCache } from '@privateid/cryptonets-web-sdk';

clearCache();

import { generatePasskey } from '@privateid/cryptonets-web-sdk';

generatePasskey(uuid);

{
    uuid: string; // The UUID for which you want to generate a passkey (Required)
}

import { authenticatePasskey } from '@privateid/cryptonets-web-sdk';

authenticatePasskey(uuid);

{
    uuid: string; // The UUID for which you want to authenticate a passkey (Required)
}

import { deletePasskey } from '@privateid/cryptonets-web-sdk';

deletePasskey(uuid);

{
    uuid: string; // The UUID for which you want to delete the passkey (Required)
}