return {
    XXT_HOME_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch document directory path",
    },
    XXT_SCRIPTS_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch script directory path",
    },
    XXT_EXE_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch executable file path",
    },
    XXT_CONF_FILE_NAME = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch configuration file path",
    },
    XXT_DAEMONS_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch daemon script directory path",
    },
    XXT_LIB_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch library directory path",
    },
    XXT_RES_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch resource directory path",
    },
    XXT_LOG_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch log directory path",
    },
    XXT_CERT_PATH = {
        type = "value",
        description = "*XXT* 1.3.8+ XXTouch certificate directory path",
    },

    -- Extra String library
    string = {
        type = "lib",
        childs = {
            to_hex = {
                type = "function",
                description = "*XXT* Converts a string (or block of binary data) into printable hexadecimal text.",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            from_hex = {
                type = "function",
                description = "*XXT* inverse function of string.to_hex, converts printable hexadecimal text to a string (or binary data block)",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            from_gbk = {
                type = "function",
                description = "*XXT* Convert GBK encoded text to UTF-8 encoded text",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            md5 = {
                type = "function",
                description = "*XXT* Calculates the md5 checksum of a string (or block of binary data).",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            sha1 = {
                type = "function",
                description = "*XXT* Calculates the sha1 checksum of a string (or block of binary data).",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            base64_encode = {
                type = "function",
                description = "*XXT* Base64 encoding of strings (or blocks of binary data)",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            base64_decode = {
                type = "function",
                description = "*XXT* Inverse function of string.base64_encode that converts base64 encoded text back to a string (or block of binary data)",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            aes128_encrypt = {
                type = "function",
                description = "*XXT* Encrypts strings (or blocks of binary data) using AES128 algorithm ECB mode",
                args = "(s: string, key: string)",
                returns = "(string)",
                valuetype = "string",
            },
            aes128_decrypt = {
                type = "function",
                description = "*XXT* Decrypts an encrypted string (or block of binary data) using the AES128 algorithm ECB mode",
                args = "(s: string, key: string)",
                returns = "(string)",
                valuetype = "string",
            },
            ltrim = {
                type = "function",
                description = "*XXT* Remove blank characters from the left side of the text",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            rtrim = {
                type = "function",
                description = "*XXT* Remove blank characters from the right side of the text",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            trim = {
                type = "function",
                description = "*XXT* Remove left and right blank characters from text",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            atrim = {
                type = "function",
                description = "*XXT* Remove all blank characters from text",
                args = "(s: string)",
                returns = "(string)",
                valuetype = "string",
            },
            split = {
                type = "function",
                description = "*XXT* Splitting a string with a separator rule",
                args = "(s: string, sep: string)",
                returns = "(table)",
            },
            strip_utf8_bom = {
                type = "function",
                description = "*XXT* 1.1.3-1+ Stripping UTF8-BOM from document headers",
                args = "(input: string)",
                returns = "(output: string)",
            },
            random = {
                type = "function",
                description = "*XXT* Generate random strings",
                args = "(chars: string[, count_6: integer, char_len: integer])",
                returns = "(string)",
            },
        },
    },

    -- Extra Table library
    table = {
        type = "lib",
        childs = {
            deep_copy = {
                type = "function",
                description = "*XXT* Deep copy a table",
                args = "(tab: table)",
                returns = "(newtab: table)",
            },
            deep_print = {
                type = "function",
                description = "*XXT* Prints a table deeply and stores the results in the print buffer.",
                args = "(tab: table)",
                returns = "(text: string)",
            },
            deep_dump = {
                type = "function",
                description = "*XXT* 1.2+ Deep print a table and return the result",
                args = "(tab: table)",
                returns = "(text: string)",
            },
            load_string = {
                type = "function",
                description = "*XXT* Load a table from a string\nmost cases is the inverse function of table.deep_print",
                args = "(text: string)",
                returns = "(tab: table)",
            },
        },
    },

    -- OS library
    os = {
        type = "lib",
        childs = {
            restart = {
                type = "function",
                description =[[*XXT* Restart the script]],
                args = "()",
                returns = "()",
            },
        },
    },

    -- XXTouch
    proc_put = {
        type = "function",
        description = "*XXT* Stores the value to the proc dictionary and returns the original value of the key location",
        args = "(key: string, value: string)",
        returns = "(old_value: string)",
    },
    proc_get = {
        type = "function",
        description = "*XXT* Reads a value from the specified key in the proc dictionary",
        args = "(key: string)",
        returns = "(value: string)",
    },
    proc_queue_push = {
        type = "function",
        description = "*XXT* Push a value into the specified proc queue dictionary and returns the size of the queue after pushing the value.",
        args = "(key: string, value: string)",
        returns = "(size: integer)",
    },
    proc_queue_pop = {
        type = "function",
        description = "*XXT* Pop a value from the specified proc queue dictionary\nIf the queue does not exist or is empty, pop an empty string",
        args = "(key: string)",
        returns = "(value: string)",
    },
    proc_queue_push_back = {
        type = "function",
        description = "*XXT* Push a value into the specified proc queue dictionary and returns the size of the queue after pushing the value.\nequivalent proc_queue_push",
        args = "(key: string, value: string)",
        returns = "(size: integer)",
    },
    proc_queue_pop_back = {
        type = "function",
        description = "*XXT* Pop a value from the direction of the push-in of the specified proc queue dictionary\nIf the queue does not exist or is empty, pop an empty string",
        args = "(key: string, value: string)",
        returns = "(value: string)",
    },
    proc_queue_push_front = {
        type = "function",
        description = "*XXT* Push a value in the direction of the specified proc queue dictionary popup and returns the size of the queue after pushing the value.",
        args = "(key: string, value: string)",
        returns = "(size: integer)",
    },
    proc_queue_pop_front = {
        type = "function",
        description = "*XXT* Pop a value from the specified proc queue dictionary\nIf the queue does not exist or is empty, pop an empty string\nEquivalent proc_queue_pop",
        args = "(key: string)",
        returns = "(value: string)",
    },
    proc_queue_clear = {
        type = "function",
        description = "*XXT* Pop all values from the specified proc queue dictionary to empty the specified queue",
        args = "(key: string)",
        returns = "(all_values: table)",
    },
    proc_queue_size = {
        type = "function",
        description = "*XXT* Get the size of the specified proc queue dictionary",
        args = "(key: string)",
        returns = "(size: integer)",
    },
    nLog = {
        type = "function",
        description = "*XXT* This function sends logs back to the development environment's log box when running scripts with the companion development environment.",
        args = "(text: string)",
        returns = "()",
    },
    dialog = {
        type = "function",
        description = "*XXT* 1.0.9+ Create a dialog object",
        args = "()",
        returns = "(dlg: dialog_object)",
        valuetype = "dialog_object",
    },

    thread = {
        type = "lib",
        description = "thread module",
        childs = {
            dispatch = {
                type = "function",
                description = "*XXT* Dispatch a task to a queue and start it when other tasks are yield.",
                args = "(task: function[, error_callback: function])",
                returns = "(thread_id: integer)",
            },
            current_id = {
                type = "function",
                description = "*XXT* Get the id of the current task",
                args = "()",
                returns = "(thread_id: integer)",
            },
            kill = {
                type = "function",
                description = "*XXT* Removes a task from the queue, regardless of whether it has been started or completed",
                args = "(thread_id: integer)",
                returns = "()",
            },
            timer_start = {
                type = "function",
                description = "*XXT* Starts a timer for a specified amount of time, the timeout dispatches the task to the queue (in seconds)",
                args = "(timeout_s: number, task: function[, error_callback: function])",
                returns = "(thread_id: integer)",
            },
            timer_stop = {
                type = "function",
                description = "*XXT* Terminate a timer task, whether it has been dispatched or not, and whether it has been completed or not",
                args = "(thread_id: integer)",
                returns = "()",
            },
            wait = {
                type = "function",
                description = "*XXT* Current thread is blocking waiting for a task to complete or waiting for a timeout (in seconds)",
                args = "(thread_id: integer, timeout_s: number)",
                returns = "()",
            },
            register_event = {
                type = "function",
                description = "*XXT* Register to listen to an event",
                args = "(event_name: string, event_callback: function[, error_callback: function])",
                returns = "(event_id: integer)",
            },
            unregister_event = {
                type = "function",
                description = "*XXT* Unregister a listening event",
                args = "(event_name: string, event_id: integer)",
                returns = "()",
            },
        },
    },

    webview = {
        type = "lib",
        description = "webview module",
        childs = {
            show = {
                type = "function",
                description = "*XXT* Show a webview",
                args = "(options: table)",
                returns = "()",
            },
            hide = {
                type = "function",
                description = "*XXT* Hide a webview",
                args = "(WVID: integer)",
                returns = "()",
            },
            destroy = {
                type = "function",
                description = "*XXT* Destroy a webview",
                args = "(WVID: integer)",
                returns = "()",
            },
            frame = {
                type = "function",
                description = "*XXT* Get a webview's frame infomation",
                args = "(WVID: integer)",
                returns = "(frame: table)",
            },
            eval = {
                type = "function",
                description = "*XXT* Execute JS code on a webview and return the result string of the JS code execution.",
                args = "(JS_code: string[, WVID: integer])",
                returns = "(results: string)",
            },
        },
    },

    http = {
        type = "lib",
        description = "http module",
        childs = {
            get = {
                type = "function",
                description = "*XXT* Send an HTTP GET request\ntimeout return HTTP status code -1",
                args = "(URL: string[, timeout_s: number, request_headers: table, URL_no_escape: boolean])",
                returns = "(HTTP_status: integer, response_headers_json: string, response_data: string)",
            },
            post = {
                type = "function",
                description = "*XXT* Send an HTTP POST request\ntimeout return HTTP status code -1",
                args = "(URL: string[, timeout_s: number, request_headers: table, request_data: string, URL_no_escape: boolean])",
                returns = "(HTTP_status: integer, response_headers_json: string, response_data: string)",
            },
            head = {
                type = "function",
                description = "*XXT* 1.1.1+ Send an HTTP HEAD request\ntimeout return HTTP status code -1",
                args = "(URL: string[, timeout_s: number, request_headers: table, URL_no_escape: boolean])",
                returns = "(HTTP_status: integer, response_headers_json: string, response_data: string)",
            },
            delete = {
                type = "function",
                description = "*XXT* 1.1.1+ Send an HTTP DELETE request\ntimeout return HTTP status code -1",
                args = "(URL: string[, timeout_s: number, request_headers: table, URL_no_escape: boolean])",
                returns = "(HTTP_status: integer, response_headers_json: string, response_data: string)",
            },
            put = {
                type = "function",
                description = "*XXT* 1.1.1+ Send an HTTP PUT request\ntimeout return HTTP status code -1",
                args = "(URL: string[, timeout_s: number, request_headers: table, request_data: string, URL_no_escape: boolean])",
                returns = "(HTTP_status: integer, response_headers_json: string, response_data: string)",
            },
            download = {
                type = "function",
                description = "*XXT* 1.1.1+ Download a file via HTTP protocol\nIf the connection is successful, then return the table type download information, otherwise return the connection failure reason text description",
                args = "(URL: string, file_path: string[, timeout_s: number, resume_after_break: boolean, block_callback: function, buffer_size: number])",
                returns = "(ok: boolean, download_info: table|string)",
            },
        },
    },

    ftp = {
        type = "lib",
        description = "ftp module",
        childs = {
            download = {
                type = "function",
                description = "*XXT* 1.1.1+ Download a file via FTP protocol\nIf the connection is successful, then return the tabular download information, otherwise return the text description of the reason why the connection failed",
                args = "(URL: string, file_path: string[, timeout_s: number, resume_after_break: boolean, block_callback: function, buffer_size: number])",
                returns = "(ok: boolean, download_info: table|string)",
            },
            upload = {
                type = "function",
                description = "*XXT* 1.1.1+ Upload a file via FTP protocol\nIf the connection is successful then return the tabular upload information, otherwise return the text description of the reason why the connection failed",
                args = "(file_path: string, URL: string[, timeout_s: number, resume_after_break: boolean, block_callback: function, buffer_size: number])",
                returns = "(ok: boolean, upload_info: table|string)",
            },
        },
    },

    json = {
        type = "lib",
        description = "json module",
        childs = {
            encode = {
                type = "function",
                description = "*XXT* Convert a table to a JSON string",
                args = "(tab: table)",
                returns = "(string|nil)",
            },
            decode = {
                type = "function",
                description = "*XXT* Convert a JSON string into a table",
                args = "(JSON: string)",
                returns = "(string|table|number|json.null|nil)",
            },
            null = {
                type = "value",
                description = "*XXT* NULL Constants in JSON",
            },
        },
    },

    plist = {
        type = "lib",
        description = "plist module",
        childs = {
            read = {
                type = "function",
                description = "*XXT* Read a plist file and convert it to a table",
                args = "(file_name: string)",
                returns = "(table)",
            },
            write = {
                type = "function",
                description = "*XXT* Writing a table to a plist file",
                args = "(file_name: string, tab: table)",
                returns = "()",
            },
        },
    },

    utils = {
        type = "lib",
        description = "utils module",
        childs = {
            add_contacts = {
                type = "function",
                description = "*XXT* Add one or more contacts to the address book",
                args = "(contacts: table)",
                returns = "(ok: boolean)",
            },
            remove_all_contacts = {
                type = "function",
                description = "*XXT* Delete all contacts from Address Book",
                args = "()",
                returns = "(ok: boolean)",
            },
            qr_encode = {
                type = "function",
                description = "*XXT* Encode text into QR code image with transparent background color",
                args = "(text: string[, opt: table])",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            launch_args = {
                type = "function",
                description = "*XXT* 1.0.5+ Get the launch arguments of the script",
                args = "()",
                returns = "(launch_args: table)",
            },
            is_launch_via_app = {
                type = "function",
                description = "*XXT* 1.1.0-1+ Determines if the current script was launched from the App's Launch button.",
                args = "()",
                returns = "(is_launch_via_app: boolean)",
            },
            video_to_album = {
                type = "function",
                description = "*XXT* 1.1.2+ Importing a video file to album",
                args = "(file_path: string)",
                returns = "()",
            },
        },
    },

    sys = {
        type = "lib",
        description = "sys module",
        childs = {
            toast = {
                type = "function",
                description = "*XXT* Display the hint text at the bottom of the screen in the current orientation\nThis function is asynchronous, the total display time of the hint text is 2.8 seconds, which affects the color picking.",
                args = "(text: string[, orientation: integer])",
                returns = "()",
            },
            alert = {
                type = "function",
                description = "*XXT* Pop up a dialog box that can have 1~3 buttons, return the selected button\n block all threads",
                args = "(text: string[, timeout_s: number, title: string, button_0_title: string, button_1_title: string, button_2_title: string])",
                returns = "(choice: integer)",
            },
            input_box = {
                type = "function",
                description = [[
*XXT* Pop up a dialog box that can have 1~3 buttons and 1~2 input boxes, return what was typed and the button selected
Block all threads
Multiple overloads:
content = sys.input_box("describe content")
content = sys.input_box("Title", "This is the description content")
content = sys.input_box("Title", "This is the description of the content",0)
content = sys.input_box("title", "describe content", "textbox shadow hint",0)
content = sys.input_box("Title", "Description", "Textbox Shadow Hint", "Textbox Inside",0)
content = sys.input_box("Title", "Description", "Textbox Shadow Hint", "Content inside Textbox", "Default Button Title",0)
content1, content2 = sys.input_box("Title", "Description", {"Textbox1 Shadow Hint", "Textbox2 Shadow Hint"},0)
content1, content2 = sys.input_box("Title", "Description",{"Textbox1 Shadow Hint", "Textbox2 Shadow Hint"},{"Content inside Textbox1", "Content inside Textbox2"},0)
content1, content2, select = sys.input_box("title", "describe content",{"textbox1 shaded hint", "textbox2 shaded hint"},{"textbox1 content", "textbox2 content"}, "default_button_title", "button1_title", "button2_title",0)
        ]],
                args = "(Multiple_overloads)",
                returns = "()",
            },
            input_text = {
                type = "function",
                description = "*XXT* Input text in the foreground program where you can input text\nThe call of this function will affect the public clipboard, please note that before the call to back up the important data in the clipboard; in the case of damage to the system's public clipboard, the function of the text input will be invalid. That is, you can't copy and paste the text, you can't use it\nWhether or not to press enter: optional parameter, whether or not to press the enter key on the keyboard after the input is complete (send, search, etc.), default false",
                args = "(text: string[, need_enter:boolean])",
                returns = "()",
            },
            msleep = {
                type = "function",
                description = "*XXT* Let the current thread block and wait for a certain amount of time (in milliseconds)\nThis method may give way, and other threads may get a chance to run before this method returns.",
                args = "(ms: number)",
                returns = "()",
            },
            time_of_day = {
                type = "function",
                description = "*XXT* Getting microsecond time information",
                args = "(info: table)",
                returns = "()",
            },
            net_time = {
                type = "function",
                description = "*XXT* Get network time\ntimeout seconds, optional parameter, used to set the maximum waiting time to get network time networking, the default 2\ntimeout return 0",
                args = "([s: number])",
                returns = "(time_s: integer)",
            },
            mtime = {
                type = "function",
                description = "*XXT* Returns a millisecond timestamp",
                args = "()",
                returns = "(time_ms: integer)",
            },
            rnd = {
                type = "function",
                description = "*XXT* Generate a true random number\n range 0 ~ 4294967295",
                args = "()",
                returns = "(rand: integer)",
            },
            memory_info = {
                type = "function",
                description = "*XXT* Get information about the current memory state of the device",
                args = "()",
                returns = "(info: table)",
            },
            available_memory = {
                type = "function",
                description = "*XXT* Get the value of the currently available memory of the device (unit: MB)",
                args = "()",
                returns = "(available: number)",
            },
            free_disk_space = {
                type = "function",
                description = "*XXT* Get the value of the current unused storage space of the device (unit: MB)\nRoot Path: Optional parameter, the mount point, can be \"/var\" or \"/\", which represent the user space and system space respectively. If there is external storage such as a memory card, there can be other values.",
                args = "([root: string])",
                returns = "(free_space: number)",
            },
            log = {
                type = "function",
                description = "*XXT* Exporting standard system logs",
                args = "(text: string)",
                returns = "()",
            },
            version = {
                type = "function",
                description = "*XXT* Get system version",
                args = "()",
                returns = "(version: string)",
            },
            xtversion = {
                type = "function",
                description = "*XXT* Get XXTouch version",
                args = "()",
                returns = "(version: string)",
            },
            mgcopyanswer = {
                type = "function",
                description = "*XXT* 1.1.2+ asks the system a question; the underlying call is to iOS's built-in MGCopyAnswer",
                args = "(question: string)",
                returns = "(answer: string|table|nil)",
            },
            MGCopyAnswer = {
                type = "function",
                description = "*XXT* 1.1.2+ asks the system a question; the underlying call is to iOS's built-in MGCopyAnswer",
                args = "(question: string)",
                returns = "(answer: string|table|nil)",
            },
        },
    },

    screen = {
        type = "lib",
        description = "screen module",
        childs = {
            init = {
                type = "function",
                description = "*XXT* Initializing the orientation for color picking or clicking\nwill affect the behavior of the functions related to get_color, find_color, and find_image\n0 for HOME on the bottom \n1 for HOME on the right \n2 for HOME on the left \n3 for HOME on the top",
                args = "(orientation: integer)",
                returns = "()",
            },
            rotate_xy = {
                type = "function",
                description = "*XXT* 1.1.1+ Convert potrait orientation to other orientation\n0 for HOME down\n1 for HOME on the right\n2 for HOME on the left\n3 for HOME on the top",
                args = "(x: integer, y: integer, orientation: integer)",
                returns = "(x1: integer, y1: integer)",
            },
            init_home_on_bottom = {
                type = "function",
                description = "*XXT* Equivalent to screen.init(0)",
                args = "()",
                returns = "()",
            },
            init_home_on_right = {
                type = "function",
                description = "*XXT* Equivalent to screen.init(1)",
                args = "()",
                returns = "()",
            },
            init_home_on_left = {
                type = "function",
                description = "*XXT* Equivalent to screen.init(2)",
                args = "()",
                returns = "()",
            },
            init_home_on_top = {
                type = "function",
                description = "*XXT* Equivalent to screen.init(3)",
                args = "()",
                returns = "()",
            },
            size = {
                type = "function",
                description = "*XXT* Get screen size",
                args = "()",
                returns = "(width: integer, height: integer)",
            },
            keep = {
                type = "function",
                description = "*XXT* Keeps the current screen content unchanged in the script Calls the get_color, find_color, image, find_image and other functions directly to the content of the hold. This function is an optimization class function to provide performance optimization for a large number of static image processing functions.",
                args = "([keep: boolean])",
                returns = "()",
            },
            unkeep = {
                type = "function",
                description = "*XXT* Inverse function of screen.keep",
                args = "([unkeep: boolean])",
                returns = "()",
            },
            is_kept = {
                type = "function",
                description = "*XXT* 1.2+ Get the current screen.keep state",
                args = "()",
                returns = "(is_kept: boolean)",
            },
            get_color = {
                type = "function",
                description = "*XXT* Get the color of a coordinate point on the screen",
                args = "(x: integer, y: integer)",
                returns = "(color: integer)",
            },
            get_color_rgb = {
                type = "function",
                description = "*XXT* Gets the color of a coordinate point on the screen and splits it into R G B forms.",
                args = "(x: integer, y: integer)",
                returns = "(R: integer, G: integer, B: integer)",
            },
            is_colors = {
                type = "function",
                description = "*XXT* Match the colors of several points on the screen",
                args = "(pclist: table[, similarity: integer])",
                returns = "(matched: boolean)",
            },
            find_color = {
                type = "function",
                description = "*XXT* Finding colors on the screen",
                args = "(Multiple_overloads)",
                returns = "(Multiple_overloads)",
            },
            image = {
                type = "function",
                description = "*XXT* Get an image of a range of the screen or full screen",
                args = "([left: integer, top: integer, right: integer, bottom: integer])",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            ocr_text = {
                type = "function",
                description = "*XXT* Recognize text on screen area",
                args = "(left: integer, top: integer, right: integer, bottom: integer[, lang: string | table, binarization: number|table])",
                returns = "(text: string)",
            },
            find_image = {
                type = "function",
                description = "*XXT* Finding the location of an image on the screen",
                args = "(image: image_object | string[, left: integer, top: integer, right: integer, bottom: integer])",
                returns = "(x: integer, y: integer)",
            },
        },
    },

    file = {
        type = "lib",
        description = "file module",
        childs = {
            exists = {
                type = "function",
                description = "*XXT* 1.1.0+ Determine whether a file or directory exists or not \n does not exist return false\n exists and is a file return \"file\"\n exists and is a directory return \"directory\"",
                args = "(file_name: string)",
                returns = "(exists | \"file\" | \"directory\")",
            },
            list = {
                type = "function",
                description = "*XXT* 1.1.0+ Get a list of all file names in a directory \n If the directory does not exist or the path is a file then return nil, otherwise return a list of directory files",
                args = "(directory: string)",
                returns = "(list: table | nil)",
            },
            size = {
                type = "function",
                description = "*XXT* 1.1.0+ Get the size of a file\n Returns nil if the file does not exist or the filename is a directory, otherwise returns the size of the file (unit: bytes)",
                args = "(file_name: string)",
                returns = "(size: integer | nil)",
            },
            reads = {
                type = "function",
                description = "*XXT* 1.1.0+ Read all the data of a file \n file does not exist to return nil, otherwise return the data of the entire file",
                args = "(file_name: string)",
                returns = "(data: string | nil)",
            },
            writes = {
                type = "function",
                description = "*XXT* 1.1.0+ Write data overwrite to file \n operation success return true, operation failure return false",
                args = "(file_name: string, data: string)",
                returns = "(ok: boolean)",
            },
            appends = {
                type = "function",
                description = "*XXT* 1.1.0+ Append data to the end of the file \n operation success return true, operation failure return false",
                args = "(file_name: string, data: string)",
                returns = "(ok: boolean)",
            },
            line_count = {
                type = "function",
                description = "*XXT* 1.1.0+ Count the total number of lines of a text file \n return to the total number of lines of the file, the file does not exist to return nil",
                args = "(file_name: string)",
                returns = "(count: integer | nil)",
            },
            get_line = {
                type = "function",
                description = "*XXT* 1.1.0+ Get the data of a specified line of a text file \nline_number is a negative number for the penultimate line number, 0 for the logical line after the last line \n line number is not enough to return the empty string, the file does not exist to return nil",
                args = "(file_name: string, line_number: integer)",
                returns = "(text: string | nil)",
            },
            set_line = {
                type = "function",
                description = "*XXT* 1.1.0+ Set the content of the specified line of the text file \nline_number is a negative number is the penultimate line number, 0 is the logical line after the last line \n operation success return true, operation failure return false",
                args = "(file_name: string, line_number: integer, data: string)",
                returns = "(ok: boolean)",
            },
            insert_line = {
                type = "function",
                description = "*XXT* 1.1.0+ Insert the content before the specified line in the text file \nline_number is a negative number is the number of the penultimate line, 0 is the logical line after the last line \n operation success return true, operation failure return false",
                args = "(file_name: string, line_number: integer, data: string)",
                returns = "(ok: boolean)",
            },
            remove_line = {
                type = "function",
                description = "*XXT* 1.1.0+ Remove the specified line in the file \nline_number is a negative number is the countdown line number, 0 is the logical line after the last line \n operation success return true, operation failure return false",
                args = "(file_name: string, line_number: integer)",
                returns = "(ok: boolean)",
            },
            get_lines = {
                type = "function",
                description = "*XXT* 1.1.0+ Get all lines of a text file \n return a sequential table, the file does not exist to return nil",
                args = "(file_name: string)",
                returns = "(list: table)",
            },
            set_lines = {
                type = "function",
                description = "*XXT* 1.1.0+ Write a sequential table transformation to a file line by line overwrite \n operation success return true, operation failure return false",
                args = "(file_name: string, lines: table)",
                returns = "(ok: boolean)",
            },
            insert_lines = {
                type = "function",
                description = "*XXT* 1.1.0+ Insert a sequential table conversion line by line into the file before the specified line \nline_number is a negative number is the number of the penultimate line, 0 is the logical line after the last line \n operation success return true, operation failure return false",
                args = "(file_name: string, line_number: integer, lines: table)",
                returns = "(ok: boolean)",
            },
            md5 = {
                type = "function",
                description = "*XXT* 1.2.4+ Calculates the MD5 value of a file as hexadecimal text, and returns an empty string if the file does not exist.",
                args = "(file_name: string)",
                returns = "(md5: string)",
            },
            sha1 = {
                type = "function",
                description = "*XXT* 1.2.4+ Calculates the SHA1 value of a file as hexadecimal text, and returns an empty string if the file does not exist.",
                args = "(file_name: string)",
                returns = "(sha1: string)",
            },
        },
    },

    image = {
        type = "lib",
        description = "image module",
        childs = {
            new = {
                type = "function",
                description = "*XXT* Creates a blank image object of the specified size",
                args = "(width: integer, height: integer)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            new_text_image = {
                type = "function",
                description = "*XXT* Create a new text image object",
                args = "(text: string, options: table)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            load_file = {
                type = "function",
                description = "*XXT* Creating a image object from a file",
                args = "(file_name: string)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            load_data = {
                type = "function",
                description = "*XXT* Creating a image object from a data string",
                args = "(data: string)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            is = {
                type = "function",
                description = "*XXT* Determine if a value is a image object",
                args = "(value)",
                returns = "(is: boolean)",
            },
            oper_merge = {
                type = "function",
                description = "*XXT* Image File Merge\n Merge Type 0 Horizontal Merge 1 Vertical Merge\n Image Quality Range 0.0~1.0\n Returns 0 for success, all other values are failures.",
                args = "(file_list: table, out_file_path: string, merge_type: integer, quality: number)",
                returns = "(result: integer)",
            },
        },
    },

    dialog_object = {
        type = "class",
        description = "dialog object",
        childs = {
            config = {
                type = "method",
                description = "*XXT* 1.0.9+ Sets the current dialog box object options config name",
                args = "(dialog: dialog_object, name: string)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            timeout = {
                type = "method",
                description = "*XXT* 1.0.9+ Set the timeout for the current dialog object (unit: second)",
                args = "(dialog: dialog_object, timeout_s: number)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            title = {
                type = "method",
                description = "*XXT* 1.0.9+ Set the title of the current dialog object",
                args = "(dialog: dialog_object, title: string)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            set_config = {
                type = "method",
                description = "*XXT* 1.2+ Sets the current dialog box object options config name",
                args = "(dialog: dialog_object, name: string)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            set_timeout = {
                type = "method",
                description = "*XXT* 1.2+ Set the timeout for the current dialog object (unit: second)",
                args = "(dialog: dialog_object, timeout_s: number)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            set_title = {
                type = "method",
                description = "*XXT* 1.2+ Set the title of the current dialog object",
                args = "(dialog: dialog_object, title: string)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            set_size = {
                type = "method",
                description = "*XXT* 1.2+ Setting the size of the current dialog object will center the dialog box",
                args = "(dialog: dialog_object, width: integer, height: integer)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            set_frame = {
                type = "method",
                description = "*XXT* 1.2+ Setting the position and size of the current dialog object",
                args = "(dialog: dialog_object, left: integer, top: integer, right: integer, bottom: integer)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            set_corner_radius = {
                type = "method",
                description = "*XXT* 1.2+ Sets the radius of the rounded corners of the current dialog box object \n the default radius of rounded corners of dialog boxes 0, that is, square corners",
                args = "(dialog: dialog_object, radius: number)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            show = {
                type = "method",
                description = "*XXT* 1.0.9+ Display a dialog object to the foreground",
                args = "(dialog: dialog_object)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_label = {
                type = "method",
                description = "*XXT* 1.0.9+ Add a label to the dialog object",
                args = "(dialog: dialog_object, label: string)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_input = {
                type = "method",
                description = "*XXT* 1.0.9+ Add an input field to the dialog object",
                args = "(dialog: dialog_object, label: string[, default: string])",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_image = {
                type = "method",
                description = "*XXT* 1.1.0+ Add a image object to the dialog box object",
                args = "(dialog: dialog_object, image: image_object)",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_picker = {
                type = "method",
                description = "*XXT* 1.0.9+ Add a picker to the dialog box object",
                args = "(dialog: dialog_object, label: string, option_list: table[, default: string])",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_switch = {
                type = "method",
                description = "*XXT* 1.0.9+ Add a switch to the dialog object",
                args = "(dialog: dialog_object, label: string[, default: boolean])",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_checkbox = {
                type = "method",
                description = "*XXT* 1.0.9+ Add a checkbox to the dialog object",
                args = "(dialog: dialog_object, label: string, option_list: table[, defaults: table])",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_radio = {
                type = "method",
                description = "*XXT* 1.1.1+ Adding a radio group to a dialog box object",
                args = "(dialog: dialog_object, label: string, option_list: table[, default: string])",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
            add_range = {
                type = "method",
                description = "*XXT* 1.1.1+ Adding a range picker to the dialog object",
                args = "(dialog: dialog_object, label: string, range: table[, default: number])",
                returns = "(dialog: dialog_object)",
                valuetype = "dialog_object",
            },
        },
    },

    image_object = {
        type = "class",
        description = "image object",
        childs = {
            copy = {
                type = "method",
                description = "*XXT* Creating a copy image object from an image object",
                args = "(image: image_object)",
                returns = "(new_image: image_object)",
                valuetype = "image_object",
            },
            crop = {
                type = "method",
                description = "*XXT* New copy of image object by intercepting part of the image object",
                args = "(image: image_object[, left: integer, top: integer, right: integer, bottom: integer])",
                returns = "(new_image: image_object)",
                valuetype = "image_object",
            },
            save_to_album = {
                type = "method",
                description = "*XXT* Exporting image object to the ALBUM",
                args = "(image: image_object)",
                returns = "()",
            },
            save_to_png_file = {
                type = "method",
                description = "*XXT* Exporting a image object to a PNG format file",
                args = "(image: image_object, file_name: string)",
                returns = "()",
            },
            save_to_jpeg_file = {
                type = "method",
                description = "*XXT* Exporting a image object to a JPEG format file",
                args = "(image: image_object, file_name: string[, quality: number])",
                returns = "()",
            },
            png_data = {
                type = "method",
                description = "*XXT* Get the PNG format data of the image object",
                args = "(image: image_object)",
                returns = "(data: string)",
            },
            jpeg_data = {
                type = "method",
                description = "*XXT* Get the JPEG format data of an image object",
                args = "(image: image_object)",
                returns = "(data: string)",
            },
            turn_left = {
                type = "method",
                description = "*XXT* The image object is rotated 90 degrees to the left",
                args = "(image: image_object)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            turn_right = {
                type = "method",
                description = "*XXT* The image object is rotated 90 degrees to the right",
                args = "(image: image_object)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            turn_upondown = {
                type = "method",
                description = "*XXT* The image object is rotated 180 degrees",
                args = "(image: image_object)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            size = {
                type = "method",
                description = "*XXT* Get the size of the image object",
                args = "(image: image_object)",
                returns = "(width: integer, height: integer)",
            },
            get_color = {
                type = "method",
                description = "*XXT* Get the color of a point of a image object",
                args = "(image: image_object, x: integer, y: integer)",
                returns = "(color: integer)",
            },
            set_color = {
                type = "method",
                description = "*XXT* Setting the color of a point of a image object",
                args = "(image: image_object, x: integer, y: integer, color: integer)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            replace_color = {
                type = "method",
                description = "*XXT* Replaces a color (or an approximate color) on a image object with another color.",
                args = "(image: image_object, original: integer, target: integer[, similarity: integer])",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            draw_image = {
                type = "method",
                description = "*XXT* Drawing another image object within a image object",
                args = "(image: image_object, image2: image_object, options: table)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            binaryzation = {
                type = "method",
                description = "*XXT* Binarize the image object",
                args = "(image: image_object, opt: table)",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            find_color = {
                type = "method",
                description = "*XXT* Find color in image object, same as screen.find_color.",
                args = "(image: image_object, Multiple_overloads)",
                returns = "(Multiple_overloads)",
            },
            qr_decode = {
                type = "method",
                description = "*XXT* Decode a QR code image object to text",
                args = "(image: image_object)",
                returns = "(text: string|nil)",
            },
            cv_find_image = {
                type = "method",
                description = "*XXT* Find the most similar position in a image object and its similarity to another image object.",
                args = "(image: image_object, image2: image_object)",
                returns = "(x: integer, y: integer, similarity: number)",
            },
            cv_binaryzation = {
                type = "method",
                description = "*XXT* CV Binarize the image object",
                args = "(image: image_object[, threshold: number])",
                returns = "(image: image_object)",
                valuetype = "image_object",
            },
            cv_resize = {
                type = "method",
                description = "*XXT* Create a stretched image object of another size from the image object",
                args = "(image: image_object, width: integer, height: integer)",
                returns = "(new_image: image_object)",
                valuetype = "image_object",
            },
            tess_ocr = {
                type = "method",
                description = "*XXT* Recognize text on this image object",
                args = "(image: image_object, options: table)",
                returns = "(text: string)",
            },
            qr_scan = {
                type = "method",
                description = "*XXT* 1.2.4+ Decode a QR code image object to get the information about the QR code.",
                args = "(image: image_object)",
                returns = "(data: table)",
            },
        },
    },

    touch = {
        type = "lib",
        description = "touch module",
        childs = {
            show_pose = {
                type = "function",
                description = "*XXT* Sets whether the touch function or method displays dots.",
                args = "(show: boolean)",
                returns = "()",
            },
            tap = {
                type = "function",
                description = "*XXT* Simulates a finger touching the screen once at a specified location \n This method may give way, and other threads may be given a chance to run before this method returns.",
                args = "(x: integer, y: integer[, release_delay_ms: integer, after_delay_ms: integer])",
                returns = "()",
            },
            on = {
                type = "function",
                description = "*XXT* Simulate the finger touching the specified position on the screen",
                args = "(x: integer, y: integer)",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
            down = {
                type = "function",
                description = "*XXT* Simulate the finger touching the specified position on the screen",
                args = "(x: integer, y: integer)",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
            move = {
                type = "function",
                description = "*XXT* To simulate the movement of a finger from the current position to another position \n this method may give way, and other threads may be given a chance to run before this method returns",
                args = "(tevent: touch_event|integer, x: integer, y: integer)",
                returns = "(tevent: touch_event|nil)",
                valuetype = "touch_event",
            },
            off = {
                type = "function",
                description = "*XXT* Simulates a finger leaving the screen from the current position or a specified position \n This method call releases the current touch event object",
                args = "(tevent: touch_event|integer[, x: integer, y: integer])",
                returns = "()",
            },
            up = {
                type = "function",
                description = "*XXT* Simulates a finger leaving the screen from the current position or a specified position \n This method call releases the current touch event object",
                args = "(tevent: touch_event|integer[, x: integer, y: integer])",
                returns = "()",
            },
        },
    },

    touch_event = {
        type = "class",
        description = "touch event object",
        childs = {
            press = {
                type = "method",
                description = "Simulates the finger applying pressure at the current position, this method can only be used on devices that support 3D Touch \n this method may give way, and other threads may get a chance to run before this method returns",
                args = "([tevent: touch_event, pressure: integer, speed: integer])",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
            down = {
                type = "function",
                description = "*XXT* Simulate the finger touching the specified position on the screen",
                args = "(x: integer, y: integer)",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
            move = {
                type = "function",
                description = "*XXT* To simulate the movement of a finger from the current position to another position \n this method may give way, and other threads may be given a chance to run before this method returns",
                args = "(tevent: touch_event|integer, x: integer, y: integer)",
                returns = "(tevent: touch_event|nil)",
                valuetype = "touch_event",
            },
            off = {
                type = "function",
                description = "*XXT* Simulates a finger leaving the screen from the current position or a specified position \n This method call releases the current touch event object",
                args = "(tevent: touch_event|integer[, x: integer, y: integer])",
                returns = "()",
            },
            up = {
                type = "function",
                description = "*XXT* Simulates a finger leaving the screen from the current position or a specified position \n This method call releases the current touch event object",
                args = "(tevent: touch_event|integer[, x: integer, y: integer])",
                returns = "()",
            },
            step_len = {
                type = "function",
                description = "*XXT* Sets the step size of the current touch event object using the move method.",
                args = "(length: integer)",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
            step_delay = {
                type = "function",
                description = "*XXT* Sets the delay (in milliseconds) for each step that the current touch event object slides using the move method.",
                args = "(step_delay_ms: number)",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
            delay = {
                type = "function",
                description = "*XXT* A delay function that has no effect on an object and only serves to block the current thread. This method has the alias :msleep",
                args = "(delay_ms: number)",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
            msleep = {
                type = "function",
                description = "*XXT* A delay function that has no effect on an object and only serves to block the current thread. This method has the alias :delay",
                args = "(delay_ms: number)",
                returns = "(tevent: touch_event)",
                valuetype = "touch_event",
            },
        },
    },

    key = {
        type = "lib",
        description = "key module",
        childs = {
            press = {
                type = "function",
                description = "*XXT* Simulates pressing a physical button and then releasing it",
                args = "(keycode: string)",
                returns = "()",
            },
            down = {
                type = "function",
                description = "*XXT* Simulates the pressing of physical buttons",
                args = "(keycode: string)",
                returns = "()",
            },
            up = {
                type = "function",
                description = "*XXT* Simulates releasing a pressed physical button",
                args = "(keycode: string)",
                returns = "()",
            },
            send_text = {
                type = "function",
                description = "*XXT* Simulates continuous text typing\n adjusts the interval between each keystroke and the length of time the SHIFT key is held down for characters that require it to be typed.",
                args = "(text: string, step_delay: number, SHIFT_delay: number)",
                returns = "()",
            },
        },
    },

    pasteboard = {
        type = "lib",
        description = "pasteboard module",
        childs = {
            write = {
                type = "function",
                description = "*XXT* Write contents to the clipboard",
                args = "(data: string[, UTI: string])",
                returns = "()",
            },
            read = {
                type = "function",
                description = "*XXT* Getting contents from the clipboard",
                args = "([UTI: string])",
                returns = "(data: string)",
            },
        },
    },

    clear = {
        type = "lib",
        description = "clear module",
        childs = {
            memory = {
                type = "function",
                description = "*XXT* Clean up system memory\nThis function blocks all threads of the script until the cleanup is complete\nThis function may cause the entire system to crash",
                args = "([force: boolean])",
                returns = "()",
            },
            keychain = {
                type = "function",
                description = "*XXT* Clear the keychain information that a message is associated with\nnever * can't * pass in a parameter you don't understand\nusually pass in the inverse domain name of the application's company e.g. clear.keychain('com.tencent')",
                args = "(associated: string)",
                returns = "()",
            },
            all_keychain = {
                type = "function",
                description = "*XXT* Clear all keychains",
                args = "()",
                returns = "()",
            },
            pasteboard = {
                type = "function",
                description = "*XXT* Clear clipboard data, some information will exist in the clipboard, such as OpenUDID",
                args = "()",
                returns = "()",
            },
            cookies = {
                type = "function",
                description = "*XXT* Clearing the cookies",
                args = "()",
                returns = "()",
            },
            caches = {
                type = "function",
                description = "*XXT* Clearing the caches",
                args = "()",
                returns = "()",
            },
            all_photos = {
                type = "function",
                description = "*XXT* Clear all local photos from ALBUM, without affecting iCloud photo streams",
                args = "()",
                returns = "()",
            },
            idfav = {
                type = "function",
                description = "*XXT* Reset device IDFA and IDFV",
                args = "([new_idfavs: string])",
                returns = "(old_idfavs: string|nil)",
            },
            app_data = {
                type = "function",
                description = "*XXT* Clean up an application archive, available only for sandboxed applications",
                args = "(bid: string)",
                returns = "(ok: success)",
            },
        },
    },

    app = {
        type = "lib",
        description = "app module",
        childs = {
            bundle_path = {
                type = "function",
                description = "*XXT* Get App's bundle path",
                args = "(bid: string)",
                returns = "(path: string)",
            },
            data_path = {
                type = "function",
                description = "*XXT* Get App's data path",
                args = "(bid: string)",
                returns = "(path: string)",
            },
            group_info = {
                type = "function",
                description = "*XXT* 1.1.3+ Get App's group information",
                args = "(bid: string)",
                returns = "(group_info: table)",
            },
            plugin_info = {
                type = "function",
                description = "*XXT* 1.3.8+ Get App's plugin information",
                args = "(bid: string)",
                returns = "(plugin_info: table)",
            },
            pop_banner = {
                type = "function",
                description = "*XXT* 1.1.3+ Pop a banner",
                args = "(bid: string, title: string, message: string)",
                returns = "()",
            },
            run = {
                type = "function",
                description = "*XXT* Launch the application\nlaunch status returns 0 for success, all other values return failure.",
                args = "(bid: string)",
                returns = "(status: integer)",
            },
            close = {
                type = "function",
                description = "*XXT* Kill the application with either bid or pid.",
                args = "(bid_or_pid: string|integer)",
                returns = "()",
            },
            quit = {
                type = "function",
                description = "*XXT* Simulate exiting an application using swipe up",
                args = "(bid: string)",
                returns = "()",
            },
            is_running = {
                type = "function",
                description = "*XXT* Detect if an application is running (no distinction between front and backend)",
                args = "(bid: string)",
                returns = "(is_running: boolean)",
            },
            input_text = {
                type = "function",
                description = "*XXT* Entering text in the App",
                args = "(text: string[, need_enter:boolean])",
                returns = "()",
            },
            localized_name = {
                type = "function",
                description = "*XXT* Get the localized name of the application",
                args = "(bid: string)",
                returns = "(name: string)",
            },
            png_data_for_bid = {
                type = "function",
                description = "*XXT* Get the application's icon PNG data",
                args = "(bid: string)",
                returns = "(data: string)",
            },
            pid_for_bid = {
                type = "function",
                description = "*XXT* Get the process identifier of the application, if the application is not running return 0",
                args = "(bid: string)",
                returns = "(pid: integer)",
            },
            used_memory = {
                type = "function",
                description = "*XXT* Get the current memory consumption of the application (in MB)",
                args = "(bid: string)",
                returns = "(used_mem: number)",
            },
            front_bid = {
                type = "function",
                description = "*XXT* Get the bundle identifier of the frontend application",
                args = "()",
                returns = "(bid: string)",
            },
            front_pid = {
                type = "function",
                description = "*XXT* Get the process identifier (pid) of the foreground application",
                args = "()",
                returns = "(pid: integer)",
            },
            open_url = {
                type = "function",
                description = "*XXT* Jump to URL",
                args = "(url: string)",
                returns = "()",
            },
            bundles = {
                type = "function",
                description = "*XXT* Get a list of bundle identifiers for all installed apps",
                args = "()",
                returns = "(bids: table)",
            },
            all_procs = {
                type = "function",
                description = "*XXT* Get the process list",
                args = "()",
                returns = "(proc_list: table)",
            },
            set_speed_add = {
                type = "function",
                description = "*XXT* Setting up foreground application time speed",
                args = "(speed: number)",
                returns = "()",
            },
            install = {
                type = "function",
                description = "*XXT* Install an ipa application\n make sure that the AppSync is installed on the target device before calling this function.",
                args = "(ipa_path: string)",
                returns = "(flag: boolean)",
            },
            uninstall = {
                type = "function",
                description = "*XXT* Uninstalling an application",
                args = "(bundle_id: string)",
                returns = "(flag: boolean)",
            },
        },
    },

    device = {
        type = "lib",
        description = "device module",
        childs = {
            reset_idle = {
                type = "function",
                description = "*XXT* Reset IDLE countdown",
                args = "()",
                returns = "()",
            },
            lock_screen = {
                type = "function",
                description = "*XXT* Lock screen",
                args = "()",
                returns = "()",
            },
            unlock_screen = {
                type = "function",
                description = "*XXT* Unlock screen",
                args = "([password: string])",
                returns = "()",
            },
            is_screen_locked = {
                type = "function",
                description = "*XXT* Determine if the screen is locked",
                args = "()",
                returns = "(locked: boolean)",
            },
            front_orien = {
                type = "function",
                description = "*XXT* Get the screen orientation of the foreground application",
                args = "()",
                returns = "(orientation: integer)",
            },
            lock_orien = {
                type = "function",
                description = "*XXT* Lock device screen orientation lock",
                args = "()",
                returns = "()",
            },
            unlock_orien = {
                type = "function",
                description = "*XXT* Unlock device screen orientation lock",
                args = "()",
                returns = "()",
            },
            is_orien_locked = {
                type = "function",
                description = "*XXT* Determine if the screen orientation lock is locked",
                args = "()",
                returns = "(is_orien_locked: boolean)",
            },
            vibrator = {
                type = "function",
                description = "*XXT* Vibrate me. (You can't vibrate without a vibrating motor.)",
                args = "()",
                returns = "()",
            },
            play_sound = {
                type = "function",
                description = "*XXT* This function does not block the script, and the sound played will stop when the script stops\nIf the script needs to play the full sound, make sure you delay the exit",
                args = "(file_path: string)",
                returns = "()",
            },
            type = {
                type = "function",
                description = "*XXT* Get device type\n e.g. 'iPad3,1'",
                args = "()",
                returns = "(device_type: string)",
            },
            name = {
                type = "function",
                description = "*XXT* Get device name",
                args = "()",
                returns = "(name: string)",
            },
            set_name = {
                type = "function",
                description = "*XXT* Set device name",
                args = "(name: string)",
                returns = "()",
            },
            udid = {
                type = "function",
                description = "*XXT* Get device's UDID",
                args = "()",
                returns = "(UDID: string)",
            },
            serial_number = {
                type = "function",
                description = "*XXT* Get device's serial number",
                args = "()",
                returns = "(serial_number: string)",
            },
            wifi_mac = {
                type = "function",
                description = "*XXT* Get device's WiFi MAC address",
                args = "()",
                returns = "(WiFiMAC: string)",
            },
            ifaddrs = {
                type = "function",
                description = "*XXT* Get device's network interfaces",
                args = "()",
                returns = "(interfaces: table)",
            },
            battery_level = {
                type = "function",
                description = "*XXT* 1.0.9+ Get the remaining battery power of the current device (range 0.0~1.0)",
                args = "()",
                returns = "(level: number)",
            },
            battery_state = {
                type = "function",
                description = "*XXT* 1.0.9+ Get current device battery state",
                args = "()",
                returns = "(state: string)",
            },
            join_wifi = {
                type = "function",
                description = "*XXT* 1.2+ Connecting to a WLAN\n Encryption Type:\n0 means no encryption\n1 means encryption",
                args = "(SSID: string, password: string, encryption: integer)",
                returns = "()",
            },
            turn_on_wifi = {
                type = "function",
                description = "*XXT* Turn on device's WiFi",
                args = "()",
                returns = "()",
            },
            turn_off_wifi = {
                type = "function",
                description = "*XXT* Turn off device's WiFi",
                args = "()",
                returns = "()",
            },
            turn_on_data = {
                type = "function",
                description = "*XXT* Turn on device's data",
                args = "()",
                returns = "()",
            },
            turn_off_data = {
                type = "function",
                description = "*XXT* Turn off device's data",
                args = "()",
                returns = "()",
            },
            turn_on_bluetooth = {
                type = "function",
                description = "*XXT* Turn on device's bluetooth",
                args = "()",
                returns = "()",
            },
            turn_off_bluetooth = {
                type = "function",
                description = "*XXT* Turn off device's bluetooth",
                args = "()",
                returns = "()",
            },
            turn_on_airplane = {
                type = "function",
                    description = "*XXT* Turn on device's airplane mode",
                args = "()",
                returns = "()",
            },
            turn_off_airplane = {
                type = "function",
                description = "*XXT* Turn off device's airplane mode",
                args = "()",
                returns = "()",
            },
            flash_on = {
                type = "function",
                description = "*XXT* Turn on device's flash",
                args = "()",
                returns = "()",
            },
            flash_off = {
                type = "function",
                description = "*XXT* Turn off device's flash",
                args = "()",
                returns = "()",
            },
            reduce_motion_on = {
                type = "function",
                description = "*XXT* Enable the \"ReduceMotion\"",
                args = "()",
                returns = "()",
            },
            reduce_motion_off = {
                type = "function",
                description = "*XXT* Disable the \"ReduceMotion\"",
                args = "()",
                returns = "()",
            },
            assistive_touch_on = {
                type = "function",
                description = "*XXT* Enable the \"AssistiveTouch\"",
                args = "()",
                returns = "()",
            },
            assistive_touch_off = {
                type = "function",
                description = "*XXT* Disable the \"AssistiveTouch\"",
                args = "()",
                returns = "()",
            },
            set_autolock_time = {
                type = "function",
                description = "*XXT* Setting the number of minutes the device will automatically lock the screen",
                args = "(minutes: number)",
                returns = "()",
            },
            brightness = {
                type = "function",
                description = "*XXT* Get the brightness of the current device screen, range 0.0~1.0",
                args = "()",
                returns = "(level: number)",
            },
            set_brightness = {
                type = "function",
                description = "*XXT* Set the brightness of the device screen, range 0.0~1.0",
                args = "(level: number)",
                returns = "()",
            },
            set_volume = {
                type = "function",
                description = "*XXT* Set the global volume of the device, range 0.0~1.0",
                args = "(level: number)",
                returns = "()",
            },
        },
    },

    vpnconf = {
        type = "lib",
        description = "VPN configuration module",
        childs = {
            create = {
                type = "function",
                description = "*XXT* 1.2-3+ Creating a VPN Configuration",
                args = "(info: table)",
                returns = "(ok: boolean)",
            },
            list = {
                type = "function",
                description = "*XXT* 1.2-3+ Returned VPN List",
                args = "()",
                returns = "(list: table or nil)",
            },
            select = {
                type = "function",
                description = "*XXT* 1.2-3+ Selecting an Existing VPN Configuration",
                args = "(name_or_id: string)",
                returns = "(ok: boolean)",
            },
            connect = {
                type = "function",
                description = "*XXT* 1.2-3+ Connect to the currently selected VPN configuration",
                args = "()",
                returns = "(ok: boolean)",
            },
            disconnect = {
                type = "function",
                description = "*XXT* 1.2-3+ Disconnect the currently connected VPN configuration",
                args = "()",
                returns = "(ok: boolean)",
            },
            status = {
                type = "function",
                description = "*XXT* 1.2-3+ Get the status of the current VPN",
                args = "()",
                returns = "(status: table or nil)",
            },
        },
    },

    xpp = {
        type = "lib",
        description = "xpp module",
        childs = {
            ui_setup = {
                type = "function",
                description = "*XXT* 1.2+ Initializes the default configuration of one of the XUI interface in the current script bundle",
                args = "(xui_path: string)",
                returns = "()",
            },
            show_ui = {
                type = "function",
                description = "*XXT* 1.2+ Launching an XUI configuration interface from the current script bundle to the frontend via the main program",
                args = "(xui_path: string)",
                returns = "()",
            },
            info = {
                type = "function",
                description = "*XXT* 1.2+ Get information about the current script bundle",
                args = "()",
                returns = "(info: table)",
            },
            bundle_path = {
                type = "function",
                description = "*XXT* 1.2+ Get the absolute path to the current script bundle",
                args = "()",
                returns = "(path: string)",
            },
            resource_path = {
                type = "function",
                description = "*XXT* 1.2+ Get the absolute path of a resource in the current script bundle\nsupport localization, resource file does not exist to return nil",
                args = "(res_path: string)",
                returns = "(path: string|nil)",
            },
        },
    },
}
