@playq/core 0.2.77

package/dist/helper/faker/modules/mobile.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMobileNumber = generateMobileNumber;
+// src/helper/faker/modules/mobile.ts
+const faker_1 = require("@faker-js/faker");
+function generateMobileNumber(options) {
+    const { countryCode = 'AU', dialCodePrefix = true } = options || {};
+    switch (countryCode.toUpperCase()) {
+        case "AU": {
+            const prefix = "04";
+            const digits = faker_1.faker.string.numeric(8);
+            return dialCodePrefix ? `+61${prefix.slice(1)}${digits}` : `${prefix}${digits}`;
+        }
+        case "SG": {
+            const allowedPrefixes = ["855", "955"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(5);
+            return dialCodePrefix ? `+65${prefix}${digits}` : `${prefix}${digits}`;
+        }
+        case "IN": {
+            const allowedPrefixes = ["6", "7", "8", "9"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(9);
+            return dialCodePrefix ? `+91${prefix}${digits}` : `${prefix}${digits}`;
+        }
+        case "US": {
+            const allowedPrefixes = ["2", "3", "4", "5", "6", "7", "8", "9"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(7);
+            return dialCodePrefix ? `+1${prefix}${digits}` : `${prefix}${digits}`;
+        }
+        case "UK": {
+            const allowedPrefixes = ["7", "8", "9"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(8);
+            return dialCodePrefix ? `+44${prefix}${digits}` : `${prefix}${digits}`;
+        }
+        case "CA": {
+            const allowedPrefixes = ["2", "3", "4", "5", "6", "7", "8", "9"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(7);
+            return dialCodePrefix ? `+1${prefix}${digits}` : `${prefix}${digits}`;
+        }
+        case "NZ": {
+            const allowedPrefixes = ["2", "3", "4", "5", "6", "7", "8", "9"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(7);
+            return dialCodePrefix ? `+64${prefix}${digits}` : `${prefix}${digits}`;
+        }
+        case "PH": {
+            const allowedPrefixes = ["8", "9"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(7);
+            return dialCodePrefix ? `+63${prefix}${digits}` : `${prefix}${digits}`;
+        }
+        default:
+            throw new Error(`Unsupported country code: ${countryCode}`);
+    }
+}

package/dist/helper/faker/modules/nric.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generate a valid Singapore NRIC or FIN number according to official NRIC/FIN checksum rules.
+ *
+ * Rules:
+ *  - The prefix is 'S' or 'T' for Singaporeans/PRs, 'F' or 'G' for foreigners.
+ *  - 'S' and 'F' are for those registered before 2000, 'T' and 'G' for 2000 and after.
+ *  - The 7 digits: first two are year of birth/registration, next five are random.
+ *  - The checksum character is calculated using weights [2,7,6,5,4,3,2] and a modulo-11 algorithm.
+ *  - For 'T' and 'G', add 4 to the sum before modulo.
+ *  - The checksum character set differs for citizen/PR ('S','T') and foreigner ('F','G') prefixes.
+ * See: https://en.wikipedia.org/wiki/National_Registration_Identity_Card#Structure
+ */
+/**
+ * Options for NRIC generation.
+ */
+export interface NRICOptions {
+    prefix?: string;
+    yearOfBirth?: number;
+}
+/**
+ * Generate a valid Singapore NRIC or FIN number according to official NRIC/FIN checksum rules.
+ * @param options - Options for NRIC generation.
+ * @returns A valid NRIC string.
+ */
+export declare function generateNRIC(options?: NRICOptions): string;
+/**
+    Function to extract the year from an NRIC number
+    @param nric - The NRIC number as a string
+    @returns The year of birth as a number, or null if the NRIC is invalid
+ */
+declare function getYearFromNRIC(nric: string): number | null;
+export { getYearFromNRIC };

package/dist/helper/faker/modules/nric.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNRIC = generateNRIC;
+exports.getYearFromNRIC = getYearFromNRIC;
+const faker_1 = require("@faker-js/faker");
+const ST_CHECKSUM_CHARS = ["J", "Z", "I", "H", "G", "F", "E", "D", "C", "B", "A"];
+const FG_CHECKSUM_CHARS = ["X", "W", "U", "T", "R", "Q", "P", "N", "M", "L", "K"];
+function calculateNRICChecksum(prefix, digits) {
+    const WEIGHTS = [2, 7, 6, 5, 4, 3, 2];
+    const digitArr = digits.split('').map(Number);
+    let sum = digitArr.reduce((acc, digit, idx) => acc + digit * WEIGHTS[idx], 0);
+    if (prefix === 'T' || prefix === 'G') {
+        sum += 4;
+    }
+    const remainder = sum % 11;
+    if (prefix === 'S' || prefix === 'T') {
+        return ST_CHECKSUM_CHARS[remainder];
+    }
+    else {
+        return FG_CHECKSUM_CHARS[remainder];
+    }
+}
+/**
+ * Generate a valid Singapore NRIC or FIN number according to official NRIC/FIN checksum rules.
+ * @param options - Options for NRIC generation.
+ * @returns A valid NRIC string.
+ */
+function generateNRIC(options = {}) {
+    let { prefix, yearOfBirth } = options;
+    yearOfBirth = yearOfBirth ? Number(yearOfBirth) : undefined;
+    if (typeof yearOfBirth === 'number' && yearOfBirth > new Date().getFullYear()) {
+        throw new Error(`❌ yearOfBirth ${yearOfBirth} is in the future.`);
+    }
+    let resolvedPrefix;
+    if (prefix) {
+        resolvedPrefix = prefix;
+    }
+    else if (typeof yearOfBirth === 'number') {
+        resolvedPrefix = yearOfBirth >= 2000 ? 'T' : 'S';
+    }
+    else {
+        resolvedPrefix = faker_1.faker.helpers.arrayElement(['S', 'T', 'F', 'G']);
+    }
+    if (!['S', 'T', 'F', 'G'].includes(resolvedPrefix)) {
+        console.warn(`⚠️ Invalid prefix "${resolvedPrefix}" — choosing random valid prefix.`);
+        resolvedPrefix = faker_1.faker.helpers.arrayElement(['S', 'T', 'F', 'G']);
+    }
+    let digits;
+    if (typeof yearOfBirth === 'number') {
+        const yearDigits = String(yearOfBirth).slice(-2);
+        const randomDigits = faker_1.faker.string.numeric({ length: 5, allowLeadingZeros: true });
+        digits = `${yearDigits}${randomDigits}`;
+    }
+    else {
+        digits = faker_1.faker.string.numeric({ length: 7, allowLeadingZeros: true });
+    }
+    const checksum = calculateNRICChecksum(resolvedPrefix, digits);
+    return `${resolvedPrefix}${digits}${checksum}`;
+}
+/**
+    Function to extract the year from an NRIC number
+    @param nric - The NRIC number as a string
+    @returns The year of birth as a number, or null if the NRIC is invalid
+ */
+function getYearFromNRIC(nric) {
+    if (!/^[STFG]\d{7}[A-Z]$/.test(nric)) {
+        console.warn(`❌ Invalid NRIC format: ${nric}`);
+        return null;
+    }
+    const prefix = nric.charAt(0).toUpperCase();
+    const yearDigits = parseInt(nric.slice(1, 3), 10);
+    if (isNaN(yearDigits))
+        return null;
+    switch (prefix) {
+        case "S": // Born before 2000 (Singaporean)
+        case "F": // Foreigner before 2000
+            return 1900 + yearDigits;
+        case "T": // Born in or after 2000 (Singaporean)
+        case "G": // Foreigner in or after 2000
+            return 2000 + yearDigits;
+        default:
+            return null;
+    }
+}

package/dist/helper/faker/modules/passport.d.ts

@@ -0,0 +1,3 @@
+export declare function generatePassportNumber(options?: {
+    countryCode?: string;
+}): string;

package/dist/helper/faker/modules/passport.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePassportNumber = generatePassportNumber;
+// src/helper/faker/modules/passport.ts
+const faker_1 = require("@faker-js/faker");
+function generatePassportNumber(options) {
+    const { countryCode = 'AU' } = options;
+    switch (countryCode.toUpperCase()) {
+        case "IN":
+            return `${faker_1.faker.string.alpha({
+                length: 1,
+                casing: "upper",
+            })}${faker_1.faker.string.numeric(7)}`;
+        case "UK":
+            return `${faker_1.faker.string.alpha({
+                length: 2,
+                casing: "upper",
+            })}${faker_1.faker.string.numeric(7)}`;
+        case "US":
+            return faker_1.faker.string.numeric(9);
+        case "AU": {
+            const allowedPrefixes = ["PA", "PB", "PC", "PD", "PE", "PF", "PU", "PW", "PX", "PZ"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(7);
+            return `${prefix}${digits}`;
+        }
+        case "SG": {
+            const allowedPrefixes = ["E", "K", "S"];
+            const prefix = faker_1.faker.helpers.arrayElement(allowedPrefixes);
+            const digits = faker_1.faker.string.numeric(7);
+            return `${prefix}${digits}`;
+        }
+        default:
+            throw new Error(`Unsupported country code: ${countryCode}`);
+    }
+}

package/dist/helper/faker/modules/person.d.ts

@@ -0,0 +1,14 @@
+interface PersonNameOptions {
+    gender?: 'male' | 'female';
+    withPrefix?: boolean;
+    maxLength?: number;
+}
+export declare function generatePersonFullName(options?: PersonNameOptions): string;
+interface BirthDateOptions {
+    min?: number;
+    max?: number;
+    year?: number;
+    format?: 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'YYYY-MM-DD' | 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'YYYY/MM/DD' | 'DD-MM-YY' | 'MM-DD-YY' | 'YY-MM-DD' | 'DD/MM/YY' | 'MM/DD/YY' | 'YY/MM/DD';
+}
+export declare function generateBirthDate(options?: BirthDateOptions): string;
+export {};

package/dist/helper/faker/modules/person.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePersonFullName = generatePersonFullName;
+exports.generateBirthDate = generateBirthDate;
+const faker_1 = require("@faker-js/faker");
+function generatePersonFullName(options = {}) {
+    const { gender, withPrefix = false, maxLength } = options;
+    let firstName = faker_1.faker.person.firstName(gender);
+    let lastName = faker_1.faker.person.lastName(gender);
+    let fullName = withPrefix
+        ? `${faker_1.faker.person.prefix(gender)} ${firstName} ${lastName}`
+        : `${firstName} ${lastName}`;
+    if (maxLength && fullName.length > maxLength) {
+        // Try trimming last name first, then first name
+        lastName = lastName.slice(0, Math.max(1, Math.floor((maxLength - firstName.length - 1))));
+        fullName = withPrefix
+            ? `${faker_1.faker.person.prefix(gender)} ${firstName} ${lastName}`
+            : `${firstName} ${lastName}`;
+        if (fullName.length > maxLength) {
+            firstName = firstName.slice(0, Math.max(1, maxLength - lastName.length - 1));
+            fullName = withPrefix
+                ? `${faker_1.faker.person.prefix(gender)} ${firstName} ${lastName}`
+                : `${firstName} ${lastName}`;
+        }
+    }
+    return fullName.replace(/-/g, ' ');
+}
+function generateBirthDate(options = {}) {
+    const { min = 18, max = 65, year, format = 'DD-MM-YYYY' } = options;
+    let date;
+    // const date = faker.date.birthdate({ min, max, mode: 'age' });
+    if (year) {
+        // Generate a random date in the given year
+        const month = faker_1.faker.number.int({ min: 0, max: 11 });
+        const day = faker_1.faker.number.int({ min: 1, max: 28 }); // Safe for all months
+        date = new Date(year, month, day);
+    }
+    else {
+        date = faker_1.faker.date.birthdate({ min, max, mode: 'age' });
+    }
+    const dd = String(date.getDate()).padStart(2, '0');
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const yyyy = date.getFullYear();
+    const yy = String(yyyy).slice(-2);
+    switch (format) {
+        case 'YYYY-MM-DD':
+            return `${yyyy}-${mm}-${dd}`;
+        case 'YYYY/MM/DD':
+            return `${yyyy}/${mm}/${dd}`;
+        case 'MM-DD-YYYY':
+            return `${mm}-${dd}-${yyyy}`;
+        case 'MM/DD/YYYY':
+            return `${mm}/${dd}/${yyyy}`;
+        case 'DD/MM/YYYY':
+            return `${dd}/${mm}/${yyyy}`;
+        case 'DD-MM-YYYY':
+            return `${dd}-${mm}-${yyyy}`;
+        case 'DD-MM-YY':
+            return `${dd}-${mm}-${yy}`;
+        case 'MM-DD-YY':
+            return `${mm}-${dd}-${yy}`;
+        case 'YY-MM-DD':
+            return `${yy}-${mm}-${dd}`;
+        case 'DD/MM/YY':
+            return `${dd}/${mm}/${yy}`;
+        case 'MM/DD/YY':
+            return `${mm}/${dd}/${yy}`;
+        case 'YY/MM/DD':
+            return `${yy}/${mm}/${dd}`;
+        default:
+            return `${dd}-${mm}-${yyyy}`;
+    }
+}

package/dist/helper/faker/modules/postcode.d.ts

@@ -0,0 +1,6 @@
+interface PostCodeOptions {
+    countryCode?: string;
+    stateCode?: string;
+}
+export declare function getValidPostCode(options?: PostCodeOptions): string;
+export {};

package/dist/helper/faker/modules/postcode.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidPostCode = getValidPostCode;
+// src/helper/faker/modules/passport.ts
+const faker_1 = require("@faker-js/faker");
+const postcodes_valid_sg_json_1 = __importDefault(require("./data/postcodes_valid_sg.json"));
+function getValidPostCode(options = {}) {
+    // export function getValidPostCode(countryCode: string = "AU", stateCode?: string): string {
+    const { countryCode = "AU", stateCode = "" } = options;
+    switch (countryCode.toUpperCase()) {
+        case "SG": {
+            return faker_1.faker.helpers.arrayElement(postcodes_valid_sg_json_1.default);
+        }
+        case "AU":
+            const AU_STATE_RANGES = {
+                "NSW": [2000, 2999],
+                "ACT": [2600, 2639],
+                "VIC": [3000, 3999],
+                "QLD": [4000, 4999],
+                "SA": [5000, 5799],
+                "WA": [6000, 6797],
+                "TAS": [7000, 7799],
+                "NT": [800, 899]
+            };
+            if (stateCode) {
+                const range = AU_STATE_RANGES[stateCode.toUpperCase()];
+                if (!range) {
+                    throw new Error(`Unsupported state code: ${stateCode}`);
+                }
+                const [min, max] = range;
+                const postcodeLength = max.toString().length;
+                const postcode = faker_1.faker.number.int({ min, max }).toString().padStart(postcodeLength, '0');
+                return postcode;
+            }
+            // If no state is specified, choose a random state and generate a postcode
+            const randomState = faker_1.faker.helpers.arrayElement(Object.keys(AU_STATE_RANGES));
+            const [min, max] = AU_STATE_RANGES[randomState];
+            const postcodeLength = max.toString().length;
+            const postcode = faker_1.faker.number.int({ min, max }).toString().padStart(postcodeLength, '0');
+            return postcode;
+        default:
+            throw new Error(`Unsupported country code: ${countryCode}`);
+    }
+}

package/dist/helper/fixtures/locAggregate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Dynamically builds the `loc` namespace from the consumer project.
+ * - Scans PLAYQ_PROJECT_ROOT/resources/locators for *.loc.ts or *.ts files
+ * - Imports each module (requires ts-node registration in the child process)
+ * - Collects named exports and default object keys into a single namespace
+ */
+export declare function getLocNamespace(): Record<string, any>;

package/dist/helper/fixtures/locAggregate.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocNamespace = getLocNamespace;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Dynamically builds the `loc` namespace from the consumer project.
+ * - Scans PLAYQ_PROJECT_ROOT/resources/locators for *.loc.ts or *.ts files
+ * - Imports each module (requires ts-node registration in the child process)
+ * - Collects named exports and default object keys into a single namespace
+ */
+function getLocNamespace() {
+    const base = safeProjectRoot();
+    const dir = path.resolve(base, 'resources/locators');
+    const out = {};
+    if (!fs.existsSync(dir)) {
+        // Not an error—project may not provide locators
+        return out;
+    }
+    const files = fs.readdirSync(dir)
+        .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
+        .map(f => path.join(dir, f));
+    for (const file of files) {
+        try {
+            // Clear module cache to reflect changes between runs
+            delete require.cache[require.resolve(file)];
+            const mod = require(file);
+            // Prefer named exports: export const lambdatest = {...}
+            for (const key of Object.keys(mod)) {
+                if (key === 'default')
+                    continue;
+                out[key] = mod[key];
+            }
+            // If default export is an object (e.g., { lambdatest: {...} }), merge keys
+            const def = mod.default;
+            if (def && typeof def === 'object') {
+                for (const [k, v] of Object.entries(def)) {
+                    // Do not overwrite explicitly named exports
+                    if (!(k in out))
+                        out[k] = v;
+                }
+            }
+        }
+        catch (e) {
+            console.warn(`⚠️ Failed to load loc module ${file}:`, (e === null || e === void 0 ? void 0 : e.message) || e);
+        }
+    }
+    return out;
+}
+function safeProjectRoot() {
+    if (process.env.PLAYQ_PROJECT_ROOT)
+        return process.env.PLAYQ_PROJECT_ROOT;
+    // Walk up to find a package.json as fallback
+    let current = process.cwd();
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, 'package.json')))
+            return current;
+        current = path.dirname(current);
+    }
+    return process.cwd();
+}

package/dist/helper/fixtures/logFixture.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from 'winston';
+export declare const logFixture: {
+    init(scenarioName: string): void;
+    get(): Logger;
+    setLogger(log: Logger): void;
+    getLogger(): Logger;
+    attach(name: string, data: Buffer, type?: string): Promise<void>;
+};

package/dist/helper/fixtures/logFixture.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFixture = void 0;
+const winston_1 = require("winston");
+const logger_1 = require("../util/logger");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+let logger;
+exports.logFixture = {
+    init(scenarioName) {
+        logger = (0, winston_1.createLogger)((0, logger_1.options)(scenarioName));
+    },
+    get() {
+        if (!logger)
+            throw new Error("Logger not initialized!");
+        return logger;
+    },
+    setLogger(log) {
+        logger = log;
+    },
+    getLogger() {
+        return logger;
+    },
+    async attach(name, data, type = 'application/octet-stream') {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const ext = type.includes('png') ? 'png' : type.includes('jpg') ? 'jpg' : 'txt';
+        const filename = `${timestamp}-${name.replace(/\s+/g, '_')}.${ext}`;
+        const attachmentDir = path_1.default.resolve('logs', 'attachments');
+        const filePath = path_1.default.join(attachmentDir, filename);
+        fs_1.default.mkdirSync(attachmentDir, { recursive: true });
+        fs_1.default.writeFileSync(filePath, data);
+        logger.info(`📎 Attached file: ${filePath}`);
+    }
+};
+// // src/hooks/logFixture.ts
+// import { Logger, createLogger, format, transports } from 'winston';
+// let logger: Logger;
+// export const logFixture = {
+//   init(scenarioName: string): void {
+//     logger = createLogger({
+//       level: 'info',
+//       format: format.combine(
+//         format.timestamp(),
+//         format.printf(({ timestamp, level, message }) => `[${timestamp}] ${level}: ${message}`)
+//       ),
+//       transports: [new transports.Console()]
+//     });
+//   },
+//   get(): Logger {
+//     if (!logger) throw new Error("Logger not initialized!");
+//     return logger;
+//   }
+// };

package/dist/helper/fixtures/webFixture.d.ts

@@ -0,0 +1,19 @@
+import type { Browser, BrowserContext, Page, Frame } from "playwright";
+export declare const webFixture: {
+    pages: Map<string, Page>;
+    frames: Map<string, Frame>;
+    launchBrowser(): Promise<void>;
+    newContext(options?: Parameters<Browser["newContext"]>[0]): Promise<BrowserContext>;
+    newPage(name?: string): Promise<Page>;
+    getBrowser(): Browser;
+    getContext(): BrowserContext;
+    getCurrentPage(): Page | undefined;
+    setCurrentPage(name: string): void;
+    closeContext(): Promise<void>;
+    closeAll(): Promise<void>;
+    setWorld(world: any): void;
+    getWorld(): any;
+    setPlaywrightPage(page: Page): void;
+    getSmartIQData(): any[];
+    setSmartIQData(data: any[]): void;
+};