Mini-App API Documentation

Store a value in persistent mini-app storage.

{
  "key": "user_preference",
  "data": { "theme": "dark", "language": "en" },
  "callback": "onStorageSet"
}

{
  "action": "setStorage",
  "key": "user_preference",
  "success": true
}

const request = { key: "user_preference", data: { theme: "dark" }, callback: "onStorageSet" };
AtlayoInterface.setStorage(JSON.stringify(request));

function onStorageSet(response) {
    console.log('Saved:', response.success);
}

Retrieve a value from persistent storage.

{ "key": "user_preference", "callback": "onStorageGet" }

{
  "action": "getStorage",
  "key": "user_preference",
  "found": true,
  "data": "{\"theme\":\"dark\"}"
}

AtlayoInterface.getStorage(JSON.stringify({ key: "user_preference" }));

function onStorageGet(response) {
    if (response.found) {
        const data = JSON.parse(response.data);
        console.log('Theme:', data.theme);
    }
}

Remove a specific key from storage.

{ "key": "user_preference" }

{
  "action": "removeStorage",
  "key": "user_preference",
  "removed": true
}

AtlayoInterface.removeStorage(JSON.stringify({ key: "user_preference" }));

Clear all data from the mini-app storage.

{}

{ "action": "clearStorage", "cleared": true }

AtlayoInterface.clearStorage(JSON.stringify({}));

Request permission for specific user data fields. Previously granted permissions return data immediately without a dialog.

["given_name", "family_name", "phone_number"]

{
  "given_name": "John",
  "family_name": "Doe",
  "phone_number": "+1234567890"
}

const permissions = ["given_name", "family_name", "phone_number"];
AtlayoInterface.requestPermissions(JSON.stringify(permissions));

window.onPermissionsGranted = function(data) {
    document.getElementById('userName').textContent =
        data.given_name + ' ' + data.family_name;
    const sysInfo = JSON.parse(AtlayoInterface.getSystemInfo());
    if (sysInfo.token) {
        fetch('/api/user-data', {
            headers: { 'Authorization': 'Bearer ' + sysInfo.token }
        });
    }
};

Check if specific permissions have been granted without showing a dialog.

["gps", "bluetooth"]

{
  "gps": true,
  "bluetooth": false
}

AtlayoInterface.checkPermissions(JSON.stringify(["gps", "bluetooth"]));

window.onPermissionsChecked = function(data) {
    console.log("GPS granted:", data.gps);
};

Request new permissions to be merged with already granted ones. Shows a dialog only if there are new or previously denied permissions.

["bluetooth"]

{
  "given_name": "John",
  "bluetooth": true
}

AtlayoInterface.requestAdditionalPermissions(JSON.stringify(["bluetooth"]));

window.onPermissionsGranted = function(data) {
    // Same callback as requestPermissions
};

Set the Android status bar color.

"#FF0000"

void

AtlayoInterface.setStatusBarColor("#FF0000");

Set the mini-app top bar background color.

"#3498db"

void

AtlayoInterface.setTopBarBackgroundColor("#3498db");

Set the mini-app top bar text/icon color.

"#FFFFFF"

void

AtlayoInterface.setTopBarForegroundColor("#FFFFFF");

Set the Android navigation bar color and icon style.

AtlayoInterface.setNavigationBarColor("#000000", true)

void

AtlayoInterface.setNavigationBarColor("#000000", true);

Control the screen orientation (rotation) for the mini-app. By default, the orientation is locked to portrait.

"landscape"

void

AtlayoInterface.setOrientation("landscape");

Returns comprehensive device and system information as a JSON string (synchronous).

AtlayoInterface.getSystemInfo()

{
  "brand": "samsung", "model": "SM-G991B", "platform": "android",
  "screenWidth": 1080, "screenHeight": 2400, "darkMode": false,
  "language": "en", "token": "", "safeArea": { "top": 28, "bottom": 0 }
}

const systemInfo = JSON.parse(AtlayoInterface.getSystemInfo());
document.getElementById('deviceInfo').textContent =
    systemInfo.brand + ' ' + systemInfo.model;
document.getElementById('screenSize').textContent =
    systemInfo.screenWidth + ' x ' + systemInfo.screenHeight;
if (systemInfo.darkMode) document.body.classList.add('dark-mode');
const safeArea = systemInfo.safeArea;
document.getElementById('content').style.paddingTop = safeArea.top + 'px';

Disables default web-browser long-press text selection magnifiers and context menus, substituting native haptic feedback (HapticFeedbackConstants.LONG_PRESS) to give the web view a pure native app texture.

true

true  // bridge available
false // bridge unavailable

// Native-app touch feel (no magnifier / selection handles)
Atlayo.system.setWebTouchFeedback(true);

// Restore default browser long-press behavior
Atlayo.system.setWebTouchFeedback(false);

Request pinning a dynamic launcher shortcut directly to the user's Android home screen (e.g. a "Scan & Pay" shortcut leading to a specific mini-app screen).

// Defaults: mini-app id, name, and favicon
Atlayo.system.requestAppShortcut('', '', '', '/scan-pay', 'onShortcutResult')

// Custom shortcut
Atlayo.system.requestAppShortcut(
  'scan_pay',
  'Scan & Pay',
  iconBase64Png,
  '/scan-pay',
  'onShortcutResult'
)

{
  "action": "requestAppShortcut",
  "success": true,
  "id": "scan_pay",
  "shortcutId": "my_app_scan_pay"
}

// Use mini-app defaults for id, label, and icon
Atlayo.system.requestAppShortcut('', '', '', '/scan-pay', function(result) {
    if (result.success) Atlayo.UI.toast('Shortcut requested');
});

Atlayo.system.requestAppShortcut(
    'scan_pay',
    'Scan & Pay',
    iconBase64Png,
    '/scan-pay',
    function(result) {
        if (result.success) Atlayo.UI.toast('Shortcut requested');
        else Atlayo.UI.alert(result.error || 'Could not create shortcut');
    }
);

document.addEventListener('atlayo-shortcut-action', function(e) {
    if (e.detail.targetAction === '/scan-pay') openScanAndPayScreen();
});

Opens the native OS share sheet so mini-apps can share text, URLs, images, and files with external apps (WhatsApp, Signal, Email, etc.).

const files = JSON.stringify([{
  name: 'receipt.jpg',
  mimeType: 'image/jpeg',
  data: receiptBase64
}]);

Atlayo.system.shareSystemSheet(
  'Your receipt',
  'Thanks for your order!',
  'https://shop.example.com/orders/123',
  files
)

{
  "action": "shareSystemSheet",
  "success": true
}

const files = JSON.stringify([{
    name: 'receipt.jpg',
    mimeType: 'image/jpeg',
    data: receiptBase64
}]);

Atlayo.system.shareSystemSheet(
    'Your receipt',
    'Thanks for your order!',
    'https://shop.example.com/orders/123',
    files,
    function(result) {
        if (!result.success) Atlayo.UI.alert(result.error || 'Share failed');
    }
);

Opens a native scanner UI backed by Google ML Kit. Supports two modes via mode in the config: barcode (CameraX + ML Kit barcode scanning — fast QR/barcode decode on background threads) and document (ML Kit Document Scanner — scan physical pages to digital JPEG/PDF with auto edge detection, cropping, and filters). Unlike openBarcodeScanner(), no camera frames are streamed into the WebView.

// Barcode / QR
Atlayo.system.showNativeScanner({
  mode: 'barcode',
  prompt: 'Scan payment QR',
  formats: ['qr']
})

// Searchable document PDF (selectable text)
Atlayo.system.showNativeScanner({
  mode: 'document',
  searchablePdf: true,
  ocrLanguage: 'latin',
  scannerMode: 'full'
})

// Barcode mode
{
  "action": "showNativeScanner",
  "mode": "barcode",
  "success": true,
  "text": "https://pay.example.com/abc123",
  "format": "QR_CODE"
}

// Document mode
{
  "action": "showNativeScanner",
  "mode": "document",
  "success": true,
  "pageCount": 2,
  "pages": [
    { "index": 0, "mimeType": "image/jpeg", "data": "<base64>" }
  ],
  "pdf": {
    "mimeType": "application/pdf",
    "pageCount": 2,
    "searchable": true,
    "data": "<base64>"
  }
}

// QR / barcode
Atlayo.system.showNativeScanner({ mode: 'barcode', formats: ['qr'] }, function(result) {
    if (result.success) handleQrPayload(result.text);
});

// Searchable PDF — text can be selected/copied in PDF viewers
Atlayo.system.showNativeScanner({
    mode: 'document',
    searchablePdf: true,
    ocrLanguage: 'latin'
}, function(result) {
    if (result.success && result.pdf) {
        Atlayo.system.downloadFile('scan.pdf', 'application/pdf', result.pdf.data);
    }
});

Saves a file to the device's public Downloads folder. Accepts base64-encoded file content (optionally with a data:…;base64, prefix). On Android 10+ uses MediaStore scoped storage; no storage permission is required on modern devices.

Atlayo.system.downloadFile(
  'scan-2026-04-12.pdf',
  'application/pdf',
  pdfBase64
)

{
  "action": "downloadFile",
  "success": true,
  "name": "scan-2026-04-12.pdf",
  "mimeType": "application/pdf",
  "size": 48231,
  "path": "Download/scan-2026-04-12.pdf",
  "uri": "content://..."
}

// Save scanned document PDF to Downloads
Atlayo.system.showNativeScanner({
    mode: 'document',
    resultFormats: ['pdf']
}, function(scan) {
    if (scan.success && scan.pdf) {
        Atlayo.system.downloadFile(
            'document.pdf',
            'application/pdf',
            scan.pdf.data,
            function(dl) {
                if (dl.success) Atlayo.UI.toast('Saved to Downloads');
            }
        );
    }
});

Generate an asymmetric key pair in hardware-backed secure storage. The private key never leaves the device's secure hardware.

Atlayo.crypto.generateSecureKeyPair('wallet_signing_key', 'EC')

{
  "action": "generateSecureKeyPair",
  "success": true,
  "alias": "atlayo_my_app_wallet_signing_key",
  "algorithm": "EC",
  "publicKey": "<base64 SPKI>",
  "publicKeyFormat": "SPKI",
  "alreadyExists": false
}

Atlayo.crypto.generateSecureKeyPair('wallet_signing_key', 'EC', function(result) {
    if (result.success) {
        console.log('Public key:', result.publicKey);
        registerPublicKeyWithBackend(result.publicKey);
    } else {
        Atlayo.UI.alert(result.error || 'Key generation failed');
    }
});

Sign a cryptographic message or transaction payload using a hardware-protected key. Biometric authentication (fingerprint or face unlock) is required before signing.

Atlayo.crypto.signPayloadNatively('wallet_signing_key', {
  payload: JSON.stringify({ to: '0xABC...', amount: '1.5', nonce: 42 }),
  title: 'Sign transaction',
  subtitle: 'Authorize transfer of 1.5 tokens'
})

{
  "action": "signPayloadNatively",
  "success": true,
  "signature": "<base64>",
  "algorithm": "SHA256withECDSA"
}

const txPayload = JSON.stringify({
    to: '0xABC...',
    amount: '1.5',
    nonce: 42
});

Atlayo.crypto.signPayloadNatively('wallet_signing_key', {
    payload: txPayload,
    title: 'Sign transaction',
    subtitle: 'Authorize transfer of 1.5 tokens'
}, function(result) {
    if (result.success) submitSignedTransaction(txPayload, result.signature);
    else Atlayo.UI.alert(result.error || 'Signing cancelled');
});

Get current GPS coordinates. Requires gps permission.

{ "callback": "onLocationData" }

{
  "latitude": 50.0755, "longitude": 14.4378,
  "accuracy": 12.5, "altitude": 200,
  "timestamp": 1718640000000
}

AtlayoInterface.getLocation(JSON.stringify({ callback: "onLocationData" }));
window.onLocationData = function(result) {
    if (result.error) console.error(result.error);
    else console.log("Lat:", result.latitude, "Lng:", result.longitude);
};

Start accelerometer and gyroscope streaming (~60 ms interval).

{ "callback": "onMotionData" }

{
  "action": "motionSensorData", "success": true,
  "data": {
    "accelerometer": { "x": 0.1, "y": 9.8, "z": 0.2 },
    "gyroscope": { "x": 0.01, "y": 0.0, "z": 0.0 }
  }
}

AtlayoInterface.startMotionSensor(JSON.stringify({ callback: "onMotionData" }));
window.onMotionData = function(result) {
    if (result.success) console.log("Tilt X:", result.data.accelerometer.x);
};

Stop motion sensor streaming.

{}

void

AtlayoInterface.stopMotionSensor(JSON.stringify({}));

Open camera to scan a barcode or QR code.

• AZTEC
• CODABAR
• CODE_39
• CODE_93
• CODE_128
• DATA_MATRIX
• EAN_8
• EAN_13
• ITF
• MAXICODE
• PDF_417
• QR_CODE
• RSS_14
• UPC_A
• UPC_E
• UPC_EAN_EXTENSION

The detected format is returned in the format response field.

{ "callback": "onBarcodeScanned" }

{
  "action": "scanBarcode", "success": true,
  "text": "https://example.com", "format": "QR_CODE"
}

AtlayoInterface.scanBarcode(JSON.stringify({ callback: "onBarcodeScanned" }));
window.onBarcodeScanned = function(result) {
    if (result.success) document.getElementById('scanResult').textContent = result.text;
};

Initiate fingerprint or face recognition.

{ "callback": "onBiometricAuth" }

{ "action": "authenticateBiometric", "success": true }

AtlayoInterface.authenticateBiometric(JSON.stringify({ callback: "onBiometricAuth" }));
window.onBiometricAuth = function(result) {
    if (result.success) unlockSecureContent();
    else Atlayo.UI.alert('Auth failed: ' + result.error);
};

Open native contact picker (cloud-synced Atlayo contacts).

{}

{
  "action": "selectContact", "success": true,
  "contact": {
    "displayName": "Jane Doe",
    "phoneNumbers": [{ "value": "+420123456789", "type": "mobile" }]
  }
}

AtlayoInterface.selectContact(JSON.stringify({ callback: "onContactSelected" }));
window.onContactSelected = function(result) {
    if (result.success && result.contact) {
        console.log(result.contact.displayName, result.contact.phoneNumbers[0].value);
    }
};

Check if a specific hardware feature is supported and enabled on the device.

"bluetooth"

{
  "hardware": "bluetooth",
  "supported": true,
  "enabled": false
}

AtlayoInterface.getHardwareStatus("bluetooth");

window.onHardwareStatus = function(status) {
    if (status.hardware === "bluetooth" && status.supported && !status.enabled) {
        // Prompt user to enable Bluetooth
    }
};

Open the Android system settings page to let the user enable the specified hardware feature.

"bluetooth"

void

AtlayoInterface.enableHardware("bluetooth");

Start listening for NFC tags.

{ "callback": "onNfcDiscovered" }

{ "id": "04A1B2C3", "techs": ["android.nfc.tech.NfcA"] }

Connect to discovered NFC-A tag.

{ "callback": "onNfcConnected" }

{ "success": true, "message": "Connected" }

Send APDU command to NFC-A tag.

{ "data": "FFCA000000", "callback": "onNfcTransceiveResult" }

{ "response": "0400" }

Close NFC-A connection.

void

Connect to MifareClassic tag.

{ "callback": "onMifareConnected" }

{ "success": true }

Authenticate MifareClassic sector with Key A.

{ "sector": 0, "key": "FFFFFFFFFFFF" }

{ "success": true }

Read 16-byte block (authenticate sector first).

{ "block": 4 }

{ "data": "00112233445566778899AABBCCDDEEFF" }

Write 16-byte block (32 hex chars).

{ "block": 4, "data": "00112233445566778899AABBCCDDEEFF" }

{ "success": true }

Close MifareClassic connection.

void

Connect to IsoDep tag (smart cards, EMV, passports).

{}

{ "success": true }

Send APDU to IsoDep tag.

{ "data": "00A4040007A0000000031010" }

{ "response": "9000" }

Close IsoDep connection.

void

Reads supported Application IDs (AIDs) from a connected IsoDep card by querying the PPSE directory.

{ "callback": "onIsoDepAidsResult" }

{ "success": true, "aids": ["A0000000031010", "A0000000041010"] }

AtlayoInterface.readIsoDepAids(JSON.stringify({ callback: "onMyAidsResult" }));
window.onMyAidsResult = function(result) {
    console.log(result.aids);
};

Stop NFC tag discovery.

void

Host Card Emulation — phone acts as NFC card. Reader must SELECT AID F0010203040506.

{ "data": "48656C6C6F", "callback": "onNfcEmulationResult" }

{ "action": "cardRead" }  // when reader taps phone

Stop NFC card emulation.

void

Initializes the Bluetooth adapter. If permissions are missing, prompts the user.

{ "callback": "onBluetoothAdapterOpened" }

{ "success": true, "message": "Bluetooth adapter initialized" }

Starts scanning for nearby BLE devices. Calls the callback each time a device is found. Optionally, pass an array of `services` (UUIDs) to filter the scan.

{ "services": ["180D", "180F"], "callback": "onBluetoothDeviceFound" }

{ "device": { "name": "SmartBulb", "deviceId": "00:11:22:33:44:55", "rssi": -65 } }

Stops the ongoing BLE device scan.

{ "callback": "onBluetoothDiscoveryStopped" }

{ "success": true, "message": "Discovery stopped" }

Connects to a specific BLE device by its deviceId (MAC address).

{ "deviceId": "00:11:22:33:44:55", "callback": "onBLEConnectionStateChange" }

{ "deviceId": "00:11:22:33:44:55", "connected": true, "status": 0 }

Writes data to a specific characteristic on a connected BLE device. The value must be encoded as a Base64 string.

{ 
  "deviceId": "00:11:22:33:44:55", 
  "serviceId": "0000180d-0000-1000-8000-00805f9b34fb",
  "characteristicId": "00002a37-0000-1000-8000-00805f9b34fb",
  "value": "AQI=", // Base64 encoded payload
  "callback": "onWriteComplete"
}

{ "success": true, "message": "Write initiated" }

Global callback triggered when a characteristic's value changes (notifications/indications). Ensure you assign this function in your mini-app's global scope.

{ 
  "deviceId": "00:11:22:33:44:55", 
  "serviceId": "0000180d-0000-1000-8000-00805f9b34fb",
  "characteristicId": "00002a37-0000-1000-8000-00805f9b34fb",
  "value": "AQI=" // Base64 encoded payload
}

Open full-screen camera overlay. Callback runs once when user sends or cancels. Use fullScreen: false to keep the themed status bar and lay the camera out below it.

// Default: edge-to-edge under transparent status bar
AtlayoInterface.openCamera(function(result) { ... });

// Keep status bar / inset layout
AtlayoInterface.openCamera({ fullScreen: false }, function(result) { ... });

{
  "success": true,
  "type": "image",
  "mimeType": "image/jpeg",
  "file": ""
}
// Cancelled:
{ "success": false, "error": "Cancelled" }

if (typeof AtlayoInterface.openCamera === 'function') {
    AtlayoInterface.openCamera({ fullScreen: true }, function(result) {
        if (!result.success) return;
        const url = URL.createObjectURL(result.file);
        document.getElementById('preview').src = url;
    });
} else {
    Atlayo.UI.alert('Camera not available on this platform');
}

Charge the user via wallet balance. Requires biometric authentication.

{
  "amount": 10.50,
  "api_key": "pk_YOUR_KEY",
  "description": "Purchase item XYZ",
  "recipient": "My Store"
}

{
  "success": true,
  "transactionId": 12345,
  "payment_intent_id": "pi_...",
  "timestamp": 1718640000000
}

atlayo_pay({
    amount: 10.50,
    api_key: 'pk_YOUR_KEY',
    description: 'Purchase item XYZ',
    callback: function(result) {
        if (result.success) {
            Atlayo.UI.alert('Payment successful!', { title: 'Success' });
        } else {
            Atlayo.UI.alert('Failed: ' + result.error, { title: 'Error' });
        }
    }
});

Send a push notification to a specific user of your mini-app.

{
  "app_id": "my-awesome-app",
  "user_token": "",
  "notification": {
    "title": "Item expiring soon",
    "body": "Milk expires in 2 days",
    "query_params": "fridge=abc123",
    "sound": true,
    "vibrate": true,
    "data": { "type": "expiry_soon" }
  }
}

{
  "success": true,
  "message": "Notification sent successfully via WebSocket and FCM",
  "methods": ["WebSocket", "FCM"],
  "delivered": true
}

// Register user token in mini-app
AtlayoInterface.requestPermissions(JSON.stringify(['notifications']));
window.onPermissionsGranted = function() {
    const token = JSON.parse(AtlayoInterface.getSystemInfo()).token;
    fetch('https://your-backend.example/api/register', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ token })
    });
};

// cURL from your server
curl -X POST "https://atlayo.com/developer_portal/api/v1/push_notification.php" \
  -H "Content-Type: application/json" \
  -H "X-Atlayo-Server-Key: atlayo_sk_YOUR_KEY" \
  -d '{"app_id":"my-app","user_token":"TOKEN","notification":{"title":"Hi","body":"Hello"}}' 

Base dialog component. alert and confirm are built on top of this.

Dialog wrapper with .hide(callback) to close manually.

const dlg = Atlayo.UI.dialog({
    title: 'Confirm action',
    content: 'Proceed with this operation?',
    buttons: [
        { label: 'Cancel', type: 'default' },
        { label: 'OK', type: 'primary', onClick: function() { console.log('ok'); } }
    ]
});

Show a native-style alert dialog.

Atlayo.UI.alert("Saved!", { title: "Success", buttons: [{ label: "OK", type: "primary" }] })

void

alert("Hello!");  // uses Atlayo.UI.alert automatically

Atlayo.UI.alert("Do you want to continue?", {
    title: "Confirm",
    buttons: [
        { label: "Cancel", type: "default" },
        { label: "OK", type: "primary" }
    ]
});

Show a confirmation dialog with action buttons.

Atlayo.UI.confirm("Delete this item?", { title: "Delete", buttons: [...] })

void

Atlayo.UI.confirm("Are you sure?", {
    title: "Delete Item",
    buttons: [
        { label: "Cancel", type: "default" },
        { label: "Delete", type: "warn", onClick: function() { deleteItem(); } }
    ]
});

Show a temporary toast at the top of the screen.

Atlayo.UI.toast("Settings saved", { duration: 2000 })

void

Atlayo.UI.toast("Connection successful", { duration: 3000 });
Atlayo.UI.toast("Saved!", { duration: 2000, callback: function() { console.log('closed'); } });

Show loading indicator. Returns a wrapper with .hide(callback).

const loading = Atlayo.UI.loading("Loading...");

loading.hide(callback) — call to dismiss

const hideLoading = Atlayo.UI.loading("Loading data...");
fetch('/api/data').then(r => r.json()).then(data => {
    hideLoading.hide();
    renderData(data);
});

Show a bottom action sheet. menus are the primary options; actions is typically a cancel row at the bottom.

Atlayo.UI.actionSheet([
    { label: "Take Photo", onClick: function() {
        AtlayoInterface.openCamera(function(r) {
            if (r.success) Atlayo.UI.toast('Captured!');
        });
    }},
    { label: "Choose from Gallery", onClick: openGallery }
], [
    { label: "Cancel", onClick: function() {} }
], { title: "Select Image Source" });

Show a temporary tip banner at the top of the screen (typically for validation errors).

Atlayo.UI.topTips('Please fill in all required fields', 3000);
const tip = Atlayo.UI.topTips('Invalid email', { duration: 3000, callback: function() {} });
tip.hide();  // dismiss manually

Multi-column picker for single, multi-column, or cascading selections. Each item: { label, value, disabled?, children? }.

// Single column
Atlayo.UI.picker([
    { label: 'Option A', value: 0 },
    { label: 'Option B', value: 1 }
], { defaultValue: [1], onConfirm: function(result) { console.log(result); } });

// Cascading (e.g. category → subcategory)
Atlayo.UI.picker([
    { label: 'Food', value: 0, children: [{ label: 'Pizza', value: 1 }] },
    { label: 'Drink', value: 1, children: [{ label: 'Water', value: 2 }] }
], { defaultValue: [0, 1], onConfirm: function(r) { console.log(r); } });

Date picker for year, month, and day selection.

Atlayo.UI.datePicker({
    start: 1990,
    end: 2030,
    defaultValue: [1991, 6, 9],
    onConfirm: function(result) { console.log(result); }  // [1991, 6, 9]
});

Form validation helpers. Inputs use required, pattern, emptyTips, and notMatchTips attributes.

<form id="myForm">
  <input type="tel" required pattern="[0-9]{11}"
         emptyTips="Enter phone" notMatchTips="Invalid phone">
</form>

Atlayo.UI.form.validate('#myForm', function(error) {
    if (!error) {
        const loading = Atlayo.UI.loading('Submitting...');
        submitForm().finally(function() { loading.hide(); });
    }
}, { regexp: { IDNUM: /^\d{17}[\dXx]$/ } });