will-core/index.d.ts

core module

import { Service } from "moleculer";
import { Request, Response } from 'express';
import { KnModel, KnHandler, LoggerInterface, DBConnector, TrackingInfo, OperationInfo, DBField, KnSetting, FieldSetting } from "will-db";
import { ResultSet, RecordSet } from "will-sql";
import { JSONReply } from "will-api";
import { UserTokenInfo, PasswordPolicyInfo, PasswordVerify, AuthenTokenData } from "will-lib"
import { DH } from "will-dh";

export declare class ActivateHandler extends SchemeHandler {
    model: KnModel;
    activateInfo: ActivateInfo | undefined;
    activateCategory: string;
    handlers: {
        name: string;
    }[];
    invalidate(context: ContextInfo): Promise<RecordSet>;
    activate(context: ContextInfo): Promise<RecordSet>;
    inactivate(context: ContextInfo): Promise<RecordSet>;
    removal(context: ContextInfo): Promise<RecordSet>;
    createActivateKey(): string;
    createActivateInfo(data?: any, invalidatetimes?: number): ActivateInfo;
    protected assignParameters(context: ContextInfo, sql: SQLInterface, action?: string, mode?: string): void;
    protected validateActivateInfo(info: ActivateInfo): ValidateInfo;
    doCreate(context: ContextInfo, model: KnModel, invalidatetimes?: number): Promise<ActivateInfo>;
    createActivation(db: DBConnector, info: ActivateInfo, context?: any): Promise<ResultSet>;
    validateKeyFields(context: ContextInfo): ValidateInfo;
    protected doRetrieve(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    doRetrieving(context: ContextInfo, db: DBConnector): Promise<RecordSet>;
    performRetrieving(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    getActivateInfo(db: DBConnector, info: ActivateInfo, context?: any): Promise<ActivateInfo | undefined>;
    doActivate(context: ContextInfo, model: KnModel): Promise<ActivateInfo>;
    doActivating(context: ContextInfo, db: DBConnector): Promise<ActivateInfo>;
    performActivating(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    updateActivation(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    updateActivateByKeyAndUser(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    updateActivateByKey(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    deleteActivateUser(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    deleteActivateUserCategory(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    deleteActivateUserKey(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    deleteActivateKey(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    deleteExpiration(db: DBConnector, curtime?: number, context?: any): Promise<RecordSet>;
    moveToHistoryByUser(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    moveToHistoryByKey(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    doInvalidate(context: ContextInfo, model: KnModel): Promise<ActivateInfo>;
    doInvalidating(context: ContextInfo, db: DBConnector): Promise<ActivateInfo>;
    performInvalidating(db: DBConnector, info: ActivateInfo, invalidatetimes?: number): Promise<ActivateInfo | undefined>;
    doInactivate(context: ContextInfo, model: KnModel): Promise<ActivateInfo>;
    doInactivating(context: ContextInfo, db: DBConnector): Promise<ActivateInfo>;
    /**
     * To invalidate and activate transaction
     */
    performInactivating(db: DBConnector, info: ActivateInfo, invalidatetimes?: number, context?: any): Promise<ActivateInfo | undefined>;
    protected doUpdate(context: ContextInfo, model: KnModel): Promise<any>;
    protected doRemove(context: ContextInfo, model: KnModel): Promise<any>;
    doRemoving(context: ContextInfo, db: DBConnector): Promise<RecordSet>;
    deleteActivation(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    protected doRemoval(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    doRemovaling(context: ContextInfo, db: DBConnector): Promise<RecordSet>;
    performRemovaling(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
    performRemoval(db: DBConnector, info: ActivateInfo, context?: any): Promise<RecordSet>;
}

export declare class AssureHandler {
    static isExceptPath(req: any): boolean;
    static doAuthorizeFilter(ctx: ContextInfo, req: any): Promise<ContextInfo>;
    static doAuthenticateFilter(ctx: ContextInfo, req: any): Promise<any>;
    static doAuthorize(ctx: ContextInfo): Promise<ContextInfo>;
    static doAuthenticate(ctx: ContextInfo): Promise<any>;
}

export declare class AttachHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    get(context: ContextInfo): Promise<RecordSet>;
    protected doGet(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    attach(context: ContextInfo): Promise<RecordSet>;
    protected doAttach(context: ContextInfo, model: KnModel): Promise<RecordSet>;
}

export declare class AuthenticateHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    authenticate(context: ContextInfo): Promise<UserTokenInfo | undefined>;
    protected doAuthenticate(context: ContextInfo, model: KnModel): Promise<UserTokenInfo | undefined>;
}

export declare class AuthorizeHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    authorize(context: ContextInfo): Promise<UserTokenInfo | undefined>;
    doAuthorize(context: ContextInfo, model: KnModel): Promise<UserTokenInfo | undefined>;
    getAuthorizeTokenInfo(db: DBConnector, token: string): Promise<UserTokenInfo | undefined>;
    getAuthorizeToken(db: DBConnector, atoken: AuthenTokenData, verifyTokenNotFound?: boolean, verifyAnonymousToken?: boolean): Promise<UserTokenInfo | undefined>;
}

export declare class BaseHandler extends KnHandler {
    accessor?: Accessor;
    section: string;
    constructor(model?: KnModel, settings?: KnSetting, accessor?: Accessor);
    protected getAccessor(conn: DBConnector, useruuid: string): Promise<Accessor | undefined>;
    protected retainAccessor(conn: DBConnector, useruuid: string): Promise<void>;
    protected getHeaderParameter(context: ContextInfo, parameterName: string): string | undefined;
    protected isInPageSetting(key: string, model: KnModel): boolean;
    getCurrentUser(): string;
    getAuthorizationInfo(context: ContextInfo): AuthorizationInfo | undefined;
    getTokenKey(context: ContextInfo): string | undefined;
    getUserTokenInfo(context: ContextInfo, onlyMeta?: boolean, db?: DBConnector): Promise<UserTokenInfo | undefined>;
    getUserTokenInfoByToken(context: ContextInfo, db?: DBConnector): Promise<UserTokenInfo | undefined>;
    getUserDiffie(userInfo: UserTokenInfo | undefined, verifyHandShaked?: boolean, uncheckTokenStatus?: boolean): Promise<DH | undefined>;
    getUserDH(context: ContextInfo, verifyHandShaked?: boolean, uncheckTokenStatus?: boolean): Promise<DH | undefined>;
    getAuthenToken(context: ContextInfo, verifyTokenKey?: boolean, verifyIdentifier?: boolean): Promise<AuthenTokenData | undefined>;
    verifyAuthenToken(token?: string, verifyTokenKey?: boolean, verifyIdentifier?: boolean): Promise<AuthenTokenData | undefined>;
    exposeContext(context: ContextInfo, includeChiperData?: boolean): Promise<ContextInfo>;
    isCipherData(context: ContextInfo): boolean;
    isCipherText(context: ContextInfo): boolean;
    isCipherDataAccept(context: ContextInfo): boolean;
    isCipherTextAccept(context: ContextInfo): boolean;
    /**
     * try to encrypt data if found user DH
     * @param context
     * @param data
     * @returns cipher string
     */
    encryptData(context: ContextInfo, data?: any, verifyHandShaked?: boolean): Promise<any>;
    /**
     * try to encrypt data when header accept-type is json/cipher
     * @param context
     * @param data
     * @returns json format { data: ? }
     */
    cipherData(context: ContextInfo, data?: any, verifyHandShaked?: boolean): Promise<any>;
    /**
     * try to encrypt data when header accept-type is text/cipher
     * @param context
     * @param data
     * @returns cipher string
     */
    cipherText(context: ContextInfo, data?: any, verifyHandShaked?: boolean): Promise<any>;
    createJSONReply(method: string, data?: any, model?: string): JSONReply;
    createCipherData(context: ContextInfo, method: string, data?: any, verifyHandShaked?: boolean, model?: string): Promise<any>;
    validateAuthenToken(context: ContextInfo): Promise<AuthenTokenData | undefined>;
    validateParameters(params: any, ...args: string[]): ValidateInfo;
    recordNotFound(): Promise<any>;
    notImplementation(): Promise<any>;
    createRecordSet(result?: ResultSet): RecordSet;
}

export declare class CaptchaHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    verify(context: ContextInfo): Promise<RecordSet>;
    protected doCreate(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    protected doVerify(context: ContextInfo, model: KnModel): Promise<RecordSet>;
}

export declare class ChangePasswordHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    change(context: ContextInfo): Promise<RecordSet>;
    policy(context: ContextInfo): Promise<{
        policy: string[];
    }>;
    policies(context: ContextInfo): Promise<PasswordPolicyInfo[]>;
    protected doChange(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    checkChangePassword(puserid: string, puserpass: string, pcnfpass: string): VerifyError | null;
    processChangePassword(db: DBConnector, puserid: string, puserpass: string, poldpass: string): Promise<RecordSet>;
    changeUserPassword(db: DBConnector, userid: string, pwd: string, newpwd: string, site?: string, date?: Date): Promise<PasswordVerify>;
    protected doPolicy(context: ContextInfo, model: KnModel): Promise<{
        policy: string[];
    }>;
    protected doPolicies(context: ContextInfo, model: KnModel): Promise<PasswordPolicyInfo[]>;
}

export declare class DataTableHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    protected doGet(context: ContextInfo, model: KnModel): Promise<DataTableResultSet>;
    protected getDataSet(context: ContextInfo, model: KnModel): Promise<DataTableResultSet>;
    protected buildDataTableQuery(knsql: KnSQL, datasetting: DataTableSetting): void;
    fetchDataTable(db: DBConnector, setting: DataTableSetting, disableColumnSchema?: boolean, context?: any): Promise<DataTableResultSet>;
    /**
     * To get data table as array
     * @param db connection
     * @param datasettings
     * @param disableColumnSchema
     * @returns
     */
    getDataTable(db: DBConnector, datasettings: DataTableSetting[], disableColumnSchema?: boolean, context?: any): Promise<DataTableResultSet[]>;
    fetchDataCategory(db: DBConnector, setting: DataMapEntitySetting, disableColumnSchema?: boolean, context?: any): Promise<[DataTableResultSet, DataMapEntitySetting]>;
    /**
     * To get data table as map
     * @param db connection
     * @param datasettings
     * @param disableColumnSchema
     * @returns
     */
    getDataCategory(db: DBConnector, datasettings: DataMapEntitySetting[], disableColumnSchema?: boolean, context?: any): Promise<DataEntity>;
    protected doList(context: any, model: KnModel): Promise<RecordSet>;
    protected doFind(context: any, model: KnModel): Promise<RecordSet>;
    category(context: ContextInfo): Promise<DataEntity>;
    protected doCategory(context: ContextInfo, model: KnModel): Promise<DataEntity>;
    config(context: ContextInfo): Promise<RecordSet>;
    protected doConfig(context: ContextInfo, model: KnModel): Promise<RecordSet>;
}

export declare class DiffieHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    dh(context: ContextInfo): Promise<any>;
    diffie(context: ContextInfo): Promise<any>;
    doDiffie(context: ContextInfo, model: KnModel): Promise<any>;
    createDiffie(context: ContextInfo): Promise<DH>;
    createDiffieInfo(dh: DH): DiffieInfo;
    doSaveDiffie(context: ContextInfo, model: KnModel, dh: DH): Promise<ResultSet | undefined>;
    saveDiffie(db: DBConnector, userInfo: UserTokenInfo, dh: DH, context?: any): Promise<ResultSet>;
    protected doUpdate(context: any, model: KnModel): Promise<RecordSet>;
    encrypt(context: ContextInfo): Promise<any>;
    decrypt(context: ContextInfo): Promise<any>;
}

export declare class ForgotPasswordHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    password(context: ContextInfo): Promise<PasswordVerify>;
    protected doPassword(context: ContextInfo, model: KnModel): Promise<PasswordVerify>;
    getUserInfoByEmail(db: DBConnector, email: string, context?: any): Promise<UserInfo>;
    getUserInfoById(db: DBConnector, id: string, context?: any): Promise<UserInfo>;
    composeMailMessage(db: DBConnector, record: any, eng?: boolean, template?: string, templatetype?: string): Promise<[string, TemplateInfo | undefined]>;
    performForgotPassword(context: ContextInfo, model: KnModel, db: DBConnector, userinfo: UserInfo, date?: Date): Promise<PasswordVerify>;
    doSendMail(context: ContextInfo, model: KnModel, info: MailInfo): Promise<void>;
    forgotPassword(db: DBConnector, info: UserInfo, date?: Date): Promise<PasswordVerify>;
}

export declare class LabelHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    protected validateRequireFields(context: any, model: KnModel, action: string): Promise<ValidateInfo>;
    protected doGet(context: ContextInfo, model: KnModel): Promise<DataEntity>;
    protected doList(context: any, model: KnModel): Promise<LabelData[]>;
}

export declare class LoggingHandler extends BaseHandler {
    model: KnModel;
    trackInfo?: TrackingInfo;
    insert(context: any): Promise<ResultSet>;
    protected doInsert(context: any, model: KnModel): Promise<RecordSet>;
}

export declare class LoginHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    logincallback(context: ContextInfo): Promise<LoginInfoContents>;
    logoutcallback(context: ContextInfo): Promise<LogoutInfoContents>;
    anonymouslogin(context: ContextInfo): Promise<AnonymousInfoContents>;
    protected doLoginCallback(context: ContextInfo, model: KnModel): Promise<LoginInfoContents>;
    processLogin(context: ContextInfo, db: DBConnector, useruuid: string, token: string): Promise<LoginInfoContents>;
    composeResponseInfo(row: any): LoginInfoContents;
    processLoginByNonce(context: ContextInfo, db: DBConnector, nonce: string, code: string): Promise<LoginInfoContents>;
    protected doLogoutCallback(context: ContextInfo, model: KnModel): Promise<LogoutInfoContents>;
    processLogout(db: DBConnector, token: string, context?: any): Promise<ResultSet>;
    doAnonymousLogin(context: ContextInfo, model: KnModel): Promise<AnonymousInfoContents>;
    saveAnonymousToken(context: ContextInfo, model: KnModel, authdata: AuthenTokenData, authtoken: string): Promise<UserToken>;
}

export declare class OneTimeHandler extends ActivateHandler {
    createActivateKey(): string;
    performInvalidating(db: DBConnector, info: ActivateInfo, invalidatetimes?: number): Promise<ActivateInfo | undefined>;
    validateKeyFields(context: ContextInfo): ValidateInfo;
    updateActivation(db: DBConnector, info: ActivateInfo): Promise<RecordSet>;
    protected doRemove(context: ContextInfo, model: KnModel): Promise<any>;
}

export declare class PasswordPolicyHandler extends ChangePasswordHandler {
    protected doExecute(context: any, model: KnModel): Promise<DataTable>;
}

export declare class ProgramHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    protected doGet(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    protected doRetrieve(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    performRetrieving(context: ContextInfo, db: DBConnector): Promise<RecordSet>;
    getDataSource(context: ContextInfo): Promise<DataTable | undefined>;
}

export declare class SchemeHandler extends SystemHandler {
    get(context: ContextInfo): Promise<any>;
    edit(context: ContextInfo): Promise<any>;
    html(context: ContextInfo): Promise<string>;
    protected doEdit(context: ContextInfo, model: KnModel): Promise<any>;
    protected doGet(context: ContextInfo, model: KnModel): Promise<any>;
    protected doHtml(context: ContextInfo, model: KnModel): Promise<string>;
    protected doClear(context: ContextInfo, model: KnModel): Promise<any>;
    protected doCreate(context: ContextInfo, model: KnModel): Promise<any>;
    protected doExecute(context: ContextInfo, model: KnModel): Promise<any>;
    protected doList(context: ContextInfo, model: KnModel): Promise<any>;
    protected doFind(context: ContextInfo, model: KnModel): Promise<any>;
    protected doInsert(context: ContextInfo, model: KnModel): Promise<any>;
    protected doRetrieve(context: ContextInfo, model: KnModel): Promise<any>;
    protected doUpdate(context: ContextInfo, model: KnModel): Promise<any>;
    protected doRemove(context: ContextInfo, model: KnModel): Promise<any>;
    protected doCollect(context: ContextInfo, model: KnModel): Promise<any>;
}

export declare class SigninHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    protected getSigninInfo(context: ContextInfo): SigninInfo;
    signin(context: ContextInfo): Promise<JSONReply>;
    protected doSignin(context: ContextInfo, model: KnModel): Promise<JSONReply>;
    doSigninByDomain(context: ContextInfo, model: KnModel, signinfo: SigninInfo, db: DBConnector): Promise<JSONReply>;
    doSigninByConfigure(context: ContextInfo, model: KnModel, signinfo: SigninInfo, db: DBConnector): Promise<JSONReply>;
    processTwoFactor(context: ContextInfo, db: DBConnector, row: any): Promise<FactorInfo>;
    processSigninInternalSystem(context: ContextInfo, model: KnModel, signinfo: SigninInfo, db: DBConnector, loginfo?: Object): Promise<JSONReply>;
    processSigninActiveDirectory(context: ContextInfo, model: KnModel, signinfo: SigninInfo, db: DBConnector, config?: ActiveConfig, loginfo?: Object): Promise<JSONReply>;
    processSigninPromptSystem(context: ContextInfo, model: KnModel, signinfo: SigninInfo, db: DBConnector, config?: PromptConfig, loginfo?: Object): Promise<JSONReply>;
    composeResponseBody(body: Map<string, Object>, token: UserToken, username: string, row: any, tempmatch?: boolean, dhinfo?: DiffieInfo): void;
    createUserAccess(db: DBConnector, usrinfo: UserAccessInfo, context?: any): Promise<UserToken>;
    createUserToken(db: DBConnector, usrinfo: UserAccessInfo, useruuid: string, authtoken: string, tokentype?: string, expireins?: number, context?: any): Promise<UserToken>;
    createDiffie(context: ContextInfo, db: DBConnector, token: UserToken): Promise<DiffieInfo | undefined>;
    updateUserAccessing(context: ContextInfo, model: KnModel, info: AccessingInfo): Promise<void>;
    updateUserAccess(db: DBConnector, userid: string, context?: any): Promise<void>;
    updateUserLock(db: DBConnector, username: string, lockflag: string, context?: any): Promise<void>;
    accesstoken(context: ContextInfo): Promise<Map<string, Object>>;
    account(context: ContextInfo): Promise<Map<string, Object>>;
    protected doAccessToken(context: ContextInfo, model: KnModel): Promise<Map<string, Object>>;
    processAccessToken(db: DBConnector, useruuid: string, fetching?: boolean, context?: any): Promise<Map<string, Object>>;
    fetchtoken(context: ContextInfo): Promise<Map<string, Object>>;
    protected doFetchToken(context: ContextInfo, model: KnModel): Promise<Map<string, Object>>;
    signout(context: ContextInfo): Promise<Map<string, Object>>;
    doSignout(context: ContextInfo, model: KnModel): Promise<Map<string, Object>>;
    processSignout(db: DBConnector, useruuid: string, context?: any): Promise<Map<string, Object>>;
    loginWow(userid: string, pwd: string, site?: string): Promise<any>;
    validatetoken(context: ContextInfo): Promise<AuthenTokenData | undefined>;
}

export declare class SystemHandler extends BaseHandler {
    protected exposeOperation(context: any, model: KnModel, operation: OperationInfo): Promise<void>;
    callFunctional(context: ContextInfo, info: FunctionalInfo, functional: Function): Promise<any>;
    track(context: ContextInfo, info: TrackingInfo): Promise<void>;
}

export declare class TwoFactorHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    factorInfo: FactorInfo | undefined;
    generate(context: ContextInfo): Promise<any>;
    verify(context: ContextInfo): Promise<any>;
    confirm(context: ContextInfo): Promise<any>;
    createFactorInfo(data: any): FactorInfo;
    genterateFactor(info: FactorInfo): Promise<FactorTokenInfo>;
    verifyFactor(info: FactorInfo, factorcode: string): Promise<FactorVerifyInfo>;
    composeFactorUri(info: any): string;
    doGenerate(context: ContextInfo, model: KnModel): Promise<FactorTokenInfo>;
    doGenerating(context: ContextInfo, db: DBConnector, findByUser?: boolean): Promise<FactorTokenInfo>;
    doVerify(context: ContextInfo, model: KnModel): Promise<FactorVerifyInfo>;
    doVerifying(context: ContextInfo, db: DBConnector, findByUser?: boolean): Promise<FactorVerifyInfo>;
    doGet(context: ContextInfo, model: KnModel): Promise<FactorInfo>;
    doConfirm(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    doConfirming(context: ContextInfo, db: DBConnector): Promise<RecordSet>;
    validateRequireFields(context: ContextInfo, model: KnModel, action?: string): Promise<ValidateInfo>;
    doRetrieve(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    doRetrieving(context: ContextInfo, db: DBConnector): Promise<RecordSet>;
    performRetrieving(db: DBConnector, id: string, findByUser?: boolean, context?: any): Promise<RecordSet>;
    getFactorInfo(db: DBConnector, id: string, findByUser?: boolean, context?: any): Promise<FactorInfo>;
    getConfigure(db: DBConnector, context?: any): Promise<FactorConfigInfo>;
    doCreate(context: ContextInfo, model: KnModel): Promise<FactorInfo>;
    doClear(context: ContextInfo, model: KnModel): Promise<ResultSet>;
    doInsert(context: ContextInfo, model: KnModel): Promise<FactorInfo>;
    doUpdate(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    doRemove(context: ContextInfo, model: KnModel): Promise<ResultSet>;
    performCreating(context: any, model: KnModel, db: DBConnector): Promise<ResultSet>;
    performCreateFactor(context: any, db: DBConnector, data: any): Promise<FactorInfo>;
    performClearing(context: any, model: KnModel, db: DBConnector): Promise<ResultSet>;
    createFactor(db: DBConnector, info: FactorInfo, edituser?: string, context?: any): Promise<RecordSet>;
    deleteFactor(db: DBConnector, factorid: string, context?: any): Promise<RecordSet>;
    removeFactor(db: DBConnector, factorid: string, context?: any): Promise<RecordSet>;
    moveToHistory(db: DBConnector, factorid: string, context?: any): Promise<RecordSet>;
    confirmFactor(db: DBConnector, factorid: string, edituser?: string, context?: any): Promise<RecordSet>;
    updateUserFactor(db: DBConnector, useruuid: string, factorcode: string, context?: any): Promise<RecordSet>;
}

export declare class Accessor {
    readonly useruuid: string;
    readonly userid: string;
    readonly authtoken: string;
    readonly userinfo?: any;
    constructor(useruuid: string, userid: string, authtoken: string, userinfo?: any);
}

export const RESERVED_PARAMETERS: string[] = ["program", "subprog", "language", "authtoken", "action", "caption", "ciphertext"];
export const RESERVED_FIELDS: string[] = ["authtoken","ciphertext","language","tokenkey"];
export const INSERT_MODES = ["create", "insert", "add", "entry", "enter", "entrance"];
export const UPDATE_MODES = ["retrieve", "find", "list", "get", "query", "view", "search", "retrieval", "edit", "update", "modify"];
export const RETRIEVE_MODES = ["retrieve", "get", "retrieval", "edit", "view", "query"];
export const DELETE_MODES = ["delete", "remove", "reset", "erase", "clear"];
export const COLLECT_MODES = ["collect", "find", "list", "query", "search", "inquiry", "enquiry"];

export interface LoginInfoContents {
    authToken: string;
    userUuid: string;
    textures: any[];
    email: string;
    displayName: string;
    userPrincipalName: string;
    userContents: any;
    accessContents: any;
    info?: any;
}
export interface LogoutInfoContents {
    authToken: string;
}
export interface AnonymousInfoContents {
    userUuid: string;
    authToken: string;
}
export interface ContextInfo {
    params: any;
    meta: any;
    options?: any;
}
export interface AuthorizationInfo {
    authorization: string;
    client?: string;
}
export interface SigninInfo {
    username: string;
    password: string;
    site?: string;
}
export interface DiffieInfo {
    prime: string;
    generator: string;
    publickey: string;
}
export interface UserAccessInfo {
    userid: string;
    site?: string;
    code?: string;
    state?: string;
    nonce?: string;
    loginfo?: Object;
}
export interface AccessingInfo {
    userid?: string;
    username?: string;
    lockflag?: string;
}
export interface CipherData {
    data: string;
}
export interface ValidateInfo {
    valid: boolean;
    info?: string;
    options?: any;
}
export interface DataSet {
    [name: string]: any;
}
export interface DataEntity {
    [name: string]: DataSet;
}
export interface DataTable {
    action: string;
    dataset: DataSet;
    entity: DataEntity | Array<any>;
    meta?: DataSet;
    renderer?: string;
    error?: any;
}
export interface DataTableSetting {
    tableName: string;
    keyField: string;
    addonFields?: string;
    orderFields?: string;
    checkActive?: boolean;
    checkSite?: boolean;
    siteOnly?: boolean;
    addonFilters?: string;
    captionFields?: string;
    nameen?: string;
    nameth?: string;
    options?: any;
}
export interface DataTableResultSet {
    tablename: string;
    resultset: ResultSet;
    options?: any;
}
export interface DataMapSetting {
    keyName: string;
    valueNames: string[];
    groupId?: string;
    groupNames?: string[];
    categoryName?: string;
    options?: any;
}
export interface DataMapEntitySetting extends DataTableSetting {
    setting?: DataMapSetting;
}
export interface DataMapRecordSetting extends DataTableResultSet {
    setting: DataMapSetting;
}
export interface FormatInfo {
    name?: string;
    value: any;
    rs?: any;
    field?: DBField;
}
export interface LabelItem {
    name: string;
    value: string;
}
export interface LabelData {
    language: string;
    label: LabelItem[];
}
export interface FunctionalInfo extends OperationInfo {
    raw: boolean;
}
export interface TemplateInfo {
    subjecttitle: string;
    contents: string;
    contexts: string;
    info?: any;
}
export interface UserInfo {
    found: boolean;
    userid: string;
    email: string;
    site?: string;
    username?: string;
    userpassword?: string;
    usernameen?: string;
    usernameth?: string;
    info?: any;
}
export interface ActivateInfo {
    activatekey: string;
    activateuser: string;
    transtime: number;
    expiretime: number;
    activatecount: number;
    activatetimes: number;
    expiredate?: Date;
    activatecategory?: string;
    activatestatus?: string;
    activatelink?: string;
    activatepage?: string;
    activateremark?: string;
    activateparameter?: string;
    activatemessage?: string;
    activatecontents?: string;
    activatedate?: Date;
    activatetime?: Date;
    info?: any;
}
export interface FactorConfigInfo {
    factorconfig: boolean;
    factorverify: boolean;
    issuer: string;
    info?: any;
}
export interface FactorInfo extends FactorConfigInfo {
    userid: string;
    email: string;
    factorfound: boolean;
    factorid: string;
    factorkey: string;
    factorflag: string;
    factorurl?: string;
    factorremark?: string;
    factorimage?: string;
}
export interface FactorTokenInfo {
    valid: boolean;
    token: string;
    info?: any;
}
export interface FactorVerifyInfo {
    verified: boolean;
    delta: number;
    info?: any;
}

export declare class UserToken {
    useruuid: string;
    expiretimes: number;
    code: string;
    state: string;
    nonce: string;
    authtoken: string;
    constructor(useruuid: string, expiretimes: number, code: string, state: string, nonce: string, authtoken: string);
}

export declare class VerifyError extends Error {
    readonly code: number;
    readonly errno: number | undefined;
    readonly state: string | undefined;
    constructor(message: string, code: number, errno?: number, state?: string);
}

export declare abstract class BaseRouter {
    readonly service: Service;
    readonly logger: LoggerInterface;
    dir: string;
    constructor(service: Service, dir?: string);
    buildContext(req: Request, pid?: string): ContextInfo;
    createContext(req: Request, pid?: string): Promise<ContextInfo>;
    cipherData(context: ContextInfo, data?: any, verifyHandShaked?: boolean): Promise<any | undefined>;
    cipherText(context: ContextInfo, data?: any, verifyHandShaked?: boolean): Promise<any | undefined>;
    createCipherData(context: ContextInfo, method: string, data?: any, verifyHandShaked?: boolean, model?: string): Promise<any>;
    call(serviceName: string, req: Request): Promise<any>;
    authorize(req: Request): Promise<ContextInfo>;
    protected verifyToken(req: Request, res: Response): Promise<boolean>;
    protected verifyAuthenToken(req: Request): Promise<boolean>;
    protected getAuthorizeToken(req: Request): string | undefined;
}

export declare class CallbackRouter extends BaseRouter {
    doLoginCallback(req: Request, res: Response): Promise<void>;
    doLogoutCallback(req: Request, res: Response): Promise<void>;
    doAnonymousLogin(req: Request, res: Response): Promise<void>;
    doSignin(req: Request, res: Response): Promise<void>;
    doFetchToken(req: Request, res: Response): Promise<void>;
    doAccessToken(req: Request, res: Response): Promise<void>;
    doSignout(req: Request, res: Response): Promise<void>;
}

export declare class DiffieRouter extends BaseRouter {
    doDiffie(req: Request, res: Response): Promise<void>;
    doEncrypt(req: Request, res: Response): Promise<void>;
    doDecrypt(req: Request, res: Response): Promise<void>;
    doUpdate(req: Request, res: Response): Promise<void>;
}

export declare class UploadRouter extends BaseRouter {
    private fileuploader;
    private uploadfile;
    constructor(service: Service, dir?: string, paramname?: string, fileTypes?: RegExp, fileSize?: number);
    private buildMulter;
    doUpload(req: Request, res: Response): void;
    protected doUploadFile(req: Request, res: Response): Promise<void>;
}

export declare class LabelConfig {
    configname: string;
    language: string;
    label: DataEntity;
    constructor(configname: string, language?: string);
    load(workdir?: string, labelpath?: string): Promise<void>;
    get(key: string, defaultLabel?: string, language?: string): any;
}

export declare class LabelUtility {
    labelname: string;
    constructor(labelname: string);
    load(workdir?: string, labelpath?: string): Promise<LabelData[]>;
    build(ary: LabelData[]): DataEntity;
    loadAndBuild(workdir?: string, labelpath?: string): Promise<DataEntity>;
}

export declare class NotifyConfig {
    getConfigValue(db: DBConnector, category: string, colname: string, context?: any): Promise<string>;
    getConfigCategory(db: DBConnector, category: string, context?: any): Promise<DataSet>;
    getApproveURL(db: DBConnector, context?: any): Promise<string>;
    getActivateURL(db: DBConnector, context?: any): Promise<string>;
    getConfigTemplate(db: DBConnector, template: string, templatetype: string, context?: any): Promise<TemplateInfo | undefined>;
    isVerifyConfig(db: DBConnector, category: string, colname: string, context?: any): Promise<boolean>;
}

export declare class PageUtility {
    progid: string;
    context: ContextInfo;
    constructor(progid: string, context: ContextInfo);
    isEnglish(): boolean;
    isThai(): boolean;
    isLanguage(language: string): boolean;
    isExecuteMode(mode: string): boolean;
    isInsertMode(mode?: string): boolean;
    isUpdateMode(mode?: string): boolean;
    isRetrieveMode(mode?: string): boolean;
    isDeleteMode(mode?: string): boolean;
    isCollectMode(mode?: string): boolean;
    format(info: FormatInfo): any;
    checked(checker: string, value: any): string;
    selected(checker: string, value: any): string;
}

export declare class Responser {
    static createError(model: string, method: string, err: any): JSONReply;
    static createDbError(model: string, method: string, err: any): JSONReply;
    static responseError(res: Response, err: any, model: string, method: string): void;
}

export declare class TheUtility {
    static createMapEntities(rs: ResultSet, setting: DataMapSetting): Map<string, string>;
    static createDataEntity(records: DataMapRecordSetting[]): DataEntity;
    static getDefaultLanguage(context?: any): string;
    static isEnglish(context: any): boolean;
    static isThai(context: any): boolean;
    static isLanguage(context: any, language: string): boolean;
    static isReservedParameter(parameter: string): boolean;
    static transformData(rs: any, fields?: FieldSetting, formatter?: Function): DataSet;
    static formatData(info: FormatInfo): any;
}