declare const cfg: Config;
type Config = {
    UNIX_TIME: number;
    cookie: {
        STATE: string;
        TOKEN: string;
        REFRESH: string;
        SESSION: string;
    };
    app: AppCfg;
    api: ApiCfg;
    hub: HubCfg;
    hwl: HwlCfg;
    user: UserCfg;
};
type AppCfg = {
    CODE: string;
    NAME: string;
    VERSION: string;
    RELEASE: string;
    CALLBACK: string;
};
type ApiCfg = {
    URL: string;
    UUID: string;
    TOKEN?: string;
    HEADERS?: Headers;
};
type HubCfg = {
    LOGIN: string;
    OAUTH: string;
    FIDO2: string;
    API: string;
    WSS: string;
    UUID: string;
    TASK?: Worker;
};
type HwlCfg = {
    HOST: string;
    FILE: string;
};
type UserCfg = {
    sub: number;
    name: string;
    utyp: string;
    unit: string;
    unit_id: number;
    role_id: number;
    metadata: {
        emp_type: string;
        emp_level: string;
        position: string;
    };
    picture: string;
    AGCY?: number;
    DVSN?: number;
    SECT?: number;
    DEPT?: string;
    ACCT?: number;
    ACTYPE?: number;
    ACROLE?: number;
    ACNAME?: string;
    AGCY_NAME?: string;
    DVSN_NAME?: string;
    SECT_NAME?: string;
};

type MWParams = {
    path: string;
    ignore?: string[];
    isLine?: boolean;
};
declare const authMW: (params: MWParams) => Promise<void>;

declare const login: () => void;
declare const logout: () => void;
declare const callback: () => void;

declare const index$2_authMW: typeof authMW;
declare const index$2_callback: typeof callback;
declare const index$2_login: typeof login;
declare const index$2_logout: typeof logout;
declare namespace index$2 {
  export { index$2_authMW as authMW, index$2_callback as callback, index$2_login as login, index$2_logout as logout };
}

interface AuthService {
    getToken(params: ReqToken): Promise<ApiRsp>;
    getUserInfo(token?: string): Promise<ApiRsp>;
}
declare const auth: AuthService;
type ReqToken = {
    grant_type: string;
    client_id: string;
    client_secret?: string;
    username?: string;
    password?: string;
    refresh_token?: string;
    code?: string;
    uuid?: string;
};
type RspToken = {
    access_token: string;
    token_type: string;
    expires_in: number;
    refresh_token?: string;
    redirect_uri?: string;
};
type UserInfo = {
    sub: number;
    name: string;
    utyp: string;
    unit: string;
    unit_id: number;
    role_id: number;
    metadata?: {
        emp_type: string;
        emp_level: string;
        position: string;
    };
    picture?: string;
    updated_at: number;
};

interface UnitService {
    getUnit(id: number): Promise<ApiRsp>;
    getChild(id: number): Promise<ApiRsp>;
    getTree(id: number): Promise<ApiRsp>;
    setChildDropdown(id: number, elm: HTMLSelectElement): Promise<void>;
    setTreeDropdown(id: number, elm: HTMLSelectElement): Promise<void>;
}
declare const unit: UnitService;
type UnitType = 'AGENCY' | 'DIVISION' | 'SECTION';
type OrgUnit = {
    id: number;
    parent_id: number | null;
    unit_type: UnitType;
    code: string;
    name: string;
    short: string;
    abbr_th: string;
    abbr_en: string;
    path: string;
    level: number;
    is_active: boolean;
    children?: OrgUnit[];
};

interface MasterService {
    getEmpType(): Promise<ApiRsp>;
    getEmpLevel(): Promise<ApiRsp>;
    getPosition(): Promise<ApiRsp>;
    setEmpTypeDropdown(elm: HTMLSelectElement): Promise<void>;
    setEmpLevelDropdown(elm: HTMLSelectElement): Promise<void>;
    setPositionDropdown(elm: HTMLSelectElement): Promise<void>;
}
declare const master: MasterService;
type EmpMasterData = {
    id: number;
    code: string;
    name: string;
    is_active: boolean;
};
type EmpType = EmpMasterData;
type EmpLevel = EmpMasterData;
type Position = EmpMasterData;

interface ClientService {
    GetApp(code?: string): Promise<ApiRsp>;
    setAppDropdown(elm: HTMLSelectElement): Promise<void>;
}
declare const client: ClientService;
type AppClient = {
    id: number;
    client_id: string;
    client_name: string;
    client_type: string;
    redirect_uri: string;
    grant_type: string;
    latest: string;
    logfile: string;
    isActive: boolean;
};

interface AuditService {
    getAuditLog(params: ReqAuditLog): Promise<ApiRsp>;
}
declare const audit: AuditService;
type ReqAuditLog = {
    start_date: string;
    end_date?: string;
    client_id?: string;
    path?: string;
    limit?: number;
    offset?: number;
};
type AuditLog = {
    id: number;
    created_at: string;
    user_id?: number;
    client_id?: string;
    remote_ip: string;
    status: number;
    method: string;
    path: string;
    latency: number;
    user_agent?: string;
    profile?: {
        name: string;
        utyp: string;
        unit: string;
    };
};

type ApiRsp = {
    status: {
        code: number;
        message: string;
    };
    rows: {
        total: number;
        limit: number;
        offset: number;
    };
    data: unknown;
};

type types_ApiRsp = ApiRsp;
type types_AppClient = AppClient;
type types_AuditLog = AuditLog;
type types_EmpLevel = EmpLevel;
type types_EmpType = EmpType;
type types_OrgUnit = OrgUnit;
type types_Position = Position;
type types_ReqAuditLog = ReqAuditLog;
type types_ReqToken = ReqToken;
type types_RspToken = RspToken;
type types_UnitType = UnitType;
type types_UserInfo = UserInfo;
declare const types_audit: typeof audit;
declare const types_auth: typeof auth;
declare const types_client: typeof client;
declare const types_master: typeof master;
declare const types_unit: typeof unit;
declare namespace types {
  export { type types_ApiRsp as ApiRsp, type types_AppClient as AppClient, type types_AuditLog as AuditLog, type types_EmpLevel as EmpLevel, type types_EmpType as EmpType, type types_OrgUnit as OrgUnit, type types_Position as Position, type types_ReqAuditLog as ReqAuditLog, type types_ReqToken as ReqToken, type types_RspToken as RspToken, type types_UnitType as UnitType, type types_UserInfo as UserInfo, types_audit as audit, types_auth as auth, types_client as client, types_master as master, types_unit as unit };
}

declare const http: {
    get: (url: string) => Promise<ApiRsp>;
    post: (url: string, body: unknown) => Promise<ApiRsp>;
    put: (url: string, body: unknown) => Promise<ApiRsp>;
    delete: (url: string) => Promise<ApiRsp>;
    getRefreshToken: (isLine?: boolean) => Promise<void>;
    buildUriQuery: (params: object) => string;
};

declare const index$1_audit: typeof audit;
declare const index$1_auth: typeof auth;
declare const index$1_client: typeof client;
declare const index$1_http: typeof http;
declare const index$1_master: typeof master;
declare const index$1_unit: typeof unit;
declare namespace index$1 {
  export { index$1_audit as audit, index$1_auth as auth, index$1_client as client, index$1_http as http, index$1_master as master, types as model, index$1_unit as unit };
}

declare const newTask: (worker: new () => Worker) => void;
declare const checkUpdate: (min?: number) => NodeJS.Timeout;
type BrdPack = {
    from: string;
    to: string;
    cmd: string;
    msg: unknown;
};
type LatestPack = {
    uuid: string;
    name: string;
    version: string;
    release: string;
};
type NotifyPack = {
    title?: string;
    icon?: string;
    body: string;
};

type index_BrdPack = BrdPack;
type index_LatestPack = LatestPack;
type index_NotifyPack = NotifyPack;
declare const index_checkUpdate: typeof checkUpdate;
declare const index_newTask: typeof newTask;
declare namespace index {
  export { type index_BrdPack as BrdPack, type index_LatestPack as LatestPack, type index_NotifyPack as NotifyPack, index_checkUpdate as checkUpdate, index_newTask as newTask };
}

export { index$2 as a, index as b, cfg as c, index$1 as i };