Systems, devices, and methods for assembling and presenting interactive electronic documents

Abstract

Techniques are provided for the assembly and presentation of interactive electronic documents. Some embodiments include a computing device. The computing device includes at least one processor that executes computer-executable components stored in at least one memory device. The computer-executable components can include a runtime component configured to apply navigation rules corresponding to a navigation mode for a series of views, where at least one of the series of views can include respective prompts. The computer-executable components can also include a coordination component configured to cause the presentation of at least one of the series of views in response to the runtime component applying the navigation rules.

Description

[[Technical Field]]

[0001] Cross-Reference to Related Applications This application claims the benefit and priority of U.S. Application No. 18 / 066,462, filed December 15, 2022, which is a continuation of U.S. Application No. 17 / 968,680, filed October 18, 2022, which claims the benefit and priority of U.S. Provisional Patent Application No. 63 / 347,442, filed May 31, 2022, and U.S. Provisional Patent Application No. 63 / 412,838, filed October 3, 2022, the contents of all of which are incorporated herein by reference in their entireties. [[Background Art]]

[0002] Conventional approaches for generating interactive electronic documents typically involve using a declarative description of the structure of the interactive electronic document and branching logic associated with the interactive electronic document. While declarative descriptions may be well suited for simple interactive electronic documents, the suitability of declarative descriptions may be insufficient for more sophisticated interactive electronic documents that have rich interactivity requirements, deep logic, and / or complex validation constraints. Examples of such more sophisticated interactive electronic documents include clinical questionnaires, detailed consent documents, guides for standalone tasks, and similar documents.

[0003] Other existing approaches to generating interactive electronic documents can rely on a large amount of program code that constitutes the interactive electronic document. Such approaches may be called high-code approaches and offer extensive flexibility through their construction. That is, almost any adjustment to an interactive electronic document can be made by adjusting the codebase that forms that document. However, high-code approaches are time-consuming and quite fragile. In fact, changes to any part of an interactive electronic document constructed using a high-code approach, regardless of the scope of the change, may require a re-examination of the entire workflow that underpins the interactive electronic document.

[0004] Therefore, there is still much room for improvement in the technology for creating and presenting electronic questionnaires, and more generally, interactive electronic documents. [Overview of the Initiative]

[0005] Please understand that both the following summary and the embodiments for carrying out the invention are merely illustrative and descriptive, and not limiting.

[0006] In one embodiment, the disclosure provides a computing system. The computing system includes a computing device. The computing device includes at least one processor that runs a computer executable component stored in at least one memory device. The computer executable component may include a runtime component configured to apply navigation rules corresponding to navigation modes for a set of views, and at least one of the views in the set may include its respective prompt. The set of views and the logic that may be associated with them may consist of human-readable content formatted as no-code statements or low-code statements, or a combination thereof. The computer executable component may also include a coordination component configured to trigger the presentation of at least one of the views in the set in response to the runtime component applying navigation rules. The computer executable component may also include a presentation component configured to draw its respective user interface corresponding to at least one of the views.

[0007] Additional elements or advantages of this disclosure are described in part in the subsequent specification, are evident from the specification, or can be learned through the practice of this disclosure. The advantages of this disclosure may be achieved by elements and combinations specifically indicated in the appended claims.

[0008] This summary is not intended to identify any material or essential features of the Disclosure, but merely to summarize its specific features and variations. Further details and features are described in the following sections. Furthermore, both the above summary and the following embodiments for carrying out the invention are merely illustrative and descriptive and do not limit the embodiments of the Disclosure.

[0009] The accompanying drawings are an integral part of this disclosure and are incorporated herein by reference. The drawings illustrate exemplary embodiments of this disclosure and, together with this specification and the claims, help to illustrate, at least partially, the various principles, elements, or aspects of this disclosure. Embodiments of this disclosure are further described below with reference to the accompanying drawings. However, the various elements of this disclosure can be implemented in many different forms and should not be construed as being limited to the implementations described herein. Throughout, similar figures refer to similar elements. [Brief explanation of the drawing]

[0010] [Figure 1] An example of a computing system according to one or more embodiments of this disclosure is illustrated below. [Figure 2] An example of a runtime component according to one or more embodiments of this disclosure is illustrated below. [Figure 3] The elements of a runtime component according to one or more embodiments of this disclosure are illustrated below. [Figure 4A] Examples of user interfaces according to one or more embodiments of this disclosure are illustrated below. [Figure 4B] Other examples of user interfaces based on one or more embodiments of this disclosure are illustrated. [Figure 5] Elements of a software application according to one or more embodiments of this disclosure are illustrated. [Figure 6A] A class diagram illustrating a model of a configuration package according to one or more embodiments of this disclosure is illustrated. [Figure 6B] An example representation of a configuration package according to one or more embodiments of this disclosure is illustrated below. [Figure 7] An example of a process flow for supplying a configuration package according to one or more embodiments of this disclosure is illustrated. [Figure 8A] The data structures constituting view definitions included in a configuration package, according to one or more embodiments of this disclosure, are illustrated. [Figure 8B]illustrates an example of inheritance existing in the data structure shown in FIG. 8A, in accordance with one or more embodiments of the present disclosure. [Figure 9] illustrates an example of a computing system, in accordance with one or more embodiments of the present disclosure. [Figure 10A] illustrates an example of a user interface, in accordance with one or more embodiments of the present disclosure. [Figure 10B] illustrates an example of human-readable text that at least partially defines the view shown in the section of FIG. 10A. [Figure 10C] illustrates another example of a user interface, in accordance with one or more embodiments of the present disclosure. [Figure 10D] illustrates an example of human-readable text that at least partially defines the view shown in the section of FIG. 10C. [Figure 11A] illustrates yet another example of a user interface, in accordance with one or more embodiments of the present disclosure. [Figure 11B] illustrates still another example of a user interface, in accordance with one or more embodiments of the present disclosure. [Figure 12A] illustrates an example of a computing system, in accordance with one or more embodiments of the present disclosure. [Figure 12B] illustrates an example of a verification subsystem, in accordance with one or more embodiments of the present disclosure. [Figure 13] illustrates an example of a process flow for exchanging translation information, in accordance with one or more embodiments of the present disclosure. [Figure 14] illustrates another example of a process flow for exchanging translation information, in accordance with one or more embodiments of the present disclosure. [Figure 15] illustrates an example of a method, in accordance with one or more embodiments of the present disclosure. [Figure 16] illustrates an example of a method, in accordance with one or more embodiments of the present disclosure. [Figure 17] illustrates an example of a method, in accordance with one or more embodiments of the present disclosure. [Figure 18]An example of a computing system is illustrated in accordance with one or more embodiments of the present disclosure. DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

[0011] This disclosure recognizes and addresses, among other technical challenges, the problem of assembling and presenting interactive electronic documents. An example of an interactive electronic document is an electronic clinical outcome assessment (eCOA). Another example of an interactive electronic document is an electronic consent form. As will be described in more detail below, embodiments of this disclosure enable the assembly and presentation of interactive electronic documents by separating (i) a definition aspect involved in structuring a set of views and various logics associated with the set of views, such logics including, for example, navigation logic, branching logic, and validation logic; (ii) a translation aspect involved in consuming the set of views in a desired natural language; and (iii) a layout aspect involved in structuring the layout of UI elements corresponding to each view of the set of views on a particular computing device having a defined set of resolutions. By separating these aspects, embodiments of this disclosure provide greater flexibility and efficiency than existing technologies in the development and presentation of interactive electronic documents. More specifically, in contrast to existing technologies, by separating their embodiments, embodiments of the present disclosure enable scalable and efficient use of computing resources when configuring interactive electronic documents having a full range of complexity, from simple documents to highly complex documents. Additionally, by separating their embodiments, embodiments of the present disclosure also provide greater completeness with respect to the validity of the elements constituting the interactive electronic documents. Such flexibility may include a seamless implementation of the interactive electronic document for presentation on a computing device having a desired type of UI element library (native or custom) without changing the existing configuration of the translation embodiments, and / or the definition of the views and associated logic. The computing device may be a personal computing device or an institutional computing device (such as a computing device provided by a hospital, testing center, public library, or similar entity).

[0012] Referring to the drawings, Figure 1 illustrates an example of a computing system 100 according to one or more embodiments of the present disclosure. The illustrated computing system 100 includes a computing device 110 which may include a software application 114 (e.g., a mobile application, a web application, a web browser, or another type of application). In response to being executed, the software application 114 may cause a display device 120 to present a plurality of user interfaces 130 (UI 130) which may form part of a set of views. Each view in the set of views may include one or more prompts. The prompts may be questions or calls to action. The plurality of user interfaces 130 may be presented sequentially or as a sequence of views in the set of views, and each UI of the plurality of UI 130 embodies a view in the set of views. In some cases, the set of views may form or otherwise represent a questionnaire, and the sequence of the plurality of user interfaces 130 embodies a digital (or electronic) instance of the questionnaire. The questionnaire may correspond to clinical outcome assessments (COAs), triage assessments, neuropsychological assessments, college aptitude assessments, vocational assessments, professional certification assessments, licensing assessments, or similar assessments. The COA, and the corresponding eCOA instance implemented in accordance with this disclosure, may include patient-reported outcomes (PROs), performance outcomes (PerfOs), healthcare provider-reported outcomes (ClinROs), or observer-reported outcomes (ObsROs) on which the patient can complete the COA. Multiple UIs 130 may include, for example, a combination of landing pages (e.g., an index page or table of contents), questionnaire sections, results pages, results summary pages, and similar pages. In other cases, a series of views may form or represent a different type of document, and a sequence of multiple user interfaces 130 may embody a digital (or electronic) instance of the document.Simply as an example, in other such cases, a series of views could represent a consent document, a privacy practices document, a waiver of liability document, a standalone task guide (e.g., an installation guide or a troubleshooting guide), or something similar.

[0013] A navigation mode can specify the manner in which a series of views (e.g., a questionnaire, a consent form, or similar) are traversed. Therefore, a particular view presented in a sequence of multiple UIs 130 can be at least partially specified by the navigation mode. The execution of the software application 114 can cause the display device 120 to present multiple UIs 130 sequentially (e.g., UIs one after another) and according to one of several navigation modes. In other words, during the execution of the software application 114, a series of views containing multiple UIs 130 (e.g., a questionnaire or a consent form) can be traversed according to a specific navigation mode among several navigation modes.

[0014] Several navigation modes may include, for example, linear mode, hub-and-spoke mode, and computer adaptation test (CAT) mode. For illustrative purposes, linear mode causes a series of views to be traversed sequentially, one view at a time, until all views in the series have been traversed. Each view is selectable and includes a control element (such as a "next" button) that, in response to selection, advances the view to the next consecutive view. That is, each UI corresponding to each view includes a control element, and the selection of the control element causes the display device 120 to transition from the current view to the next consecutive view. In an exemplary scenario where the series of views is eCOA, such linear mode is the primary mode used for subject-recorded outcomes (also referred to as subject-reported outcomes).

[0015] As a further example, the hub-and-spoke mode allows for rapid navigation to the appropriate section of a series of views. As part of the navigation of the series of views in such a mode, a specific view corresponding to a table of contents (hub) can be displayed on a display device 120 that lists all sections within the series of views. Each section of the table of contents may be displayed using selectable UI elements. That particular view may also include an indicator showing the percentage of sections completed. The end user can select a section (e.g., click or tap), answer a question (spokes), and then return to the table of contents. In an exemplary scenario where the series of views is an eCOA, the hub-and-spoke mode is a relevant mode typically used for healthcare record outcomes. In such a scenario, the hub-and-spoke mode is used to record responses from subject interviews, in which the subject can quickly answer different questions in different sections as the subject describes their symptoms and outcomes. Therefore, the healthcare provider needs to be able to navigate efficiently across different sections.

[0016] As a further example, CAT mode allows for dynamic navigation between views in a series of views as the end user responds to prompts within a view. The transition from the first section in a series of views to the second section in the same series of views can be based on the content of the response to the prompt(s) in the first section. For example, if the series of views represents an eCOA, depending on the response to the first section assessing pain, the questionnaire flow can proceed to either a second section that probes how well the subject feels (e.g., in the case of mild pain), or a third section that probes whether the pain is manageable (e.g., in the case of severe pain). In an exemplary scenario where the series of views corresponds to an electronic assessment (eCOA, electronic license assessment, etc.), CAT mode can update the score while the electronic assessment is in progress (e.g., while the series of views is being traversed), and the intermediate updates to the score can be used to select further questions to be shown in order to obtain more accurate results.

[0017] Rather than being statically implemented, as is typical in existing technologies, the navigation mode can be dynamically defined at runtime in the software application 114. The navigation mode can be defined as a group of rules (referred to as a rule set). Regardless of its type, the navigation mode can be defined as a rule set having one or more rules. The software application 114 includes a runtime component 140 that can retrieve a group of rules in response to the start of execution of the software application 114. The group of rules can be retrieved from the primary memory device of the computing device 110 (not shown in Figure 1). Retrieving a group of rules can include loading, or otherwise receiving, data defining the group of rules from the primary memory device. As a result, the runtime component 140, and therefore the software application 114, can be configured according to the navigation mode. More specifically, as shown in Figure 2, the runtime component 140 may include an ingestion component 210 that can retrieve a group of rules 204a that define the navigation mode. The group of rules 204a can be retrieved in a native format for the rule library 240 included in the runtime component 140. The input component 210 can pass or otherwise send a group of rules 204a (or data defining such rules) to the rule library 240.

[0018] The runtime component 140 can also acquire definition data that defines a set of views (e.g., questionnaires). The definition data may be included in a configuration file within a configuration package 116 acquired by the computing device 110. The definition data is graphically represented in Figure 1 as a block having the character "+D". A set of views may be defined in terms of human-readable content formatted according to a Core Definition Language (CDL). For illustrative purposes, CDL refers to a set of files in a specific format that define instructions for forming views and prompts, and for defining logical statements and formulas related to interactive electronic documents. In addition, since each type of file is defined by a set of grammars and rules, CDL may be referred to as the language of interactive electronic documents. As described herein, CDL may be represented using JSON for describing interactive electronic documents and a JSON schema for the grammar of statements describing interactive electronic documents. This disclosure is, of course, not limited to, other forms of CDL other than JSON and associated JSON schemas. In some embodiments, and regardless of its form, a CDL can define a code and, relying on that code, identify various types of objects, each having one or more attributes. The code uniquely identifies prompts, text, or other objects that constitute an interactive electronic document. Thus, the code can provide references to the interior of an interactive electronic document.

[0019] The definition data may include human-readable content that defines the data structure for each view in a set of views. The human-readable content may be, or may include, a NO-CODE statement or a LOW-CODE statement, for example. The definition data may also include second human-readable content that defines branching logic for the set of views. The branching logic may include one or more statements. An example of a branching logic statement is "if question5.response>5 then GOTO section 3," which represents the following logic: if the response to question 5 has a value greater than 5, proceed to section 3 in the interactive electronic document. In some cases, the second human-readable content may also define one or more validation conditions and one or more actions. Each action (or, in some cases, at least one action) responds to at least one outcome of the validation condition(s). An example of an action is the presentation of a specific error message based on the outcome of the validation condition. As shown in Figure 2, the ingestion component 210 can retrieve definition data 204b that defines the set of views. Definition data 204b may include definition structures 214 and logical structures 218. Each definition structure in definition structure 214 defines each view of a set of views (e.g., questions in a questionnaire). Each logical structure in logical structure 218 may define each logical statement contained within view definition 204b. A logical statement refers to either logic or an expression and may be formatted as a NO-CODE or LOW-CODE representation of the logic or expression, or may be expressed otherwise. A logical statement may be expressed in LOW-CODE or NO-CODE format as either an IF-predicate-THEN-action statement or an IF-predicate-THEN-action A-ELSE-action B statement.When a no-code approach is adopted, during the configuration of the +D components of the configuration package 116, the predicates representing the IF portion of a logical statement can be defined by selecting from a pre-configured menu of conditions (e.g., subject is male, subject is non-binary, subject is Hispanic, etc.) or expressions. For example, the condition "subject is male" may be configured by selecting "gender" from a first menu (e.g., a graphical dropdown menu), then selecting "equals" from the first or second menu, and then selecting "male" from the first or yet another menu. Similarly, the action(s) associated with the logical statement can also be selected from a pre-configured menu of actions. Examples of actions in the pre-configured menu of actions may be "grayout(question_n)" and "highlight(question_m)". Furthermore, since the +D components can be updated and then supplied to the computing device 110 as the updated configuration package 116, the logical statements defined by the logical structure 218 can be modified as desired without causing changes to the definition of a set of views. In other words, embodiments of this disclosure allow for flexible adjustment of various logics associated with a set of views, independently of the definition of the set of views themselves.

[0020] The logical structure of logical structure 218 can define logical statements that target, for example, branch logic, verification logic, invalidation logic, scoring logic, export logic, or combinations thereof. Branch logic refers to logic that directs a transition from the current prompt to the next prompt based on a specific condition. Verification logic indicates the presence of an invalid response to a prompt based on a specific condition. Invalidation logic directs the exclusion of one or more next prompts based on a specific response to the current prompt. Scoring logic indicates a manner in which one or more responses to a group of prompts associated with a set of views are evaluated. Export logic can indicate a manner in which responses to prompts and / or other data associated with the traversal of a set of views are exported.

[0021] Since the CDL does not need to conform to the native format of the rule library 240, the branching logical structure 218 may not be formatted according to its native format. Therefore, the runtime component 140 may include a logic translator component 220 (also referred to as the logic translator 220) that can convert the branching logical structure 218 into a group of rules formatted according to the native format of the rule library 240. The runtime component 140 may, for example, combine (i) a group of rules resulting from the conversion of the branching logical structure 218 and (ii) a group of rules 204a corresponding to a desired navigation mode for traversing a set of views (e.g., questionnaires or consent documents) via the logic translator component 220. The runtime component 140 can then hold the group of rules resulting from such a combination in the rule library 240 as a rule set in the rule set 244. The combined group of rules can instruct how the end user is directed to interact with the set of views. When a series of views corresponds to a survey, the combined group of rules can dictate how an end user (e.g., a patient, clinician, or other subject) is instructed to answer the survey.

[0022] At runtime, a definition structure 214 and a particular set of rules, configured using navigation mode rules 204a and logical structure 218 (obtained from view definition 204b), can specify a set of views in terms of the logic and assembly of a set of views. To apply that logic, runtime component 140 may include rule component 230 (such as a rule engine) that can access the rule library 240 and implement (e.g., interpret or otherwise execute) each rule in a particular set of rules. In some cases, in response to implementing one or more rules in a particular set of rules, rule component 230 may allow one or more navigation mode rules derived from the group of rules 204a to be overridden by logical structure 218. In such cases, the translated rules from logical structure 218 may take precedence over the translated rules from navigation mode rules 204a. An example is in question Q. u This is a branching logic from (in the case of a survey), and question Q u Since the answer received was "yes", the next question to be answered is question Q v This shows that (v is different from u+1). Such a transition is Q u The subsequent question is question Q. u+1This overrides the linear mode which defines that a section is grayed out. An implementation of such an override rule present in the rule set can, in some cases, trigger the implementation of a defined action, such as graying out a section. Thus, override rules can go beyond branching logic. In other words, override rules include if-then statements that, for example, perform a defined action in response to a conditional statement being met. For example, IF question5.response>7 THEN greyout-section(6), or IF question.6.response>2 THEN next-question(8). Figure 3 illustrates an example of elements of a runtime component 150 related to the operation of a rule component 230 according to one or more embodiments of the present disclosure. The rule component 230 may be functionally coupled to a data storage 310 containing fact data that defines a plurality of facts representing the current state of a traversal of a set of views. The plurality of facts include the first fact 1 314(1), the second fact 2 314(2), and so on, up to the Qth fact 314(Q). For example, one of several facts could be the value of the current question in the questionnaire (e.g., response-15), and another of several facts could be the answer to question number 14 (i.e., that other fact could be response-14). Rule component 230 is also functionally coupled to rule library 240. Rule library 240 contains rule data that defines a particular set of rules. Rules within a particular set of rules contain if-then statements. As an example, a particular set of rules contains M rules, each with its own priority: the first rule 1 320(1) with priority P, the second rule 2 320(2) with priority P-1, and so on, up to the Nth rule N 320(N) with priority P0, and so on, up to the Mth rule M 320(M) with priority P0-q. The M rules can be sorted in descending order of priority, i.e., P>P-1>P0>P0-q.

[0023] Rule component 230 can apply rules within a specific rule set. Rule component 230 can apply rules within a specific rule set in order of priority. Therefore, some rules may be applied (or evaluated) before others. In response to rule component 230 applying rules within a rule set, rule component 230 can evaluate facts (e.g., fact 1 314(1) to Q 314(Q)) that define the current state of the traversal of a set of views. Facts may be evaluated according to the "if" condition of the if-then statement of the applied rule. Based on the result of evaluating such "if" condition, the "then" action in the if-then statement of the applied rule may establish one or more new facts (e.g., establish fact 314(Q+1)), remove one or more existing facts, update one or more existing facts, perform another action, navigate to a specific view among the set of views, or perform a combination of the above.

[0024] For illustrative purposes only, we consider the traversal of a questionnaire in linear mode. As described herein, the navigation mode rule 204a corresponds to linear mode and may be maintained in the rule library 240 as a set of rules including: (i) Rule 1: If the fact that "the Next button was clicked" is true and there are no validation errors, update the current question fact to the next question / view. (ii) Rule 2: If the fact that "the Previous button was clicked" is true, update the current question fact to the previous question / view. (iii) Rule 3: If the fact that "the Submit button was clicked" is true and there are no validation errors, create a "Completed" fact. As further described herein, the logical structure within the view definition of a questionnaire may be translated into one or more native rules for the rule component 230. For example, if the branching logic for question 7 states "If the answer to this question is true, gray out the rest of the section," the logic translator 220 can translate such branching logic into a native rule that states "If fact response 7 is true, disable the rest of the questions in the section in the CDL definition structure." Similarly, CDL validation conditions / rules within the survey view definition can be translated into one or more native rules for the rule component 230. For example, if the CDL validation rule states "The value of question 8 must be within the range of 1 to 10," the logic translator 220 can then translate such validation condition / rule into "If fact response 8 is outside the range of 1 to 10, add an additional fact validation - failure - 8."

[0025] Therefore, the runtime component 140 is separated from the implementation of the aspects associated with causing the presentation of the UI corresponding to a view among a set of views on the display device 120. In short, as shown in Figure 1, the software application 114 may include a coordination component 150 functionally coupled to the runtime component 140, the coordination component 150 causing the presentation of the UI (or other UIs at other times) on the display device. More specifically, the runtime component 140 includes a runtime interface 144 that functionally couples the runtime component 140 to the coordination component 150. The runtime interface 144 exposes or otherwise provides a number of functions (or behaviors) that, in combination with a particular set of rules, can query and / or determine the logical state of a set of views, and thus control the presentation of the set of views. The number of functions constitutes the core control logic of the runtime component 140. For illustrative purposes only, the number of functions may include a first function configured to retrieve the current view to be represented on the display device 120. A call to the first function returns the page element(s) and prompt(s) corresponding to the current view. The page element(s) and prompt(s) may be returned as a CDL data structure formatted according to JavaScript Objection Display (JSON). The first function may be referred to as Operation Q for naming purposes only.

[0026] Continuing with the examples, multiple functions may also include a second function configured to pass a response to a prompt (e.g., a question). A call to the second function passes the response as a specific CDL data structure formatted according to JSON. The second function may, for naming purposes only, be called Operation R. Multiple functions may also include a third function configured to pass an indicator of interaction with a control element. For example, an indicator that a navigation icon is selected (e.g., clicked or tapped). The third function may, for naming purposes only, be called Operation N. Multiple functions may also include a fourth function configured to extract one or more validation errors from the current response to a prompt. For example, an indicator that a navigation icon is selected (e.g., clicked or tapped). The fourth function may, for naming purposes only, be called Operation V. Multiple functions may also include a fifth function configured to determine whether a particular sequence of a view (e.g., an instance of a survey) is complete. A call to the fifth function may return an indicator of a positive or negative determination, and may also return one or more responses to a prompt. One or more responses may be returned as a specific CDL data structure formatted according to JSON. The fifth function may be referred to as Operation C, simply for naming purposes.

[0027] The coordination component 150 may include an execution component 154 that can execute function calls for one or more of a plurality of function calls exposed by the runtime interface 144. In response to the execution of a function call, the coordination component 150 may instruct the presentation component 150 to draw a UI (e.g., one of the UI 130) on the display device 120. The presentation component 150 is part of the application 114 and includes a library interface 164 that provides a functional coupling between the presentation component 150 and the coordination component 140. The presentation component 150 may include a UI element library 166 having a plurality of UI elements 168. Each UI element 168 includes at least one presentation element and at least one navigation control element (also referred to hereby as a control element). Presentation elements associated with UI elements 168 may include various types of digital content, such as still images (e.g., icons, avatars, subject photos, etc.), animations, video segments, audio segments, ringtones, and electronic documents (e.g., documents and / or presentations in Portable Digital Format (PDF)). In some cases, simply as an example, the UI element library 166 could be the React UI library. In other cases, the UI element library 166 could be a custom library or a native library (for example, a UI library for the operating system (O / S) of a computing device 110, such as iOS or Android).

[0028] To trigger the presentation of a view from a set of views, the coordination component 150 can, for example, execute a function call (operation Q) to a first function to retrieve the view via the execution component 154. As mentioned, a view is defined in terms of a data structure formatted according to the CDL. The execution component 154 can then implement translation logic 156 for mapping a first data structure from the set of views to a prompt (e.g., a question in a questionnaire or a consent statement in a disclaimer). The translation logic 156 may be defined in a configuration file within the configuration package 116. The translation logic 156 is graphically represented in Figure 1 as a block with the character "+T". The prompt may be defined in a desired natural language (e.g., English, Italian, or Spanish) for a set of views. Thus, the mappings that constitute the translation logic 156 can be defined to translate the data structure in the CDL into a desired natural language. More specifically, to implement the translation logic 156, the execution component 154 can determine that a translation rule is satisfied for a particular view from a set of views. In response, the execution component 154 can translate a first natural language statement associated with a prompt and presented in a first natural language into a second natural language statement in a second natural language. The translation may be performed by identifying the first natural language statement and then applying a mapping to associate the first natural language statement with the second natural language statement.

[0029] Additionally, the execution component 154 may also implement layout logic 158 for determining one or more UI elements to be presented in the UI corresponding to the view on the display device 120. The layout logic 158 may be defined in a configuration file within the configuration package 116. In Figure 1, the layout logic 158 is graphically represented by a block with the letter "-L". In response to implementing the layout logic, the execution component 154 may instruct the presentation component 160 via the library interface 164 to retrieve one or more UI elements and draw them in a defined layout of areas in the UI corresponding to the view.

[0030] As a simple example, Figure 1 presents a UI 132 corresponding to a view in a series of views. UI 132 may include a presentation element 134 that represents a prompt related to the view. The presentation element 134 may include, for example, text or other markings representing the prompt. The text may be formatted according to a specific font type and font size configured, for example, by layout logic 158. In fact, the layout logic 158 may not only enable font formatting, but may also enable the alignment of text on the UI 132 screen, including a right-to-left display option. The prompt may be a natural language statement (such as a question) in a specific natural language. UI 132 may also include a control element 136. The control element 136 may be selectable and may allow receiving input data in response to a prompt. UI 132 may further include a navigation element 138 (represented by an arrow mark).

[0031] As mentioned, the presented and view-corresponding UI may include prompts and control elements that allow the end user to interact with the UI. Thus, the presenting component 160 can receive input data 118 in response to interaction with the UI. Note that the input data 118 flows unidirectionally toward the application 114, and the reception of the input data 118 in the presenting component 160 is represented as an arrow toward the presenting component 160 from a block labeled "118". In some cases, the input data 118 may include response data in response to a prompt; for example, the input data 118 may indicate an answer to a question that is part of the eCOA. Such response data may be referred to as prompt response data. The presenting component 160 can pass the input data 118, including the prompt response data, to the coordination component 150 via the library interface 164. The execution component 154 can receive the input data 118, including the prompt response data, and then execute a function call (operation R) to send (or pass) the input data 118 to the runtime component 140. As described herein, the input data 118, including prompt response data, may be sent in JSON format.

[0032] In other cases, instead of including prompt response data within the input data 118, the input data 118 may include navigation response data in response to the selection of a control element in the UI corresponding to the view (e.g., a navigation control). As described herein, the input data 118 containing the navigation response data may be sent in JSON format. The presentation component 160 can receive the input data 118 containing the navigation response data. The presentation component 160 can then send (or pass) the navigation response data to the coordination component 150 via the library interface 164. The execution component 154 can receive the signaling and then execute a function call (operation N) to send the signaling to the runtime component 140.

[0033] The runtime component 140 has access to branch logic and / or validation conditions(s) and can operate on the input data 118. Such operation may result in errors. Therefore, the execution component 154 can perform another function call (operation V) to retrieve any validation errors that may exist in response to the runtime component 140 operating on the input data 118. If validation errors exist, the execution component can receive a CDL data structure that identifies the error view. The execution component 154 can then instruct the presentation component 160 to draw one or more UI elements indicating the errors. In some cases, as illustrated in Figure 4A, the presentation component 160 can redraw UI 132 to include a single UI element 410 corresponding to the error view. The UI element 410 may be presented as an overlay and may include text (represented by a line segment) indicating the validation error. In some cases, instead of presenting an overlay, the UI element 410 can be integrated into UI 132. Furthermore, or in other cases, besides including the UI element 410, the presentation component 160 can change the appearance of the redrawn section of UI 132. For example, UI 132 can be redrawn to include a gray layer that is semi-transparent and covers at least a portion of UI 132, and the UI element 410 as an overlay. Figure 4B presents an example of another sequence of user interfaces in which an error view is involved in the presentation of one of the user interfaces. More specifically, UI 450 can present a prompt 454 and a plurality of selectable UI elements 456 representing a group of possible answers. UI 450 also includes a first navigation control 458a and a second navigation control 458b. In response to the selection of navigation control 458b, the execution component 154 can instruct the presentation component 160 to redraw UI 450 with a gray pane that may be semi-transparent overlaying UI 450, and also to draw the UI element 460 as an overlay.UI element 460 represents the error view.

[0034] Embodiments of this disclosure are not limited to defining a navigation mode as a set of rules and relying on rule components (such as rule component 240 (Figure 2)). Instead of obtaining navigation mode rule 204a, as illustrated in Figure 5, runtime component 140 may select program code that defines a navigation mode. For this purpose, runtime component 140 may be functionally coupled to navigation mode component 510. Navigation mode component 510 can execute navigation mode logic 504 corresponding to a navigation mode, which becomes program code that defines the navigation mode. In fact, navigation mode component 510 can execute various types of navigation mode logic 504 corresponding to each navigation mode. Thus, runtime component 140 can select program code by selecting an implementation of navigation mode logic 504 that can be executed by navigation mode component 510. An implementation of navigation mode logic 504 may be embodied in an instance of navigation mode component 510.

[0035] The runtime component 140 may include an interpreter component 520 that can, at runtime, retrieve (e.g., load) specific program code that defines a particular navigation mode used to traverse a questionnaire. This specific program code may be retrieved (e.g., loaded) via the navigation mode component 510. Additionally, at runtime, the interpreter component 520 may retrieve multiple logical structures 218. As described herein, at runtime, the ingestion component 210 can retrieve a logical structure 218 from a view definition 204b and supply the logical structure 218 to the interpreter component 520. The interpreter component 520 can then directly execute both specific program code that defines a navigation mode for a set of views and, for example, a logical structure 218 that defines branching logic for a set of views. As mentioned, the logical structure 218 is not limited to containing logical statements that define branching logic. In fact, in some cases, the logical structure 218 may contain logical statements that define one or more of the following: verification logic, invalidation logic, scoring logic, or export logic.

[0036] For a defined set of views (e.g., a questionnaire), computing device 110 can obtain the view definition (e.g., view definition 204b), translation logic (e.g., translation logic 156), and layout logic (e.g., layout logic 158) via configuration package 116. Computing device 110 can receive configuration package 116 from another computing device located remotely to computing device 110. The configuration package may be received in response to the execution of application 114 or in response to the time when application 114 was installed. For this purpose, in some cases, the execution of application 114 may trigger the presentation of a selection prompt to select a specific natural language from a group of natural languages ​​available in the configuration package that is uploaded or otherwise received. The other computing device located remotely to computing device 110 may generate a configuration package in response to such a selection.

[0037] A configuration package may contain three sets of configuration files, each set having at least one configuration file that defines a set of view aspects. Each configuration file may be defined in terms of CDL. The first aspect concerns the definition of a set of views. The set of configuration files associated with the definition aspect (also referred to as the "+D" aspect) includes a single configuration file that can describe each view, branch logic (and in some cases, scoring logic), and validation conditions. This single configuration file may be generated, for example, by individually configuring each view (or part) in each working file and then integrating multiple views (or parts) into a single configuration file. This single configuration file may be referred to as a CDL+D configuration file and may be denoted as CDL+D. The CDL+D configuration file may also define a response format for responding to prompts (e.g., questions) within a view. The second aspect concerns translating the views described in the CDL+D configuration file into a target natural language. The set of configuration files associated with the translation aspect (also referred to as the "+T" aspect) may include multiple files, each corresponding to a desired natural language. The +T configuration file defines the translation mapping. The +T configuration file may be referred to as the CDL+T configuration file and may be written as CDL+T. The third aspect concerns the UI layout corresponding to each view described in the +D configuration file. The set of configuration files relating to the layout aspect (also referred to as the "+L" aspect) may each contain multiple files corresponding to a UI layout for a particular type of display device and a particular UI library associated with a computing device such as computing device 110. The particular UI library may be one of several UI libraries available for the computing device (e.g., a smartphone or tablet computer). The +L configuration file defines the layout logic. The +L configuration file may be referred to as the CDL+L configuration file and may be written as CDL+L.

[0038] Figure 6A shows a class diagram 600 representing a model of configuration package 610. Configuration package 610 includes one or more CDL+L configuration files, one or more CDL+T configuration files, and a single CDL+D configuration file. The CDL+L configuration files are dependent on the CDL+T configuration files, and the CDL+T configuration files are dependent on the CDL+D configuration files. The specific dependency structure of the CDL+D, CDL+T, and CDL+L configuration files allows for the isolation of the implementation of the verification process in response to changes to one or more of those configuration files. In some embodiments, such changes may be implemented while the configuration file is in a working state, as opposed to an immutable state. A working state refers to a condition of a configuration file that is mutable and allows for revisions to that file. An immutable state refers to a condition of a configuration file that is immutable and has a persistent version assigned to that file. The persistent version may be identified using a persistently unique identifier formatted according to a desired versioning schema. In the working state, changes to a CDL+L configuration file can trigger a validation process only for that file. Changes to a CDL+T configuration file trigger a validation process for each CDL+L configuration file dependent on the changed CDL+T file. Changes to a CDL+D configuration file trigger a validation process for the CDL+T configuration file (or more) dependent on the CDL+D configuration file, and also for the CDL+L configuration file (or more) dependent on the CDL+T configuration file. A component structure is a modular data structure that defines various elements of a set of views in terms of sections, views, and prompts. Multiple components can be configured individually, for example, in their respective working files, and then, as mentioned, integrated into a single CDL+D configuration file.

[0039] Figure 6B illustrates Figure 670, which represents a model of an instance of a configuration package 660 containing a data repository 650 containing multiple configuration packages 654, and multiple configuration files 664 of types +D, +T, and +L. Note that, as shown in Figure 670, a single CDL+D configuration file 672 exists in an instance of configuration package 660, and for that single CDL+D configuration file 672, there are multiple CDL+T configuration files associated with the CDL+D configuration file 672, and there are also multiple CDL+L configuration files associated with the multiple CDL+T configuration files in various ways. In fact, in some embodiments, each configuration package of configuration package 654 may have a single CDL+D configuration file, one or more CDL+T configuration files, and one or more CDL+L configuration files, and such configuration files may be related in the manner shown in class diagram 600 in Figure 6A.

[0040] Figure 7 illustrates an example of a process for supplying a configuration package according to one or more embodiments of the present disclosure. Supplying a configuration package may include generating a configuration package and transmitting the configuration package to a computing device. In the illustrated process flow, a configuration component 714 can receive input data 720. The configuration component 714 may be part of a package supply subsystem 710. In some cases, the configuration component 714 may be hosted by a computing device (not shown in Figure 7) included in the package supply subsystem 710. The input data 720 may include first data that defines the contents of a CDL+D configuration file 724. In response to the receipt of the first data, the configuration component 714 may generate a CDL+D configuration file 724 in a data repository 650. The CDL+D configuration file 724 may be generated in a file system residing in the data repository 650. As part of generating the CDL+D configuration file 724, the configuration component 714 may generate a unique identifier, a UI, which can be incorporated into a CDL+D configuration file 726. A unique identifier can be used to reference the CDL+D configuration file 724 from another configuration file. An example of a unique identifier is a Universally Unique Identifier (UUID).

[0041] In addition, or in some cases, the input data 720 may also include second data that defines the content of the CDL+T configuration file 726. In response to receiving the second data, the configuration component 714 may generate the CDL+T configuration file 726 in the data repository 650. The CDL+T configuration file 726 may be generated in a file system residing in the data repository 650. As part of generating the CDL+T configuration file 726, the configuration component 714 may generate a unique identifier and incorporate this unique identifier into the CDL+T configuration file 726. This unique identifier (e.g., UUID) can be used to reference the CDL+T configuration file 724 from another configuration file. In some cases, each text value contained in the CDL+T configuration file may support Markdown (e.g., headings, paragraphs, line breaks, emphasis) so that the font and / or highlighting can be customized.

[0042] Furthermore, or in yet another case, the input data 720 may also include third data defining the contents of the CDL+L configuration file 728. In response to receiving the third data, the configuration component 714 may generate the CDL+L configuration file 728 in the data repository 650. The CDL+L configuration file 728 may be generated in a file system residing in the data repository 650. As part of generating the CDL+L configuration file 728, the configuration component 714 may generate a unique identifier and incorporate this unique identifier into the CDL+L configuration file 728. This unique identifier (e.g., a UUID) can be used to reference the CDL+L configuration file 724 from another configuration file. As illustrated in Figure 6A, the definition of the CDL+L configuration file may specify versions of runtime bundles corresponding to runtime component 140, coordination component 150, and presentation component 160, which are suitable for use with configuration packages containing the CDL+L configuration file. The versions may be identified, for example, via a UUID. Additionally, a CDL+L configuration file may contain a reference or another type of link to that version of the runtime bundle. Thus, configuration component 714 can apply one or more integrity tests to the CDL+L configuration file 728 for one or more versions of the UI element library 166. Version-controlled runtime bundles may be kept in archives within the data repository 650. In this way, configuration component 714 can determine that the CDL+L configuration file (and configuration packages incorporating such files) is available for the version of runtime component 140 under which the CDL+L configuration file is being tested. Thus, verified behavior for the configuration package can be maintained for the desired runtime bundle.

[0043] As illustrated in Figure 7, the package supply subsystem 710 also includes a packaging component 816. In some cases, a computing device (not shown in Figure 7) that hosts the configuration component 714 can also host the packaging component 816. The packaging component 716 can retrieve the CDL+L configuration file 728, the CDL+T configuration file 726, and the CDL+D configuration file 724, and generate a configuration package 730 in the data repository 650. The packaging component 816 can hold the configuration package 730 in a file system located in the data repository 650. That file system can also contain various configuration files (CDL+D, CDL+T, and CDL+T files). Package 730 could be, for example, one of the packages 654 held in the data repository 650.

[0044] To obtain a configuration package, the computing device 110 can send a request 740 to the package supply subsystem 710 for an interactive electronic document, natural language, and a specific combination of device type and display resolution. Such a specific combination would be a specific CDL+L configuration file. The interactive electronic document could include, for example, a questionnaire, consent form, evaluation, or standalone task guide (e.g., an installation guide or troubleshooting guide). In some cases, the computing device 110 can send a request 740 in response to initiating the execution of an application 114 (not shown in Figure 7). The request 740 may be sent by a communication system 750. The communication system 140 could include one or a combination of networks (wireless or wired) that enable bidirectional communication of data and / or signaling.

[0045] The delivery component 718, included in the package supply subsystem 710, can receive request 740. In some cases, the computing device (not shown in Figure 7) hosting the configuration component 714 and the packaging component 716 can also host the delivery component 718. In other cases, a second computing device (not shown in Figure 7) can host the delivery component 718. In response to receiving request 740, the delivery component 718 can select a configuration package 760 that satisfies the requested specific combination of interactive electronic documents, natural language, and device type and display resolution. The configuration package 760 may be selected from a group of packages 654 in the data repository 650. The configuration package 760 may contain several configuration files, a specific set of configuration files, namely CDL+D, CDL+T, and CDL+L configuration files, that correspond to the requested specific combination of electronic interactive documents, natural language, and device type and display resolution. Therefore, the delivery component 718 can generate a deliverable configuration package 770 by extracting a specific set of configuration files and then assembling the deliverable configuration package 770. For this purpose, the delivery component 718 can analyze the language that defines the device type and display resolution for several CDL+L files. Such analysis can generate a CDL+L file suitable for the device type and display resolution. In addition, the delivery component 718 can determine references to CDL+T files within a suitable CDL+L file. A CDL+T file may be suitable for natural language. Similarly, the delivery component 718 can determine references to CDL+D files within a CDL+T file, where a CDL+D file defines an electronic interactive document.The configuration package 770 can be referred to as a "minimal package" in that it includes configuration files related to applicable interactive electronic documents, desired natural language, and a specific type of computing device having specific UI characteristics / attributes. The delivery component 718 can transmit the configuration package 770 to the computing device 110 via the communication system 770.

[0046] For illustrative purposes only, configuration package 760 may be configuration package 660 as depicted in Figure 6B, which includes configuration files shown in tree structure 670. Delivery component 718 can determine that CDL+D configuration file 672, CDL+T configuration file 674, and CDL+L configuration file 676 form a set of files corresponding to a requested specific combination of interactive electronic documents, natural language, and device type and display resolution. Therefore, deliverable configuration package 770 includes CDL+D configuration file 672, CDL+T configuration file 674, and CDL+L configuration file 676.

[0047] By implementing the exemplary process flow shown in Figure 7, embodiments of the present disclosure can deterministically deliver a portion of a configuration package, i.e., a deliverable configuration package 770, to a device and for a desired natural language. The portion of the configuration package to be delivered is device and natural language appropriate in that an interactive electronic package can be appropriately presented on the device (e.g., without visual artifacts) in a desired natural language. Such determinism and appropriateness make such exemplary process flows superior to existing techniques for delivering interactive electronic documents.

[0048] An example of a component applicable to an interactive electronic document is shown in class diagram 800, which is shown in Figure 8A. Here, the component enables a modular approach to creating an interactive electronic document from built-in sections, pages, and / or elements. The interactive electronic document is itself a component. The inheritance associated with ActionBase, PromptBase, and ElementBase in class diagram 800 is shown in inheritance diagram 850, which is shown in Figure 8B. In one example, the interactive electronic document is a questionnaire. As described herein, in some cases, the components (Parts) that make up the interactive electronic document may be generated individually and held in their respective working files, as described herein. The component is a modular component of the interactive electronic document corresponding to a section, page, or isolated element. The various components that make up the interactive electronic document can then be integrated into a single CDL+D configuration file, as also described herein.

[0049] As illustrated in Figure 8A, element bases can be inherited from parts. Next, both prompt bases and page element bases (PageElementBase) can be inherited from element bases. Here, a prompt base class defines a specific type of prompt from a group of types. Such prompts can be presented in the UI as selectable presentation elements. Additionally, a page element base class defines visual elements that can be presented in the UI as presentation elements that are either selectable or non-selectable. For illustrative purposes only, Table 1 shows examples of question types that may be used in the definition of a questionnaire according to the embodiments described herein. [Table 1] TIFF0007927880000002.tif156153

[0050] As a further example, Table 2 illustrates an example of a data model for answered questions or other types of prompts. Such a data model defines, for example, the format of the data that is expected to be obtained in response to a questionnaire. Each question or prompt may hold data in a specific known, predefined format (for example, a question with datetime entries would always store datetime values, and a question with free-text entries would always store string values). [Table 2]

[0051] In addition to the CDL+D, CDL+T, and CDL+L configuration files, embodiments of the present disclosure may also enable the generation and / or validation of a configuration file that defines scoring logic for interactive electronic documents. Such a file may be referred to as a CDL+S configuration file. The CDL+S configuration file defines a new score that can be determined by application 114, for example, automatically for interactive electronic documents, via runtime component 140, based on a data model. One or more scores that may be associated with a survey data model may be determined based on responses (i.e., prompt response data) received by application 114 during survey traversal in response to prompts (or multiple prompts) in the interactive electronic document. This ability to calculate scores should be applied to the latest version of the dataset; that is, application 114 should obtain a score based on data that has been determined when the score is used and / or probed.

[0052] In addition, or in some embodiments, a configuration file defining the data export may also be generated and validated. Such a file may be referred to as a CDL+E configuration file. The CDL+E configuration file may allow configuration of how the data export file may be formatted and how the data may be arranged within the data export file. Information from this configuration artifact may be applied when performing the data export. The CDL+E configuration file may be embodied, for example, as a template for data mapping, data calculation, and / or data transformation between the survey data model and the export file. The CDL+E configuration file may allow exporting responses collected during the traversal of the survey and arranging such responses in a specific structure. Thus, the CDL+E configuration file may allow configuration of the position of each data model item in the export file, along with any fixed values ​​associated with the item, configuration of file separators, and / or configuration of file names.

[0053] As illustrated in Figure 9, embodiments of the present disclosure may include a computing system 900 that enables the generation of interactive electronic documents (e.g., questionnaires or consent forms) in the manner described herein. The computing system 900 may host various subsystems and components. The computing system 900 may be a distributed system. More specifically, the computing system 900 may include an assembled subsystem 910 containing various components.

[0054] The assembly subsystem 910 includes one or more CDL editor components 912. The CDL editor components 912, individually or in specific combinations, may enable the end user to directly and interactively edit a CDL configuration file. Thus, the CDL editor components 912 may enable any interactive customization of the CDL configuration. To this end, the editor components 912, individually or in specific combinations, may cause the display device 922 to present a user interface 924 (UI924) containing selectable visual elements, each configured to receive input data defining a CDL configuration file. For illustrative purposes only, the exemplary UI 1010 shown in Figure 10A is one example of a UI924. UI1010 includes a selectable view pane 1020 that can receive input data defining a CDL+D configuration file. More specifically, the input data may define at least text 1024, the text 1024 may define a portion of a CDL+D configuration file. As can be seen from Figure 10A, text 1024 is human-readable text. Text 1024 is also shown in Figure 10B. The exemplary UI 1010 also includes a second view pane 1030 that can present a view associated with input data entered into view pane 1020. The view may, in some cases, be presented in a time-coordinated manner along with the input data entries that define the CDL+D configuration file. That is, view pane 1020 can present the view in near real-time as input data is entered into view pane 1020. Thus, the view may be referred to as a real-time preview. To present a real-time preview in view pane 1020, at least one of the CDL editor components 912 may pass or otherwise provide the current definition of the configuration file to a first previewer component of the previewer components 914.The first previewer component can cause the display device 922 to present the current view in the second view pane 1030 based on its current definition in the configuration file.

[0055] Figure 10C illustrates an exemplary UI 1050 having a first view pane 1060 and a second view pane 1070. Similar to the second view pane 1020 (Figure 10A), view pane 1060 is selectable and can receive input data that defines a CDL+L configuration file. More specifically, the input data can define at least text 1064, which can define a portion of a CDL+L configuration file. As can be seen from Figure 10C, text 1064 is human-readable text. For illustrative purposes only, text 1064 is also shown in Figure 10D. Similar to view pane 1030 (Figure 10A), view pane 1070 can present a view associated with the input data entered into view pane 1060. Its view can also, in some cases, be presented in a manner that is temporally coordinated with the entry of the input data. That is, view pane 1070 can present a view in near real-time as the input data is entered into view pane 1020. The first previewer component can cause the display device 922 to present the current view in the second view pane 1070 based on the current definition in the CDL+L configuration file.

[0056] In some cases, the second previewer component is included in the previewer component(s) 914. After the CDL configuration file is generated, the second previewer component may enable the retrieval (e.g., loading) of the CDL configuration file, for example, using the CDL editor component(s) 912. The second previewer component can then cause the display device 922 to display the results of the CDL configuration file and / or any errors in processing the CDL configuration file or configuration package containing the CDL configuration file. The second previewer component may enable navigation between various survey chapters and the display of layouts for each chapter applied by the runtime bundle, placeholder text for all elements on the screen, the number and type of responses collected from end users, etc.

[0057] In addition, or in another embodiment, the second previewer component may enable the execution (or run) of an interactive electronic document (e.g., a questionnaire) to verify that the collected data can conform to a defined data model (e.g., a test data model). For this purpose, the second previewer component can receive one or more responses from the end user, for example, to each of the viewed chapters. The second previewer component can then cause the display device 922 to show how the data can be mapped (e.g., how the response object can find its question).

[0058] The assembly subsystem 910 may also include one or more screen capture generation components 916. The screen capture components 916, individually or in combination, can provide various functionalities related to generating and, in some cases, presenting screen capture images (also referred to as screenshots) for a given CDL configuration package. The screen capture images may include everything an end-user can observe during traversal of a questionnaire or another type of interactive electronic document, including all possible views, all possible validation messages and validation screens, translated into natural language usable by the consumer / end-user. The screen capture components 916, individually or in combination, can generate image captures for any combination of device, natural language, and interactive electronic documents. In some cases, the screen capture images may be used for reviewing translation work products (created by human experts or autonomous machines). In other cases, the screen capture images may be used for submission for approval of a clinical trial accompanied by a specific questionnaire.

[0059] The assembly subsystem 910 may also include one or more translation exchange components 920. The translation exchange component(s) 920 may enable the exchange of data related to a CDL+T configuration file with one or more translator devices 940. The translator devices 940 may be located remotely from the assembly subsystem 910 (or, in some cases, from a computing device(s) capable of hosting the assembly subsystem 910). Such data can be exchanged in many ways. In some cases, the translation exchange component(s) 920, individually or in combination, may provide editing services (e.g., hosting) and transmit data related to a CDL+T configuration file to one or more of the translator devices 940. A CDL+T configuration file corresponds to a specific natural language. The CDL+T configuration file may include human-readable text that defines a code corresponding to each prompt and, for each prompt, includes English text as a description of the prompt. The CDL+T configuration may also contain placeholder strings (e.g., empty strings) that serve as placeholders, receiving text indicating the translation into the desired natural language. In addition, the translation exchange component(s) 920 may receive input data via an editing service that defines at least a portion of the CDL+T configuration file, such input data formatted according to the CDL. In other cases, the translation exchange component(s) 920 may convert the CDL+T configuration into a specific format that can be used by at least one of the translator devices 940, and then convert the data in that specific format for at least one of the translator devices 940. For example, such data may be sent in a file compatible with the specific format. Furthermore, the translation exchange component(s) 920 may receive other data formatted according to a specific format (e.g., in a file), and then convert the other data into a CDL+T configuration file.

[0060] Translation exchange component(s) 920 can use screen capture component(s) 916 to acquire screen capture images of interactive electronic documents according to a CDL+T configuration file defined by a translator device among the translator devices 940. The CDL+T configuration file corresponds to a specific natural language. The translation exchange component(s) 920 can then send the screen capture images to the translator device. In response, the translator device can perform, or facilitate, a review of the screen capture images to evaluate the quality of the translation associated with the CDL+T configuration file in the specific natural language.

[0061] This disclosure is not limited to the generation of CDL configuration files via editor component 912. Although not shown in Figure 9, in some embodiments, the computing system 900 may include a designer subsystem that can enable the graphical and / or pre-configured generation of interactive electronic documents. Such a subsystem can be used in repository management component 918a to manage configurations and supply those configurations to a workflow service for further use by applications 954 (e.g., intra-clinical or home-use applications).

[0062] Furthermore, or in some cases, the computing system 900 may also include an administrator screen presentation component (not shown in Figure 9). Such a component can link the management of the survey library with the use of surveys in eCOA trials performed on a particular platform. In one embodiment, an authenticated and authorized user may publish a survey from the survey library directly to a specific survey ID from a particular survey to which the user is authorized to perform such an action.

[0063] The assembly subsystem 910 also includes one or more repository management components 918 that can enable scrutiny of CDL configuration files 982 or configuration packages 654, or both, held in the data repository 650. For this purpose, the repository management component 918 can cause the display device 922 to present a user interface that may include a list of interactive configuration packages (or their respective interactive electronic documents) or component configuration files held in the data repository 650. Each item in the list may be represented by a selectable visual element that, in response to selection, triggers the presentation of one or more configuration files (CDL+D, CDL+T, CDL+L) that constitute the selected item (or configuration package). The user interface may be one of the UI 924. UI 1110, shown in Figure 11A, is an example of such a user interface. UI 1150, shown in Figure 11B, is an example of a user interface that may be presented in response to selecting an item in the list of interactive configuration packages. As described herein, the contents of the data repository 650 may be generated by a component 714 which is part of a package supply subsystem 710 included in the computing system 900. Note that the display device 922 facilitates the authorization and management of interactive electronic documents, in contrast to the display device 120 (Figure 1), which enables traversing and thus completing interactive electronic documents.

[0064] The repository management component(s) 918 may also enable the management of libraries of interactive electronic documents (or their respective configuration packages 654), individually or in combination. Additionally, the repository management component(s) 918 may enable end users to save configuration files (e.g., CDL+D, CDL+T, CDL+L) to the data repository 650 as part of the CDL configuration file 982. The repository management component(s) 918 may also enable the management of configuration files 982 and configuration packages 654, individually or in combination, and to store additional optional data relating to those configuration files and packages.

[0065] The computing system 900 also includes one or more device synchronization components 970. At least one of the device synchronization components 970 may be functionally coupled to a computing device 950, each including application 114 (Figure 1) as described herein. As shown by the dashed line, the computing device 950 may be outside the computing device 900. At least one of the networks 928 can provide such a functional coupling. Since the computing device among the computing devices 950 may be a partially connected device, for example, a device that lacks connectivity to at least one network for a certain period, at least one of the device synchronization components 970 may receive data from the computing device during the period when the computing device has connectivity to at least one network. Such data may define the current state of the traversal of an interactive document in the computing device. Thus, the data may include prompt-response data indicating one or more responses to each prompt presented to the computing device. In response to receiving such data, one or more of the device synchronization components 970 may synchronize (i) the current state of the interactive electronic document traversal in the computing device and (ii) the last recorded state of the interactive electronic document traversal. In addition to, or as part of, synchronizing such states, the device synchronization component 970 may hold prompt response data as part of response data 987 in the data repository 984. The device synchronization component 970 may also send other data to one of the computing devices 950 in response to a computing device becoming connected to at least one of the networks 928.Such other data may include setting parameters that can control the manner in which interactive electronic documents are implemented on computing devices.

[0066] At least one of the device synchronization components 970 can receive scoring data from one or more computing devices 950 and can hold the scoring data in the data repository 984 as part of the scoring data 986. At least one of the device synchronization components 970 can also receive data exported from interactive electronic documents and can hold such exported data in the data repository 984 as part of the data export 988.

[0067] The computing system 900 further includes a device management subsystem 930 that can track computing devices 950 used to traverse interactive electronic documents (such as questionnaires or consent forms). For that purpose, the device management subsystem 930 can maintain a record corresponding to each computing device of the computing devices 950, and each record of the records includes data indicating the computing resources of the computing device. Computing resources include the operating system (O / S), visualization resources (e.g., display size, display resolution, UI toolkit type, combination thereof, or similar), and / or other resources. In some cases, the device management subsystem 930 can provision one or more of the computing devices 950. As part of provisioning, the device management subsystem 930 can generate such records for the provisioned computing device(s). In addition, or in other cases, the device management subsystem 930 can generate such records for each computing device that acquires (e.g., downloads and installs) the application 114. As part of provisioning computing devices, the device management subsystem 930 can also generate records containing data that show the relationship between computing devices and an organization that uses the computing devices to provide interactive electronic documents to end users. Such relationships may indicate that the computing devices are supplied by or otherwise managed by the organization, or that the computing devices are outside the organization. Computing devices outside the organization may be classified as a personal device utilization (BYOD) type.

[0068] In some embodiments, as shown in Figure 12A, the computing system 900 may include a verification subsystem 1210 functionally coupled to at least an assembly subsystem 910. In some cases, the verification subsystem 1210 may also be functionally coupled to a display device 922. The verification subsystem 1210 can verify configuration packages for a set of views. Verifying configuration packages may allow for maintaining an accurate verification state of the configuration packages. The configuration package may be one of the configuration packages 654.

[0069] To verify a configuration file, the verification subsystem 1210 can first update the verification status of the configuration file. For this purpose, the verification subsystem 1210 may include a first component 1250, shown in Figure 12B, which can determine that a first configuration file has been modified. The configuration file may be held in a CDL configuration file 982 and may be one of a CDL+D configuration file, a CDL+T configuration file, or a CDL+L configuration file. The first component 1250 can then identify a configuration package containing the first configuration file. As mentioned, the configuration package may be one of, for example, a configuration package 654.

[0070] Additionally, the first component 1250 can identify one or more second configuration files that depend on the first configuration file. The second configuration files are included in the configuration package. To determine such dependencies, the first component 1250 can determine references that associate the first configuration file with another configuration file, and then identify such other configuration files as one of the second configuration files. The first component 1250 can determine if references to yet another configuration file exist in the other configuration files. If so, the first component 1250 identifies that additional other configuration file as another second configuration file among the second configuration files. The first component 1250 can continue analyzing the referenced and associated configuration files until the other configuration file can no longer be identified as one of the second configuration files.

[0071] The first component 1250 can classify each file of the second configuration file(s) as an unverified file. By classifying each second configuration file(s) of the second configuration file(s), the first component 1250 updates the verification status of each second configuration file(s) of the second configuration file(s). Additionally, in contrast to existing technologies, by classifying configuration files(s) and unverified, the verification subsystem 1210 can separate configuration files(s) for verification in response to modified configuration files. Thus, computing resources can be used more efficiently when updating and / or maintaining interactive electronic documents according to aspects of this disclosure.

[0072] The first component 1250 can also cause the display device 922 to present a UI containing a list of second configuration files (or more). The first component 1250 can then receive input data indicating the selection of an unverified file. Such input data may be received via the selection of elements in the list, where each element represents an unverified file.

[0073] In some cases, as shown in Figure 12B, the second component 1260 of the verification subsystem 1210 can provide an unverified file to the assembly subsystem 910. The second component 1260 can provide the selected unverified file in several ways. For example, the second component 1260 can pass the assembly subsystem 910 a reference to the selected unverified file, or another type of identifier for the selected unverified file. The assembly subsystem 910 can then use the reference or other identifier to retrieve the unverified file from the data repository 650.

[0074] Therefore, the unverified file can be updated via the assembly subsystem 910, or one or more components of the assembly subsystem 910, in a manner similar to the assembly of a new configuration file. After the update to the unverified file is complete, the updated unverified file can be made available to the verification subsystem 1210. The second component 1260 can acquire (e.g., receive or retrieve) the updated unverified file and make it available to the third component 1270 of the verification subsystem 1210, as shown in Figure 12B.

[0075] The third component 1270 can apply verification tests to the updated unverified file. The verification tests may be specific to the type of unverified file. That is, verification tests applied to a CDL+D configuration file may differ from those applied to a CDL+T configuration file. Similarly, verification tests applied to a CDL+D configuration file or a CDL+T configuration file may differ from those applied to a CDL+L configuration file. For example, applying verification tests for a CDL+D configuration file may include each script executing (or causing to execute) one or more NO-CODE scripts and / or one or more LOW-CODE scripts that emulate the end-user response to the prompt(s) defined in the CDL+D configuration file. In response to executing (or causing to execute) one of such scripts (NO-CODE or LOW-CODE), the third component 1270 can automatically determine whether the logical statement or logical expression, or both, is properly implemented.

[0076] As another example, applying a validation test for a CDL+T configuration file may, in some embodiments, include applying a machine learning model (such as a Generative Adversarial Neural Network (GANN)) to determine the validity or invalidity of the configuration file. More specifically, the third component 1270 may implement a GANN to translate text corresponding to natural language statements in a first natural language from the first natural language to the second natural language. Additionally, the third component 1270 may then, via the GANN, back-translate the previously translated text from the second natural language to the first natural language and compare such back-translation with the original natural language statement in the first natural language to determine whether any characteristic errors or defects in the text translation can be detected. It should be noted that in some cases, when the third component 1270 applies such a validation test, the validation test may use a customized set of one or more dictionaries. In one example, the dictionaries may be applicable specifically to the domain of the clinical trial language. The customized dictionaries may be maintained in a data repository within the storage subsystem 980.

[0077] As yet another example, applying validation tests for a CDL+L configuration file may, in some cases, involve applying a group of one or more geometric conditions that define sufficient visualization output for the CDL+L configuration file. Since the rendering engine (such as the presentation component 160) can draw UI elements to the UI on a display device, the rendering engine can access data indicating the placement of UI elements within the UI. As part of applying validation tests, a third component 1270 can determine whether the rendered (or drawn) UI elements satisfy one or more geometric conditions. Note that during the application of validation tests, the UI may be rendered on the display device 922 by its rendering engine. The computing device hosting the assembly subsystem 910 may include a rendering engine.

[0078] Regardless of the type of configuration file and verification test, the successful application of a verification test (or, in some cases, multiple verification tests) to a configuration file (e.g., CDL+D, CDL+T, or CDL+L) results in the configuration file being verified. A state variable can indicate the verification status of the configuration file.

[0079] After the verification tests have been applied, the verification subsystem 1210 can determine (for example, via the first component 1250) whether the updated unverified file has been verified. A negative determination may result in further updates to the updated unverified file and the application of additional verification tests (multiple) thereafter. A positive determination may result in the verification subsystem 1210 (for example, via the first component 1250) classifying the updated unverified file as a verified configuration file. The verification subsystem 1210 can then (for example, via the second component 1260) add the verified configuration to the configuration package that originally contained the unverified version of the verified configuration file.

[0080] Figure 13 illustrates an example of a process flow for exchanging translation information according to one or more embodiments of the present disclosure. The translator device 1320 can receive input data 1332 for accessing a login page for an editing service provided by a translation exchange component 920. The editing service enables configuring or otherwise updating a CDL+T configuration file. In response to receiving input data 1332, the translator device 1320 can present a UI 1340 presenting the login page. The translator device 1320 can then receive input data 1334 defining login credentials. As part of the login process 1342, the translator device 1320 can send login credentials to a translation exchange component 920, in which case access to the editing service may be authenticated and authorized.

[0081] In response to accessing the editing service, the translator device 1320 may present a UI 1350 containing UI elements that identify the CDL+T configuration file(s) to be updated with translations for a specific natural language. The translator device may receive input data 1352 indicating the selection of a specific CDL+T configuration file(s) 1356. The translator device may send a request 1354 for a specific CDL+T configuration file(s) to the translation exchange component(s) 920. In response to the request, the translation exchange component(s) 920 may retrieve the CDL+T configuration file(s) 1356 from the data repository 1330 individually or in combination, causing the translator device 1320 to present a UI 1360. As part of causing the translator device 1320 to present a UI 1360, the translation exchange component(s) 920 may send translation data 1358 to the translator device 1320. Translation data 1348 can define human-readable text, for example, English text, and can also contain placeholder text in a desired natural language, where the placeholder text serves as a placeholder for the desired natural language text. For example, the desired language could be Portuguese, and the human-readable language defined by translation data 1348, along with the format part of the CDL+T configuration file, would include: {"code": "Q12", "text": "How bad is your pain?", "translation": "Quao ruim ea sua dor?"}, {"code"...

[0082] UI1360 may include a review pane 1364 where human-readable text defined by translation data received from translation exchange component(s) 920 can be viewed and edited. Editing such human-readable text may include, for example, editing placeholder text in the desired natural language. To edit the human-readable text defined by the translation data, the translator device 1320 may receive input data 1362 defining the statement in the desired natural language. After a translation deemed sufficient, the translator device 1320 may receive first data in the input data 1362 indicating acceptance of the edited translation data. The first input data may be received via selection of selectable visual elements 1366 present in UI1360. In response, the translator device 1320 may send update data 1356 to translation exchange component(s) 920. The update data 1356 may include at least a portion of the edited translation data. Upon receiving update data 1356, the translation exchange component(s) 920 may generate CDL+T configuration files 1358 in the data repository 1330, individually or in combination. Each CDL+T configuration file 1358 corresponds to an updated version of a specific CDL+T translation file 1356.

[0083] In response to generating the CDL+T configuration file 1358, the translation exchange component 920 may send a command 1358 (or, in some cases, a request) to the screen capture component 916 to generate one or more screen capture images 1362. The translation exchange component 920 may receive the screen capture images 1362 and send them to the translator device 1320. The screen capture images 1362 may be sent individually or contained within a single file. Receiving the screen capture images 1362 may result in the translator device 1320 presenting the UI 1370. The UI 1370 includes a review pane 1374 and a control element including a first control element (labeled "A") and a second control element (labeled "R"). The selection of a first control element via input data 1372 causes the translator device 1320 to send an indicator 1378 to accept the translation contained in the screen capture image 1362. The selection of a second control element indicates rejection of the translation contained in the screen capture image 1362, resulting in the translator device 1360 presenting the UI 1360 to the translation data 1348 for further editing.

[0084] Figure 14 illustrates another example of a process flow for exchanging translation information according to one or more embodiments of the present disclosure. A translation exchange component(s) 920 can retrieve a CDL+T configuration file 1410 for a specific natural language from a data repository 1330. A translation exchange component(s) 920 can implement a conversion process 1420 that can convert the CDL+T configuration file 1410 into a translator+T file 1424, individually or in combination. The translator+T file 1424 contains translation data present in the CDL+T configuration file, but the translation data is formatted according to a specific format that can be manipulated by the translator device 1320. A translation exchange component(s) 920 can send the translator+T file 1424 to the translator device 1320.

[0085] The translator device 1320 can receive the translator+T file 1424 and, in response, can manipulate the translator+T file 1424 by implementing the editing process 1430. The implementation of the editing process 1430 can result in a translator+T file 1434 containing updated translation data corresponding to the CDL+T configuration file 1410 in a specific natural language. The translator device 1320 can send the translator+T file 1434 to the translation exchange component 920. In response to receiving the translator+T file 1434, the translation exchange component 920 can implement the conversion process 1420 individually or in combination to convert the translator+T file 1434 into a CDL+T configuration file 1440 in a specific natural language. The translation exchange component 920 can store the CDL+T configuration file 1440 in the data repository 1330. In some cases, the translation exchange component(s) 920 can generate CDL+L configuration files (not shown in Figure 14) for specific computing devices and UI toolkits, individually or in combination. In other cases, the translation exchange component(s) 920 can cause the package supply subsystem 710 to generate such CDL+L configuration files, individually or in combination.

[0086] In response to the generation of the CDL+T configuration file 1440, the translation exchange component 920 may send a command 1444 (or, in some cases, a request) to the screen capture component 916 to generate one or more screen capture images 1448. The translation exchange component 920 may receive the screen capture images 1448 and send them to the translator device 1320. The screen capture images 1448 may be sent individually or contained within a single file. Receiving the screen capture images 1448 causes the translator device 1320 to present the UI 1450. The UI 1450 includes a review pane 1452 and a control element including a first control element (labeled "A") and a second control element (labeled "R"). The selection of a first control element via input data 1454 causes the translator device 1320 to send an indicator 1458 to accept the translation contained in the screen capture image(s) 1448. The selection of a second control element indicates rejection of the translation contained in the screen capture image(s) 1448, causing the translator device 1320 to perform the editing process 1430 again for editing the translation data contained in the translator+T file 1434.

[0087] It should be noted that both process flows shown in Figures 13 and 14 rely on the separation of the translation process from other aspects of the interactive electronic document configuration. Furthermore, by implementing either the process flow shown in Figure 13 or Figure 14, embodiments of the present disclosure provide an efficient mechanism for exchanging configuration files with a translator platform. Compared to existing technologies, this mechanism significantly reduces human intervention and efficiently utilizes computing resources when translating interactive electronic documents.

[0088] Considering the embodiments described herein, exemplary methods that may be performed in accordance with this disclosure can be better understood by referring, for example, to the flowcharts in Figures 15-17. For simplicity of explanation, the exemplary methods disclosed herein are presented and described as a series of blocks (for example, each block represents an action or operation in the method). However, the exemplary methods are not limited by the order of blocks and associated actions or operations, as some blocks may be performed in a different order and / or simultaneously with others than those shown and described herein. Furthermore, not all illustrated blocks and associated actions may be required to perform an exemplary method according to one or more embodiments of this disclosure. Two or more of the exemplary methods (and any other methods disclosed herein) may be performed in combination with each other. Note that exemplary methods (and any other methods disclosed herein) may alternatively be represented as a series of interrelated states or events, such as in a state diagram.

[0089] The methods disclosed herein can enable or facilitate the transport and transfer of such methods to a system of computing devices (such as a mobile smartphone, table computer, or blade server) for execution by one or more processors of a computing device or computing device(s), and therefore for implementation, or for storage in one or more memory devices of or functionally coupled to a computing device, while being held on a product or a computer-readable non-temporary storage medium. In one embodiment, one or more processors, such as a processor(s) that implement (e.g., execute) one or more of the disclosed methods, can be employed to implement program code (e.g., processor-executable instructions) held on a memory device or any computer or machine-readable medium in order to execute one or more of the disclosed methods. Such program code can provide a computer-executable or machine-executable framework for executing the methods described herein.

[0090] Figure 15 illustrates an exemplary method 1500 for traversing an interactive electronic document according to one or more embodiments of the present disclosure. A computing device may perform the exemplary method 1500 in whole or in part. For that purpose, the computing device includes computing resources that can implement at least one of the blocks included in the exemplary method 1500. Computing resources include, for example, a central processing unit (CPU), a graphics processing unit (GPU), a tensor processing unit (TPU), memory, disk space, incoming bandwidth and / or outgoing bandwidth, interfaces (I / O interfaces or APIs or both), controller devices (may), power supplies, combinations thereof, and / or similar resources. In one example, the computing device may include programming interfaces (may), an operating system, software, firmware for configuring and / or controlling a virtualization environment, and similar resources.

[0091] The computing device can embody the computing device 110 (Figure 1) and thus host the application 114 (Figure 1) and the components within the application 114. The computing device can execute exemplary method 1500 at the runtime of the application 114 in response to the execution of at least one of the runtime component 140, the coordination component 150, or the presentation component 160.

[0092] In block 1510, the computing device may present a user interface (UI) corresponding to a view in a set of views while running application 114 for traversing a set of views of an interactive electronic document. The UI may be presented based on current state data. The current state data includes various types of information, namely, first data defining the current location and position within the interactive electronic document, second data indicating the set of existing responses, third data indicating validation errors, and various other states. The UI may be presented on a display device (e.g., display device 120) that is integrated with or functionally coupled to the computing device. The UI includes a presentation element representing a prompt and at least one navigation control element. In one example, the set of views forms a questionnaire, and the prompts correspond to questions within the questionnaire.

[0093] In block 1520, the computing device can continue running application 114, and in response, the coordination component 150 can receive prompt-response data from the presentation component 160 in response to prompt or navigation response data associated with at least one control element. The prompt-response data may be formatted according to JSON and may be received in that format. The navigation response data may also be formatted according to JSON and may be received in that format. As described herein, the coordination component 150 may be configured to trigger the presentation of pages / views of an interactive electronic document. Additionally, the presentation component 150 may be configured to draw the respective UIs corresponding to the pages / views on a display device. In one example, each UI may include UI 130, and the display device may be display device 130. Thus, the exemplary method 1500 can proceed in two different paths: a response path and a navigation path. In Figure 15, the response path is denoted as “Response”, and the navigation path is denoted as “Navigation”.

[0094] As the response path progresses, in block 1530, the computing device can continue executing application 114, and in response, the coordination component 150 can send (or pass) prompt response data to the runtime component 140. As described herein, the runtime component 140 may be configured to apply navigation logic to current state data and to apply branching logic and verification logic (collectively referred to as traversal logic) to prompt response data. The navigation logic corresponds to a navigation mode for interactive electronic documents. For example, the navigation mode may be one of linear mode, hub-and-spoke mode, or CAT mode.

[0095] Furthermore, in the response path, in response to further execution of application 114, in block 1540, runtime component 140 may apply at least one of branch logic or verification logic to prompt response data and current state data. As a result, runtime component 140 may generate the following state data. The branch logic and verification logic may be formatted according to CDL. Although not shown, as part of exemplary method 1500, a computing device may also obtain branch logic and verification logic via runtime component 140. Obtaining branch logic and verification logic by runtime component 140 may include receiving first human-readable content defining branch logic and second human-readable content defining verification logic. The first and second human-readable content are formatted according to CDL. In some embodiments, as described herein, runtime component 140 includes an interpreter component, and as part of exemplary method 1500, runtime component 140 may apply branch logic or verification logic by applying branch logic or verification logic directly in CDL via the interpreter component.

[0096] As the navigation path progresses, in block 1550, the computing device can continue running application 114, and in response, the coordination component 150 can send (or pass) navigation response data to runtime component 140.

[0097] Regardless of whether the exemplary method 1500 proceeded along the response path or the navigation path, in block 1560, the computing device may optionally apply one or more other types of logic via the runtime component 140. These other types of logic may include, for example, one or more of the following: invalidation logic, scoring logic, or export logic.

[0098] In block 1570, the computing device can continue running application 114, and in response, the runtime component 140 can apply navigation logic to the current state data. As part of exemplary method 1500, the computing device can obtain navigation logic by receiving a group of rules corresponding to navigation modes that define the modes of traversal of a set of views via the runtime component. The group of rules may be received in a native format for the rule library contained in the runtime component.

[0099] As described herein, the runtime component 140 is not limited to rule sets, and therefore the exemplary method 1500 is not limited. In fact, in some embodiments, and also as part of the exemplary method 1500, a computing device may obtain navigation logic by selecting a navigation mode component that defines a navigation mode corresponding to a navigation mode that defines a manner of traversal of a set of views, via the runtime component 140. In such embodiments, the runtime component 140 may apply navigation logic to current state data by using an interpreter component that may be included in the runtime component 140, and by executing at least the navigation mode component via the interpreter component.

[0100] In block 1580, the computing device can continue running application 114, and in response, runtime component 140 can configure the next state data as the current state data. The flow of the exemplary method can then continue to block 1510, where the computing device can, in response to applying navigation logic, present a second UI corresponding to a second view of a set of views based on the next state data. The second UI may include a presentation element representing a second prompt and at least one second navigation control element.

[0101] Figure 16 illustrates exemplary method 1600 for presenting pages / views of an interactive electronic document according to one or more embodiments of the present disclosure. A computing device may implement exemplary method 1600 in whole or in part. In some cases, a computing device implementing exemplary method 1500 may also implement exemplary method 1600. As noted, exemplary method 1600 may be implemented as part of implementing block 1510 of exemplary method 1500.

[0102] A computing device implementing exemplary method 1600 can embody computing device 110 (Figure 1) and thus host application 114 (Figure 1) and components within application 114. The computing device can execute exemplary method 1600 at runtime of application 114 in response to executing at least one of runtime component 140, coordination component 150, or presentation component 160.

[0103] In block 1610, the computing device can run (or continue running) application 114, and in response, the coordination component 150 can obtain (e.g., receive) data from the runtime component 140 that defines a prompt. As mentioned, a prompt may include a question or a call to an action.

[0104] In block 1620, the computing device can continue running application 114, and in response, the coordination component can instruct the presentation component 160 to draw a UI containing presentation elements representing prompts. In some cases, the UI contains multiple presentation elements corresponding to each prompt.

[0105] In block 1630, the computing device can continue to run application 114, and in response, the presentation component 160 can draw the UI on the display device according to a desired or otherwise defined set of visualization resources. As mentioned, the UI may be one of several UIs 130, such as UI 132, and the display device may be display device 130 (Figure 1).

[0106] Although not shown in Figure 16, exemplary method 1600 may also include receiving data by the coordination component 150 that defines layout logic configured for a combination of interactive electronic documents, a specific natural language, and a specific visualization resource. Such data may be formatted according to a core definition language. Thus, in some embodiments, instructing the presentation component 160 to draw the UI may include passing data defining layout logic to the presentation component for interpretation by a library of UI elements (e.g., UI element library 166 (Figure 1)). The library of UI elements may include at least one presentation element and at least one control element. Then, the presentation component 160 drawing the UI on the display device may, at runtime, include retrieving UI elements from the library of UI elements and providing one or more UI elements to be included in a defined layout of an area within the UI. Such UI elements may be defined by the layout logic and configured according to one or more visualization resources of the display device, including graphic resolution and size of the visualization area.

[0107] Figure 17 illustrates an exemplary method 1700 for verifying a configuration package for a series of views, according to one or more embodiments of the present disclosure. Verifying a configuration package may enable maintaining an accurate verified state of the configuration package. A computing device may implement exemplary method 1700 in whole or in part. For that purpose, the computing device includes computing resources that can implement at least one of the blocks included in exemplary method 1700. Computing resources include, for example, a CPU, GPU, TPU, memory, disk space, incoming bandwidth and / or outgoing bandwidth, interfaces (I / O interfaces or APIs or both), controller devices (or more), power supplies, combinations thereof, and / or similar resources. In one example, the computing device may include programming interfaces (or more), an operating system, software for configuring and / or controlling a virtualization environment, firmware, and similar resources.

[0108] A computing device implementing exemplary method 1700 can host a verification subsystem 1210 (Figure 12A) and components within the verification subsystem 1210. The computing device can execute exemplary method 1700 in response to, for example, the execution of one or more of the first component 1250, the second component 1260, or the third component 1270.

[0109] In block 1705, the computing device can determine that a first configuration file has been modified (for example, via the first component 1250). The configuration file may be one of a CDL+D configuration file, a CDL+T configuration file, or a CDL+L configuration file.

[0110] In block 1710, the computing device can identify a configuration package containing configuration files (for example, via the first component 1250). The configuration package may be, for example, one of the configuration packages 654 (Figure 6B).

[0111] In block 1715, the computing device can identify one or more second configuration files that depend on a first configuration file (for example, via a first component 1250). The second configuration files are included in a configuration package.

[0112] In block 1720, the computing device can classify each file of the second configuration file(s) as an unverified file (for example, via the first component 1250).

[0113] In block 1725, the computing device may trigger the presentation of a list of second configuration files (for example, via the first component 1250). The list may be presented on a display device integrated into or functionally coupled to the computing device.

[0114] In summary, blocks 1705-1725 can form a method for updating the validation status of the configuration file.

[0115] In block 1730, the computing device can receive input data indicating the selection of an unverified file (for example, via the first component 1250).

[0116] In block 1735, the computing device can update or trigger an update of an unverified file. The computing device can trigger an update of an unverified file, for example, via a second component 1260. The computing device can cause the assembly subsystem 910 (Figure 9) to update the unverified file. In some embodiments, the computing device can also host the assembly subsystem 910 and the components within it. Thus, the computing device can update the unverified file via its subsystem.

[0117] In block 1740, the computing device can apply verification tests to an unverified file (for example, via a third component 1270). The verification tests may be specific to the type of unverified file. That is, verification tests applied to a CDL+D configuration file may differ from those applied to a CDL+T configuration file. Similarly, verification tests applied to a CDL+D configuration file or a CDL+T configuration file may differ from those applied to a CDL+L configuration file. For example, applying verification tests for a CDL+D configuration file may involve executing one or more no-code scripts and / or one or more low-code scripts, each of which emulates an end-user response to a prompt(s) defined in the CDL+D configuration file. In response to executing one such script (no-code script or low-code script), the computing device can automatically determine whether a logical statement or logical expression, or both, is properly implemented.

[0118] As another example, applying a validation test for a CDL+T configuration file may, in some embodiments, include applying a machine learning model (such as a GANN) to determine the validity or invalidity of the configuration file. More specifically, a computing device may implement a GANN to translate text corresponding to natural language statements in a first natural language from the first natural language to the second natural language. Additionally, the GANN may determine whether it can detect any characteristic errors or defects in the translation of the text by back-translating the previously translated text from the second natural language to the first natural language and comparing such back-translation to the original natural language statement in the first natural language. It should be noted that in some cases, when a computing device applies such a validation test, the validation test may use a customized set of one or more dictionaries. As mentioned, in one example, the dictionaries may be applicable specifically to the domain of the clinical trial language.

[0119] As yet another example, applying validation tests for a CDL+L configuration file may, in some cases, involve applying a group of one or more geometric conditions that define sufficient visualization output for the CDL+L configuration file. Since a rendering component (such as presentation component 160) can draw UI elements to the UI on a display device, the rendering component can access data indicating the placement of UI elements within the UI. As part of applying validation tests, a computing device can determine whether the rendered (or drawn) UI elements satisfy one or more geometric conditions.

[0120] Regardless of the type of configuration file and verification test, the successful application of a verification test (or, in some cases, multiple verification tests) to a configuration file (e.g., CDL+D, CDL+T, or CDL+L) results in the configuration file being verified. A state variable can indicate the verification status of the configuration file.

[0121] In block 1742, the computing device (for example, via the first component 1250) can determine whether the updated unverified file is verified. A negative determination ("no" branch) results in the flow of exemplary method 1700 being directed to block 1745, where the computing device can classify the updated unverified file as unverified before the flow of exemplary method 1700 continues to block 1735 for further updates. A positive determination ("yes" branch) results in the flow of exemplary method 1700 being directed to block 1750, where the computing device can classify the updated unverified file as a verified configuration file.

[0122] In block 1755, the computing device can add a verified configuration to the configuration package (for example, via a second component 1260).

[0123] To provide additional context, the computer-based methods and systems disclosed herein may be executed on the computing system 1800 illustrated in Figure 18 and described below. Similarly, the computer-based methods and systems disclosed herein may utilize one or more computing devices to perform one or more functions at one or more locations. Figure 18 is a block diagram illustrating an example of a computing system 1800 for performing the disclosed methods and / or implementing the disclosed systems. The computing system 1800 shown in Figure 18 is merely an example of a computing system and is not intended to imply any limitation on the scope of use or functionality of the operating environment architecture. Furthermore, the operating environment should not be construed as having any dependencies or requirements relating to any one or any combination of components illustrated in the exemplary operating environment.

[0124] The computer-based methods and systems described herein can operate in a number of other general-purpose or dedicated computing system environments or configurations. Examples of well-known computing systems, environments, and / or configurations that may be suitable for use in the systems and methods include, but are not limited to, personal computers, server computers, laptop devices, and multiprocessor systems. Additional examples include set-top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, and distributed computing environments that include any of the systems or devices described above.

[0125] The methods and systems that are performed on the disclosed computers may be executed by software components. The systems and methods that are performed on the disclosed computers may be described in a general context in which computer executable instructions are executed by one or more computers or other processing devices. Generally, program modules may include program code, routines, objects, components, data structures, etc., that perform a specific task or implement a specific abstract data type. The methods that are performed on the disclosed computers may also be implemented in a grid-type distributed computing system in which tasks are performed by remote computing devices linked through a communication network. In a distributed computing system, program modules may reside in both local computer storage media, including memory storage devices, and remote computer storage media.

[0126] Furthermore, the systems and methods executed on computers disclosed herein can be implemented via a general-purpose computing device in the form of a computing device 1801. In some embodiments, the computing device 1801 can embody a computing device 110 (Figure 1). The components of the computing device 1801 may include one or more processors 1803, a system memory 1812, and a system bus 1813 that functionally connects various system components, including one or more processors 1803, to the system memory 1812. In some cases, the system can utilize parallel computing.

[0127] System bus 1813 represents one or more of several possible types of bus structures, including a memory bus or memory controller, peripheral bus, accelerated graphics port, or local bus, using any of a variety of bus architectures. System bus 1813, and all buses specified herein, may be implemented via wired or wireless network connections, and each subsystem, including one or more processors 1803, one or more mass storage devices 1804 (referred to as mass storage 1804), an operating system 1805, software 1806, data 1807, a network adapter 1808, system memory 1812, input / output interface 1810, a display adapter 1809, a display device 1811, and a human-machine interface 1802, may be contained within one or more remote computing devices 1814a, b, c, which are physically separated locations, connected through this form of bus, and effectively implement a fully distributed system.

[0128] The computing device 1801 typically comprises a variety of computer-readable media. Examples of readable media may be any available media accessible by the computing device 1801, and may include, for example, both volatile and non-volatile media, removable and non-removable media. The system memory 1812 includes computer-readable media in the form of volatile memory, such as random access memory (RAM), and / or non-volatile memory, such as read-only memory (ROM). The system memory 1812 typically includes data, such as data 1807, and / or program modules, such as the operating system 1805 and software 1806, and software that is immediately accessible and / or currently being operated by one or more processors 1803.

[0129] The computing device 1801 may also include other removable / non-removable, volatile / non-volatile computer storage media. As an example, Figure 18 illustrates a mass storage 1804 that can provide non-volatile storage for computer code, computer-readable instructions, data structures, program modules, and other data for the computing device 1801. For example, the mass storage 1804 may be embodied in, or include, a hard disk, removable magnetic disk, removable optical disk, magnetic cassette or other magnetic storage device, flash memory card, CD-ROM, digital versatile disk (DVD) or other optical storage, random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), etc.

[0130] Optionally, any number of program modules, including, for example, operating system 1805 and software 1806, can be stored in mass storage 1804. Each of operating system 1805 and software 1806 (or several combinations thereof) may contain programming and elements of software 1806. Data 1807 can also be stored in mass storage 1804. Data 1807 can be stored in one or more databases. Examples of such databases include DB2®, Microsoft® Access, Microsoft® SQL Server, Oracle®, MySQL, PostgreSQL, etc. Databases may be centralized or distributed across multiple systems. In some cases, computing device 1801 may host one or more of the various subsystems described herein. The execution of software 1806 by processor 1803 can cause computing device 1801 to provide at least some of the functionality described herein in relation to the assembly and presentation of interactive electronic documents. In an exemplary scenario in which computing device 1801 embodies computing device 110, software 1806 may include application 114 and components within application 114, such as runtime component 140, coordination component 150, and presentation component 160.

[0131] In some configurations, one or more of the subsystems described herein may be hosted in a distributed manner. Thus, software 1806 may be replicated among such computing devices. In other configurations, some components of software 1806 may be localized to a specific computing device among the computing devices, and other components of software 1806 may be localized to a second specific computing device among the computing devices. In such embodiments, the execution of software 1806 by at least one processor present in a combination of computing device 1801 and remote computing devices 1814a, b, c may cause such a computing system to provide at least some of the functionality described herein relating to the assembly and presentation of interactive electronic documents. In some embodiments, at least one of the remote computing devices 1814a, b, c may embody or host a package delivery subsystem 710 (Figure 7). Such computing devices may also include software such as software 1806, which may embody or include a delivery component 718, a component 714, and a packaging component 716. In addition, or in some embodiments, the computing system 1800 may also embody or include a computing system that enables the generation and management of interactive electronic documents as described herein. In short, the computing system 1800 may, in some cases, host a computing system 900 that includes a verification subsystem 1210 and components within the verification subsystem 1210 (e.g., a first component 1250, a second component 1260, and a third component 1270).Accordingly, in some embodiments, the computing system 1800 may include an assembly subsystem 910, a device management subsystem 930, a package supply subsystem 710, a device synchronization component(s) 970, a storage subsystem 980, and in some cases, a verification subsystem 1210 and components within the verification subsystem 1210. In such embodiments, the software 1806 may be replicated between remote computing devices 1814a, b, c, and may embody or include various components and / or subsystems, such as the assembly subsystem 910, the device management subsystem 930, the package supply subsystem 710, a device synchronization component(s) 970, and in some cases, the verification subsystem 1210 and components within the verification subsystem 1210. Execution of the software 1806 by one or more processors contained in the remote computing devices 1814a, b, c may provide the functionality described herein in relation to those subsystems and components. The memory devices within the remote computing devices 1814a, b, and c can embody or contain the storage subsystem 980 and the data contained in the storage subsystem 980.

[0132] It should be noted that this disclosure is not limited to hosting a computing system 900, and in some cases, it may include a verification subsystem 1210 and components within the verification subsystem 1210 in a distributed manner. In some cases, a single computing device, e.g., one of computing device 1801 or remote computing devices 1814a, b, c, may host a computing system 900, including, in some cases, a verification subsystem 1210 and components within the verification subsystem 1210. That single computing device may include software 1806 and may embody or include various components and / or subsystems, such as an assembly subsystem 910, a device management subsystem 930, a package supply subsystem 710, a device synchronization component(s) 970, and, in some cases, a verification subsystem 1210 and components within the verification subsystem 1210. Execution of software 1806 by one or more processors contained in that single computing device may provide the functionality described herein in relation to those subsystems and components. The memory device within the single computing device can embody or contain the storage subsystem 980 and the data contained in the storage subsystem 980.

[0133] In another embodiment, an end user may input commands and data to the computing device 1801 via an input device (not shown). Examples of such input devices include, but are not limited to, a keyboard, a pointing device (e.g., a “mouse”), a microphone, a joystick, a scanner, a glove, and other tactile input devices such as body covers. These and other input devices may be connected to one or more processors 1803 via a human-machine interface 1802 coupled to a system bus 1813, but may also be connected by other interfaces and bus structures such as a parallel port, a game port, an IEEE 1394 port (also known as a Firewire port), a serial port, or a Universal Serial Bus (USB).

[0134] In another embodiment, the display device 1811 may also be connected to the system bus 1813 via an interface such as a display adapter 1809. In some configurations, the computing device 1801 may have two or more display adapters 1809, and the computing device 1801 may have two or more display devices 1811. For example, the display device 1811 may be a monitor, an LCD (liquid crystal display), or a projector. In addition to the display device 1811, other output peripheral devices may include components such as a speaker (not shown) and a printer (not shown) that can be connected to the computing device 1801 via an input / output interface 1810. Any operation and / or results of this method may be output to an output device in any form. Such output may be any form of visual representation, including but not limited to text, graphics, animations, audio, and haptics. Thus, the display device 1811 may present various user interfaces and other information (data, metadata, and / or configuration attributes) related to tenant-specific services. The display device 1811 and the computing device 1801 may be a single device or part of separate devices. The display device 1811 can embody the display device 130 (Figure 1).

[0135] The computing device 1801 can operate in a network environment using logical connections to one or more remote computing devices 1814a, b, c and / or one or more storage server devices 1820. For example, the remote computing devices may be personal computers, portable computers, smartphones, servers, routers, network computers, peer devices, or other common network nodes. The logical connections between the computing device 1801 and the remote computing devices 1814a, b, c and the server storage devices among the server storage devices 1820 may be made via a network 1815, such as a local area network (LAN) and / or a general wide area network (WAN). Such network connections may be made through a network adapter 1808. The network adapter 1808 may be implemented in both wired and wireless environments.

[0136] For illustrative purposes, application programs and other executable program components, such as the operating system 1805, are illustrated herein as separate blocks, but such programs and components are recognized to reside at different times in different storage components of the computing device 1801 and to be executed by one or more processors 1803 of the computer. Implementations of the software 1806 may be stored in or transmitted through any form of computer-readable medium. Any of the disclosed methods may be executed by computer-readable instructions embodied on the computer-readable medium. The computer-readable medium may be any available medium that can be accessed by the computer. As described herein, “computer storage medium” includes volatile and non-volatile, removable and non-removable mediums implemented in any way or technique for storing information such as computer-readable instructions, data structures, program modules, or other data.

[0137] Many other exemplary embodiments arise from the above detailed description and the accompanying drawings. Embodiment 1: A computing device comprising at least one processor running a computer executable component stored in at least one memory device, wherein the computer executable component comprises a runtime component configured to apply navigation logic corresponding to navigation modes for a set of views, each view of the set of views including its respective prompt, and a coordination component configured to cause the presentation of at least one view of the set of views in response to the runtime component applying the navigation logic.

[0138] Example 2: The computing device according to Example 1, further comprising a presentation component configured to render a user interface corresponding to at least one view, the computer executable component.

[0139] Example 3: The computing device according to Example 1, wherein the runtime component includes a runtime interface that functionally connects the runtime component to the coordination component.

[0140] Example 4: The computing device according to Example 1, wherein a series of views represent interactivity, and the navigation mode defines the mode of traversal of interactive electronic documents.

[0141] Example 5: The computing device described in Example 4, wherein the navigation mode corresponds to linear mode, hub-and-spoke mode, or computer adaptive testing (CAT) mode.

[0142] Example 6: The computing device according to Example 4, wherein the interactive electronic document includes a questionnaire corresponding to one of the following: clinical outcome assessment, triage assessment, neuropsychological assessment, college aptitude assessment, vocational assessment, professional certification assessment, survey, or standalone task guide.

[0143] Example 7: The computing device described in Example 1, wherein a series of views represent a consent document, a privacy practices document, or a waiver consent document.

[0144] Example 8: The computing device according to Example 1, wherein the presentation of at least one view from a set of views is triggered by a runtime component applying navigation rules, and the layout logic is implemented such that it corresponds to two or more specific combinations of a unique computing device, natural language, or a user interface (UI) toolkit.

[0145] Example 9: The computing device according to claim 8, further comprising a library of user interface (UI) elements including at least one presentation element and at least one control element, wherein the implementation of layout logic includes, via a first interface, retrieving UI elements from the library of UI elements and supplying one or more UI elements for inclusion in a defined layout of an area in the first user interface corresponding to a view of at least one view.

[0146] Example 10: The computing device according to Example 1, wherein the runtime component is further configured to apply at least one of branch logic or validation logic based on input data that responds to a first prompt in a first view of at least one of the views.

[0147] Example 11: The computing device according to Example 1, wherein the coordination component is further configured to implement translation logic for a first view of at least one view.

[0148] Example 12: The computing device according to Example 10, wherein implementing translation logic includes determining whether a translation rule is satisfied for a particular view among at least one view, and translating a first natural language statement presented in a first natural language within the particular view into a second natural language statement in a second natural language.

[0149] Example 13: A method executed on a computer, comprising: presenting a user interface (UI) corresponding to a view in a series of views during the execution of an application that traverses a series of views of an interactive electronic document based on current state data, wherein the UI includes a presenting element representing a prompt and at least one navigation control element; a coordination component of the application receiving prompt response data in response to a prompt from the application's presenting component; the coordination component sending the prompt response data to the application's runtime component; the runtime component applying at least one branch logic or validation logic to the prompt response data and current state data to bring about next state data; the runtime component applying navigation logic to the current state data; and, in response to applying the navigation logic, presenting a second UI corresponding to a second view in a series of views based on next state data, wherein the second UI includes a second prompt and at least one second navigation control element.

[0150] Example 14: A computer-executed method according to Example 13, further comprising: a coordination component receiving navigation response data from a presentation component corresponding to the selection of a particular navigation control from at least one second navigation control; the coordination component transmitting the navigation response data to a runtime component; the runtime component applying navigation logic to the next state data; and, in response to the application of the navigation logic, presenting a third UI corresponding to a third view from a set of views based on the next state data.

[0151] Example 15: A method performed on a computer as described in Example 13, wherein presenting a UI includes a coordination component obtaining data defining a prompt from a runtime component, the coordination component instructing a presenting component to draw the UI, and the presenting component drawing the UI on a display device.

[0152] Example 16: A method executed on a computer as in Example 13, which involves obtaining navigation logic by having a runtime component receive a group of rules corresponding to a navigation mode that defines the traversal patterns of a set of views, further comprising receiving the group of rules in a native format for the rule library included in the runtime component.

[0153] Example 17: The method described in Example 13, performed on a computer, wherein the runtime component obtains the navigation logic, further including holding a group of rules in a rule library.

[0154] Example 18: The method executed on a computer according to Example 13, further comprising obtaining branch logic and verification logic by a runtime component.

[0155] Example 19: A method performed on a computer according to Example 18, wherein the runtime component obtains branch logic and verification logic, which includes receiving a first human-readable content defining branch logic and a second human-readable content defining verification logic, wherein the first and second human-readable content are formatted according to a core definition language, and converting the branch logic and verification logic into a second group of rules formatted according to a native format.

[0156] Example 20: A method executed on a computer as described in Example 15, wherein the runtime component includes a rule component, and the runtime component applies navigation logic, branch logic, or validation logic, and the rule component applies one or more specific rules from a group of rules, or specific rules from a second group of rules.

[0157] Example 21: A computer-executed method according to Example 13, further comprising obtaining navigation logic by having a runtime component select a navigation mode component that defines a navigation mode corresponding to a navigation mode that defines a manner of traversal of a set of views.

[0158] Example 22: The method executed on a computer according to Example 21, further comprising obtaining branch logic and verification logic by a runtime component.

[0159] Example 23: A method performed on a computer according to Example 22, wherein the runtime component obtains branch logic and verification logic, which includes receiving a first human-readable content defining branch logic and a second human-readable content defining verification logic, wherein the first and second human-readable content are formatted according to a core definition language.

[0160] Example 24: A method performed on a computer as described in Example 21, wherein the runtime component comprises an interpreter component, the runtime component applies navigation logic, and the interpreter component executes a navigation mode component.

[0161] Example 25: A method performed on a computer as described in Example 23, wherein the runtime component comprises an interpreter component, and the application of branch logic or verification logic is performed by the interpreter component directly in the core definition language.

[0162] Example 26: The method described in Example 13, executed on a computer, wherein prompt response data is formatted according to JavaScript Object Notation (JSON).

[0163] Example 27: The method described in Example 14, executed on a computer, wherein the navigation response data is formatted according to JavaScript Object Notation (JSON).

[0164] Example 28: A method performed on a computer as described in Example 14, further comprising receiving data that defines a layout logic configured for a combination of an interactive electronic document, a specific natural language, and a specific visualization resource, wherein the data is formatted according to a code definition language.

[0165] Example 29: A method performed on a computer according to Example 21, further comprising a library of user interface (UI) elements including at least one presentation element and at least one control element, wherein instructing a presentation component to draw the UI includes passing data defining layout logic to the presentation component for interpretation by the library of UI elements.

[0166] Example 30: A method performed on a computer according to Example 29, wherein the presentation component renders a UI on a display device, comprising at runtime retrieving UI elements from a library of UI elements and supplying one or more UI elements to be included in a defined layout of an area within the UI.

[0167] Example 31: A method executed on a computer as described in Example 30, wherein a UI element is configured according to one or more visualization resources of a display device, and one or more visualization resources are defined by layout logic, including graphic resolution and size of visualization area.

[0168] Example 32: A method performed on a computer according to claim 14, further comprising receiving data that defines translation logic and applying translation logic to data that defines a prompt.

[0169] Example 33: At least one non-temporary computer-readable storage medium having a processor-executable instruction encoded on the at least one non-temporary computer-readable storage medium, wherein the processor-executable instruction, in response to execution, causes a computing device to present a user interface (UI) corresponding to a view in a series of views, including a presentation element representing a prompt and at least one navigation control element, during the execution of an application that traverses a series of views of an interactive electronic document, based on current state data; the coordination component of the application receives prompt response data in response to a prompt from the presentation component of the application; the coordination component sends the prompt response data to the runtime component of the application; the runtime component applies at least one branch logic or verification logic to the prompt response data and current state data to obtain the next state data; the runtime component applies navigation logic to the current state data; and in response to applying the navigation logic, presents a second UI corresponding to a second view in a series of views, including a second prompt and at least one second navigation control element, based on the next state data.

[0170] Example 34: At least one non-temporary computer-readable storage medium according to Example 33, wherein a processor-executable instruction, in response to further execution, causes a computing device, by a coordination component, to receive navigation response data from a presentation component corresponding to the selection of a particular navigation control from at least one second navigation control; by the coordination component, to send the navigation response data to a runtime component; by the runtime component, to apply navigation logic to the next state data; and in response to the application of the navigation logic, to present a third UI corresponding to a third view from a set of views based on the next state data.

[0171] Example 35: At least one non-temporary computer-readable storage medium according to Example 33, wherein presenting a UI includes a coordination component obtaining data defining a prompt from a runtime component, the coordination component instructing a presenting component to draw the UI, and the presenting component drawing the UI on a display device.

[0172] Example 36: At least one non-temporary computer-readable storage medium as in Example 33, wherein a processor-executable instruction causes a computing device to further acquire navigation logic by receiving a group of rules corresponding to a navigation mode that defines a mode of traversal of a set of views, which are received by the runtime component in a native format for the rule library contained in the runtime component, in response to further execution.

[0173] Example 37: At least one non-temporary computer-readable storage medium as in Example 33, further comprising obtaining navigation logic by a runtime component and holding a group of rules in a rule library.

[0174] Example 38: At least one non-temporary computer-readable storage medium according to Example 33, further comprising obtaining branch logic and verification logic by a runtime component.

[0175] Example 39: At least one non-temporary computer-readable storage medium according to Example 38, wherein the runtime component obtains branch logic and verification logic, which includes receiving a first human-readable content defining branch logic and a second human-readable content defining verification logic, wherein the first and second human-readable content are formatted according to a core definition language, and converting the branch logic and verification logic into a second group of rules formatted according to a native format.

[0176] Example 40: At least one non-temporary computer-readable storage medium as in Example 35, wherein the runtime component includes a rule component, and the runtime component applies navigation logic, branch logic, or validation logic, and the rule component applies one or more specific rules from a group of rules, or specific rules from a second group of rules.

[0177] Example 41: At least one non-temporary computer-readable storage medium according to claim 33, wherein a processor-executable instruction causes a computing device to further acquire navigation logic by having a runtime component select a navigation mode component that defines a navigation mode corresponding to a navigation mode that defines a manner of traversal of a set of views, in response to further execution.

[0178] Example 42: At least one non-temporary computer-readable storage medium according to Example 41, wherein a processor-executable instruction causes a computing device, in response to further execution, to acquire branch logic and verification logic by a runtime component.

[0179] Example 43: The runtime component obtains branch logic and verification logic by receiving a first human-readable content defining branch logic and a second human-readable content defining verification logic, wherein the first human-readable content and the second human-readable content are formatted according to a core definition language, the same as the at least one non-temporary computer-readable storage medium described in Example 42.

[0180] Example 44: At least one non-temporary computer-readable storage medium according to Example 41, wherein the runtime component comprises an interpreter component, the runtime component applies navigation logic, and the interpreter component executes a navigation mode component.

[0181] Example 45: At least one non-temporary computer-readable storage medium as in Example 43, wherein the runtime component comprises an interpreter component, and the application of branch logic or verification logic is performed by the interpreter component directly in the core definition language.

[0182] Example 46: At least one non-temporary computer-readable storage medium as in Example 33, wherein prompt response data is formatted according to JavaScript Object Notation (JSON).

[0183] Example 47: At least one non-temporary computer-readable storage medium according to claim 44, wherein navigation response data is formatted according to JavaScript Object Notation (JSON).

[0184] Example 48: At least one non-temporary computer-readable storage medium according to claim 44, wherein a processor-executable instruction causes a computing device to receive data defining layout logic configured for a combination of interactive electronic documents, a specific natural language, and a specific visualization resource, formatted according to a code-defining language, in response to further execution.

[0185] Example 49: The computing device comprises a library of user interface (UI) elements, each comprising at least one presentation element and at least one control element, and instructing the presentation component to draw the UI comprises passing data defining layout logic to the presentation component for interpretation by the library of UI elements, wherein the at least one non-temporary computer-readable storage medium is as described in claim 41.

[0186] Example 50: A non-temporary computer-readable storage medium according to Example 49, wherein the presentation component renders a UI on a display device, which at runtime includes retrieving UI elements from a library of UI elements and supplying one or more UI elements to be included in a defined layout of areas within the UI.

[0187] Example 51: A computing device comprising one or more processors and one or more memory devices storing processor executable instructions, wherein the processor executable instructions, in response to execution by one or more processors, cause the computing device to present a user interface (UI) corresponding to a view in a series of views, including a presentation element representing a prompt and at least one navigation control element, during the execution of an application that traverses a series of views of an interactive electronic document, based on current state data; the application's coordination component receives prompt response data in response to the prompt from the application's presentation component; the coordination component sends the prompt response data to the application's runtime component; the runtime component applies at least one branch logic or verification logic to the prompt response data and current state data to obtain the next state data; and the runtime component applies navigation logic to the current state data, and in response to the application of the navigation logic, presents a second UI corresponding to a second view in a series of views, including a second prompt and at least one second navigation control element, based on the next state data.

[0188] Example 52: The computing device according to Example 51, wherein a processor executable instruction, in response to further execution, causes the computing device to receive navigation response data from the presentation component, via a coordination component, corresponding to the selection of a particular navigation control from at least one second navigation control; the coordination component transmits the navigation response data to the runtime component; the runtime component applies navigation logic to the next state data; and, in response to the application of the navigation logic, presents a third UI corresponding to a third view from a set of views based on the next state data.

[0189] Example 53: The computing device according to Example 51, wherein presenting a UI includes a coordination component obtaining data defining a prompt from a runtime component, the coordination component instructing a presenting component to draw the UI, and the presenting component drawing the UI on a display device.

[0190] Example 54: The computing device according to Example 51, wherein a processor executable instruction causes the computing device to further acquire navigation logic in response to further execution by receiving a group of rules corresponding to a navigation mode that defines a mode of traversal of a set of views, which is received by the runtime component in a native format for the rule library contained in the runtime component.

[0191] Example 55: The computing device described in Example 51, further comprising obtaining navigation logic via a runtime component, and holding a group of rules in a rule library.

[0192] Example 56: The computing device according to Example 51, wherein the processor executable instructions cause the computing device to further acquire branch logic and verification logic by runtime components in response to further execution.

[0193] Example 57: The computing device according to Example 56, wherein the runtime component obtains branch logic and verification logic, which includes receiving a first human-readable content defining branch logic and a second human-readable content defining verification logic, wherein the first and second human-readable content are formatted according to a core definition language, and converting the branch logic and verification logic into a second group of rules formatted according to a native format.

[0194] Example 58: The computing device according to Example 53, wherein the runtime component includes a rule component, and the runtime component applies navigation logic, branching logic, or validation logic, and the rule component applies one or more specific rules from a group of rules, or specific rules from a second group of rules.

[0195] Example 59: The computing device according to Example 51, wherein a processor executable instruction causes the computing device to further acquire navigation logic in response to further execution by selecting a navigation mode component that defines a navigation mode corresponding to a navigation mode that defines the manner of traversal of a series of views, through a runtime component.

[0196] Example 60: The computing device according to Example 59, wherein a processor-executable instruction causes the computing device to further acquire branch logic and verification logic by a runtime component in response to further execution.

[0197] Example 61: The computing device according to Example 60, wherein the runtime component receives branch logic and verification logic, which includes receiving a first human-readable content defining branch logic and a second human-readable content defining verification logic, wherein the first human-readable content and the second human-readable content are formatted according to a core definition language.

[0198] Example 62: The computing device according to Example 59, wherein the runtime component comprises an interpreter component, the runtime component applies navigation logic, and the interpreter component executes a navigation mode component.

[0199] Example 63: The computing device according to Example 61, wherein the runtime component comprises an interpreter component, and the application of branch logic or verification logic is performed by the interpreter component directly in the core definition language.

[0200] Example 64: The computing device described in Example 51, wherein prompt response data is formatted according to JavaScript Object Notation (JSON).

[0201] Example 65: The computing device described in Example 62, wherein the navigation response data is formatted according to JavaScript Object Notation (JSON).

[0202] Example 66: The computing device according to Example 62, wherein a processor executable instruction causes the computing device to receive data defining layout logic configured for a combination of interactive electronic documents, specific natural language, and specific visualization resources, formatted according to a code-defining language, in response to further execution.

[0203] Example 67: The computing device according to Example 59, wherein the computing device comprises a library of user interface (UI) elements, each including at least one presentation element and at least one control element, and instructing the presentation component to draw the UI includes passing data defining layout logic to the presentation component for interpretation by the library of UI elements.

[0204] Example 68: A computing device according to Example 67, wherein the display component renders a UI on a display device, which at runtime includes retrieving UI elements from a library of UI elements and supplying one or more UI elements to be included in a defined layout of an area within the UI.

[0205] It should be understood that the methods and systems described herein are not limited to any specific operation, process, component, or structure described, nor are they limited to any sequence or specific combination of such operation or component. It should also be understood that the terms used herein are for illustrative purposes only and are not intended to be restrictive or limiting.

[0206] Where used herein, the singular forms “a,” “an,” and “the” include both singular and plural referents unless explicitly indicated otherwise by the context. Values ​​expressed as approximations by the use of antecedents such as “about” or “approximately” shall include a reasonable variation from the reference value. Where such an approximation is included in a range, not only the endpoints but also the size of the range shall be considered an approximation. Enumerations should be considered illustrative and shall not be limited or restricted to the elements constituting the enumeration or the order in which the elements are listed, unless explicitly indicated otherwise by the context.

[0207] Throughout the specification and claims of this disclosure, the following terms have their given meanings: “comprise,” and variations such as “comprising” and “comprises,” mean, for example, to include, but not to include, other adjoins, components, elements, or actions, and are not intended to exclude them. “include,” and variations such as “including,” mean to be limited or restricted to what is indicated as to be included, and are not intended to exclude what is not indicated. “may,” means permissible but not restrictive or limiting. “Optional” or “optionally,” means that may or may not be included without altering the result or what is described. “prefer,” and variations such as “preferred” or “preferably,” mean illustrative and more ideal but not required. “etc,” means that merely serves as an example.

[0208] The actions and components described herein for use in performing the disclosed methods and constructing the disclosed systems are illustrative unless the context expressly indicates otherwise. When combinations, subsets, interactions, groups, etc., of these actions and components are disclosed, specific references to each of the various individual and collective combinations and permutations of these may not be expressly disclosed, but each should be understood to be specifically intended and described herein for all methods and systems. This applies to all aspects of this application, including, but not limited to, actions in the disclosed methods and / or components disclosed in the systems. Therefore, where there are various additional actions that can be performed or components that can be added, it should be understood that each of these additional actions can be performed and components can be added in any particular embodiment or combination of embodiments of the disclosed systems and methods.

[0209] Embodiments of this disclosure may take the form of entirely hardware embodiments, entirely software embodiments, or embodiments combining software and hardware aspects. Furthermore, methods and systems may take the form of computer program products on a computer-readable storage medium having computer-readable program instructions (e.g., computer software) embodied on the storage medium. Any suitable computer-readable storage medium, including hard disks, CD-ROMs, optical storage devices, or magnetic storage devices, may be used internally, networked, or cloud-based.

[0210] Embodiments of this disclosure are described with reference to diagrams, flowcharts, and other illustrative diagrams of computer methods, systems, devices, and computer program products. Each block in the block diagrams and flowcharts, and each combination of blocks in the block diagrams and flowcharts, may be implemented by processor-accessible instructions. Such instructions may include, for example, computer program instructions (e.g., processor-readable and / or processor-executable instructions). Processor-accessible instructions may be built (e.g., linked and compiled) and stored in a processor-executable form in one or more memory devices or one or more other processor-accessible non-temporary storage media. These computer program instructions (built or otherwise) may be loaded into a general-purpose computer, a dedicated computer, or other programmable data processing device to generate a machine. Loaded computer program instructions may be accessed and executed by one or more processors or other types of processing circuits. In response to execution, loaded computer program instructions provide functionality described in relation to flowchart blocks (individually or in particular combinations) or blocks in block diagrams (individually or in particular combinations). Therefore, such instructions executed on a computer or other programmable data processing device create means for implementing functions specified in blocks of a flowchart (individually or in specific combinations) or in blocks of a block diagram (individually or in specific combinations).

[0211] These computer program instructions may also be stored in computer-readable memory, which can instruct a computer or other programmable data processing device to function in a particular manner, thereby generating a product containing processor-accessible instructions (e.g., processor-readable instructions and / or processor-executable instructions) for performing functions specified in flowchart blocks (individually or in specific combinations) or in blocks in block diagrams (individually or in specific combinations). Computer program instructions (built or otherwise) may also be loaded into a computer or other programmable data processing device to perform a series of operations on the computer or other programmable device, thereby generating a process executed on the computer. A series of operations may be performed in response to execution by one or more processors or other types of processing circuits. Thus, such instructions executed on a computer or other programmable device provide operations for implementing functions specified in flowchart blocks (individually or in specific combinations) or in blocks in block diagrams (individually or in specific combinations).

[0212] Therefore, the blocks in block diagrams and flowchart examples support combinations of means for performing specified functions related to such diagrams and / or flowchart examples, combinations of operations for performing specified functions, and program instruction means for performing specified functions. Each block in block diagrams and flowchart examples, as well as combinations of blocks in block diagrams and flowchart examples, may be implemented by a dedicated hardware-based system that performs the specified functions or operations, or combinations, of dedicated hardware and computer instructions.

[0213] As used herein and in the accompanying drawings, terms such as “module,” “component,” “system,” and “platform” may refer to and / or include computer-related entities or entities related to an operating machine having one or more inherent functionalities. Such entities may be hardware, a combination of hardware and software, software (e.g., program code or executable program code), or running software. In one example, a component may be a processor, an object, an executable file (e.g., binary software), an execution thread, a computer program, and / or a process running on a computing device. For illustrative purposes only, a software application running on a server device may be a component, and the server device may also be a component. One or more modules may reside within a process and / or an execution thread. One or more components may also reside within a process and / or an execution thread. Each module and component may be localized on one computing device and / or distributed across two or more computing devices. In another example, each component (or module) may run from various computer-readable storage media having various stored data structures. A component (or module) can communicate via local and / or remote processes, such as by following a signal with one or more data packets (e.g., data from one component interacting with other systems via a signal, within a local system, within a distributed system, and / or via a network such as the Internet). As another example, in some cases, a component can emulate an electronic component via a virtual machine, for example, within a cloud computing system. The terms “module” and “component” (and their multiple versions) may be used interchangeably in some cases where the context makes it clear.

[0214] As used herein and in the accompanying drawings, the term “processor” can refer to substantially any computing processing unit or computing device, including single-core processors, single processors with software multithreading capability, multi-core processors, multi-core processors with software multithreading capability, multi-core processors with hardware multithreading technology, parallel platforms, and parallel platforms with distributed shared memory. Additionally, a processor can refer to electronic circuits designed and assembled to execute code instructions and / or manipulate data and signaling. Such electronic circuits may be integrated, for example, into a chipset. Thus, in some cases, a processor can be embodied or include application-specific integrated circuits (ASICs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs), complex programmable logic devices (CPLDs), discrete gate or transistor logic, discrete hardware components, or any combination thereof designed and assembled to perform the functionalities described herein. Furthermore, in some cases, a processor can leverage nanoscale architectures, such as molecular and quantum dot-based transistors, switches, and gates, to optimize space use or enhance the performance of the computing device. A processor can also be implemented as a combination of computing processing units.

[0215] Furthermore, in this specification and the accompanying drawings, terms such as “storage,” “data storage,” “repository,” and substantially any other information storage component relating to the operation and functionality of a system, subsystem, module, and component are used to refer to entities or components containing memory that are embodied in “memory component,” “memory.” As described herein, the memory and / or memory components of this disclosure may be either volatile memory or non-volatile memory, or may include both volatile and non-volatile memory. For illustrative purposes only, non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), flash memory, or non-volatile random-access memory (RAM) (e.g., ferroelectric RAM (FeRAM)). Volatile memory may include RAM that can act as external cache memory, for example. As an example rather than an limitation, RAM is available in many forms, including synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), extended SDRAM (ESDRAM), sync-link DRAM (SLDRAM), direct Rambus (DRRAM), direct Rambus dynamic RAM (DRDRAM), and Rambus dynamic RAM (RDRAM). Embodiments of this disclosure are not limited to these types of memory, and other types of memory devices may be envisioned.

[0216] Methods, apparatus, devices, and systems may employ artificial intelligence techniques such as machine learning and iterative learning. Examples of such techniques include, but are not limited to, expert systems, case-based reasoning, Bayesian networks, behavior-based AI, neural networks, fuzzy systems, evolutionary computation (e.g., genetic algorithms), swarm intelligence (e.g., Ant algorithms), and hybrid intelligent systems (e.g., expert reasoning rules generated through neural networks, or rules generated from statistical learning).

[0217] While computer-based methods, apparatuses, devices, and systems are described in relation to preferred embodiments and specific examples, the embodiments described herein are intended in all respects to be illustrative rather than restrictive, and therefore the scope is not intended to be limited to the specific embodiments described.

[0218] Unless otherwise expressly stated, no method described herein is ever intended to be construed as requiring its actions to be performed in a particular order. Therefore, if a claim for a method does not actually list the order in which its actions are performed, or if the claims or specification does not specifically state that the actions should be limited to a particular order, no order is ever intended to be inferred in any way. This is reserved for any possible implicit grounds for interpretation, including the arrangement of actions or action flows, the obvious meaning arising from grammatical structure or punctuation, and logical matters relating to the number or type of embodiments described in the specification.

[0219] It will be apparent to those skilled in the art that various modifications and variations can be made without departing from the scope or spirit. Other embodiments will also be apparent to those skilled in the art from the considerations of this specification and the practices disclosed herein. The specification and examples are for illustrative purposes only, and the true scope and spirit are intended to be indicated by the following claims.

Claims

1. A computing device, A computer comprises at least one processor that executes a computer executable component stored in at least one memory device, and the computer executable component is A configuration package is configured to acquire a configuration package, the configuration package including: (i) a definition configuration file that defines a definition configuration that is involved in the configuration of a set of views and branching logic, navigation logic, and validation logic associated with the set of views, (ii) a translation configuration file that defines the configuration of a translation configuration that is involved in the consumption of the set of views in a desired natural language, and (iii) a layout configuration file that defines a layout configuration that is involved in the configuration of the layout of UI elements, wherein each of the definition configuration file, the translation configuration file, and the layout configuration file includes human-readable text data. A runtime component configured to obtain the definition configuration file and apply the navigation logic corresponding to the navigation mode for the set of views, wherein each view of the set of views includes its respective prompt, A computing device comprising: a coordination component that implements translation logic and layout logic, and is configured to cause the presentation of at least one view of the set of views in response to the runtime component applying the navigation logic.

2. The computing device according to claim 1, wherein the computer executable component further comprises a presentation component configured to draw user interfaces corresponding to the at least one view.

3. The computing device according to claim 1, wherein the runtime component includes a runtime interface that functionally connects the runtime component to the coordination component.

4. The computing device according to claim 1, wherein the series of views represent an interactive electronic document, and the navigation mode defines the mode of traversal of the interactive electronic document.

5. The computing device according to claim 4, wherein the navigation mode corresponds to linear mode, hub-and-spoke mode, or computer adaptive testing (CAT) mode.

6. The computing device according to claim 4, wherein the interactive electronic document includes a questionnaire corresponding to one of the following: clinical outcome assessment, triage assessment, neuropsychological assessment, college aptitude assessment, vocational assessment, professional certification assessment, survey, or independent task guide.

7. The computing device according to claim 1, wherein the series of views represents a consent document, a privacy practices document, or a waiver consent document.

8. The computing device according to claim 1, wherein causing the presentation of at least one of the series of views is to implement the layout logic in response to the runtime component applying the navigation logic, the layout logic being implemented to correspond to two or more specific combinations of a unique computing device, natural language, or a user interface (UI) toolkit.

9. The system further comprises a library of user interface (UI) elements, each including at least one presentation element and at least one control element, and the layout logic is implemented as follows: Obtaining UI elements from the UI element library via the first interface, The computing device according to claim 8, comprising supplying one or more UI elements to be included in a defined layout of an area in a first user interface corresponding to a view among the at least one of the views.

10. The computing device according to claim 1, wherein the runtime component is further configured to apply at least one of the branch logic or the verification logic based on input data that responds to a first prompt in a first view of the at least one of the views.

11. The computing device according to claim 1, wherein the coordination component is further configured to implement the translation logic for a first view of the at least one view.

12. Implementing the aforementioned translation logic For a specific view among the at least one of the aforementioned views, it is determined that the translation rule is satisfied. The computing device according to claim 11, comprising translating a first natural language statement presented in a first natural language within a particular view into a second natural language statement in a second natural language.

13. A method that is performed on a computer, Obtaining a configuration package from a computing device that includes (i) a definition configuration file defining definition modes involved in the configuration of a set of views and various logic associated with the set of views, (ii) a translation configuration file defining the configuration of translation modes involved in the consumption of the set of views in a desired natural language, and (iii) a layout configuration file defining layout modes involved in the configuration of the layout of UI elements, wherein each of the definition configuration file, the translation configuration file, and the layout configuration file contains human-readable text data and is separated from each other. Presenting a user interface (UI) corresponding to a view in a series of views during the execution of an application that traverses a series of views of an interactive electronic document based on current state data, wherein the UI includes a prompting element and at least one navigation control element. The coordination component of the application receives prompt response data in response to the prompt from the presentation component of the application, The coordination component transmits the prompt response data to the application's runtime component, wherein the coordination component is configured to implement translation logic and layout logic, and the runtime component is configured to obtain the definition configuration file and navigation logic, and the definition configuration file includes definition data that defines at least one of branch logic or validation logic. The runtime component applies at least one of the branch logic or the verification logic to the prompt response data and the current state data, resulting in the following state data: The runtime component applies navigation logic to the current state data, A method performed by a computer, which includes presenting a second UI corresponding to a second view of a series of views based on the following state data in response to applying the navigation logic, wherein the second UI includes a second prompt and at least one second navigation control element.

14. The coordination component receives navigation response data from the presentation component corresponding to the selection of a specific navigation control among the at least one second navigation control, The coordination component transmits the navigation response data to the runtime component, The runtime component applies navigation logic to the following state data, A method performed on a computer according to claim 13, further comprising presenting a third UI corresponding to a third view of the series of views based on the following state data in response to applying the navigation logic.

15. Presenting the aforementioned UI is The coordination component obtains data defining the prompt from the runtime component, The coordination component instructs the presentation component to draw the UI, A method performed on a computer according to claim 13, comprising rendering the UI on a display device using the presenting component.

16. A method performed on a computer according to claim 13, which involves obtaining the navigation logic by having the runtime component receive a group of rules corresponding to a navigation mode that defines the traversal patterns of the series of views, further comprising obtaining the group of rules in a native format for a rule library included in the runtime component.

17. The method executed on a computer according to claim 13, further comprising obtaining the branch logic and the verification logic by the runtime component.

18. The runtime component can obtain the branch logic and the verification logic, Receiving a first human-readable content defining the branching logic and a second human-readable content defining the verification logic, wherein the first human-readable content and the second human-readable content are formatted according to the core definition language. A method performed on a computer according to claim 17, comprising converting the branch logic and the verification logic into a second group of rules formatted according to the native format.

19. The method executed on a computer according to claim 17, wherein the runtime component includes a rule component, and the application of the navigation logic, the branching logic, or the verification logic by the runtime component includes the application of one or more specific rules from a group of rules or specific rules from a second group of rules by the rule component.

20. The computer-based method according to claim 13, further comprising obtaining the navigation logic by selecting a navigation mode component that defines a navigation mode corresponding to a navigation mode that defines the manner of traversal of the series of views, using the runtime component.

21. The method executed on a computer according to claim 20, further comprising obtaining the branch logic and the verification logic by the runtime component.

22. The method performed on a computer according to claim 21, wherein the runtime component obtains the branch logic and the verification logic, which includes receiving a first human-readable content defining the branch logic and a second human-readable content defining the verification logic, wherein the first human-readable content and the second human-readable content are formatted according to a core definition language.

23. The method performed on a computer according to claim 20, wherein the runtime component comprises an interpreter component, and the execution of the navigation mode component by the runtime component includes applying the navigation logic by the interpreter component.

24. The method executed on a computer according to claim 22, wherein the runtime component comprises an interpreter component, and the application of the branch logic or the verification logic includes the interpreter component directly applying the branch logic or the verification logic in the core definition language.

25. The method executed on a computer according to claim 13, wherein the prompt response data is formatted according to JavaScript Object Notation (JSON).

26. The method executed on a computer according to claim 14, wherein the navigation response data is formatted according to JavaScript Object Notation (JSON).

27. A method performed on a computer according to claim 14, further comprising receiving data that defines the layout logic configured for a combination of the interactive electronic document, a particular natural language, and a particular visualization resource, wherein the data is formatted according to a core definition language.

28. A computer-based method according to claim 15, further comprising a library of user interface (UI) elements, each including at least one presentation element and at least one control element, wherein the instruction to the presentation component to draw the UI includes passing the data defining the layout logic to the presentation component for interpretation by the library of UI elements.

29. The display component enables the rendering of the UI on the display device. At runtime, the UI elements are obtained from the UI element library, A method performed on a computer according to claim 28, comprising supplying one or more UI elements to be included in a defined layout of an area within the UI.

30. The method executed on a computer according to claim 29, wherein the UI element is configured according to one or more visualization resources of the display device, and the one or more visualization resources are defined by the layout logic, including the graphic resolution and the size of the visualization area.

31. Receiving data that defines the translation logic, A method performed on a computer according to claim 14, further comprising applying the translation logic to the data defining the prompt.

32. At least one non-temporary computer-readable storage medium having processor-executable instructions encoded on the at least one non-temporary computer-readable storage medium, wherein the processor-executable instructions, in response to execution, cause a computing device to perform the method according to any one of claims 13 to 31.

33. A method that is performed on a computer, To provide the translator device with access to an editing service that enables the configuration of a translation configuration file corresponding to the desired natural language, Receiving a request for the translation configuration file from the translator device, The computing device retrieves from a data repository the following configuration packages: (i) a definition configuration file that defines definition modes involved in the configuration of a set of views and the logic associated with the set of views; (ii) a translation configuration file that defines the configuration of translation modes involved in the consumption of the set of views in a desired natural language; and (iii) a layout configuration file that defines layout modes involved in the configuration of the layout of UI elements, wherein each of the definition configuration file, the translation configuration file, and the layout configuration file contains human-readable text data and is separated from each other. In the aforementioned translation device, the presenting of a user interface, wherein the user interface enables viewing and editing of human-readable text defined by translation data corresponding to the translation configuration file, Receiving update data from the translator device that defines a sufficient translation of a portion of the human-readable text, A method performed on a computer, comprising generating a second translation configuration file in the data repository, based on the update data, that corresponds to an updated version of the translation configuration file.

34. To generate a screen capture image of the interactive electronic document associated with the updated version of the translation configuration file, A method performed on a computer according to claim 33, further comprising transmitting the screen capture image to the translator device.

35. The method performed on a computer according to claim 34, further comprising receiving an indicator of acceptance of translation contained in the screen capture image.

36. The method performed on a computer according to claim 34, further comprising receiving from the translator device second update data defining a second sufficient translation of the portion of the human-readable text in response to a rejection of the translation contained in the screen capture image.

37. The computer-based method according to claim 33, wherein the human-readable text comprises a unique code that identifies a text entry in the translation configuration file, a first text in a first natural language corresponding to the text entry, and a second text in a desired natural language corresponding to the text entry, the second text serving as a placeholder for the translation of the first text into the desired natural language.

38. Providing access The translation device receives the login credentials, A method performed on a computer according to claim 33, comprising authenticating and authorizing the translator device to access the editing service based on the login credentials.

39. A computing device, One or more processors, A computing device comprising: one or more memory devices that store computer-executable instructions causing the computing device to perform the method according to any one of claims 33 to 38 in response to execution by the one or more processors.

40. A method that is performed on a computer, Obtaining from a data repository a translation configuration file corresponding to a desired natural language, and a configuration package including (i) a definition configuration file defining definition modes involved in the configuration of a set of views and the logic associated with the set of views, (ii) a translation configuration file defining the configuration of translation modes involved in the consumption of the set of views in the desired natural language, and (iii) a layout configuration file defining layout modes involved in the configuration of the layout of UI elements, wherein each of the definition configuration file, the translation configuration file, and the layout configuration file contains human-readable text data and is separated from each other. The process involves converting the translation configuration file into a translator file configured to be operated by a translator device, wherein the translator file includes the translation data present in the translation configuration file. Sending the translation file to the translation device, The translator device receives a second translator file containing update data that defines updates to the translation data, A method performed on a computer, comprising converting the second translator file into a second translation configuration file corresponding to the desired natural language.

41. To generate a screen capture image of the interactive electronic document associated with the second translation configuration file, The method performed on a computer according to claim 40, further comprising transmitting the screen capture image to the translator device.

42. The method performed on a computer according to claim 41, further comprising receiving an indicator of acceptance of translation contained in the screen capture image.

43. The method performed on a computer according to claim 41, further comprising receiving a third translator file from the translator device containing update data defining a second update to the translation data in response to a rejection of translation included in the screen capture image.

44. The method executed on a computer according to claim 40, wherein the translator file is formatted according to a defined format accessible by the translator device.

45. A method performed on a computer according to claim 40, further comprising generating a third translation configuration file configured for a defined computing device and a defined user interface (UI) toolkit.

46. A computing device, One or more processors, A computing device comprising: one or more memory devices that store computer executable instructions causing the computing device to perform the method according to any one of claims 40 to 45 in response to execution by the one or more processors.

47. A method that is performed on a computer, Receiving first input data that defines a definition configuration file corresponding to an interactive electronic document, wherein the definition configuration file defines definitions involved in the configuration of a series of views and logic associated with the series of views, Using the first input data, generate the definition configuration file in the data repository, Receiving second input data that defines one or more translation configuration files corresponding to the interactive electronic document, wherein the one or more translation configuration files define translation modes involved in the consumption of the series of views in a desired natural language, Using the second input data, generate the translation configuration file in the data repository, Receiving third input data that defines one or more layout configuration files corresponding to the aforementioned interactive electronic document, wherein the one or more layout configuration files define layout configurations involved in the configuration of the layout of UI elements, Using the third input data, generate the layout configuration file in the data repository, A method performed on a computer, comprising generating a configuration package in the data repository, the configuration package containing the definition configuration file, a specific translation configuration file from among the one or more translation configuration files, and a specific layout configuration file from among the one or more layout configuration files, wherein the definition configuration file, the specific translation configuration file, and the specific layout configuration file are separated from each other and contain human-readable text data.

48. Receiving requests from a computing device for the interactive electronic document, natural language, and specific combinations of device type and display resolution, A method performed on a computer according to claim 47, further comprising determining that a second configuration package in the data repository satisfies the requirement, wherein the second configuration package includes a specific definition configuration file corresponding to the interactive electronic document, one or more second translation configuration files, and one or more second layout configuration files.

49. The method further includes generating a deliverable configuration package by extracting the specific definition configuration file, the specific translation configuration file from the one or more second translation configuration files, and the specific layout configuration file from the one or more second layout configuration files from the second configuration package based on the aforementioned requirements. The aforementioned specific configuration file corresponds to the natural language, The method executed on a computer according to claim 48, wherein the specific layout configuration file corresponds to the type of device and the display resolution.

50. The method performed on a computer according to claim 49, further comprising transmitting the deliverable configuration package to the computing device.

51. The extraction described above is Identifying a specific layout configuration file by analyzing the language indicating the device type and the display resolution within each of the one or more second layout configuration files, Determining the references within the aforementioned specific layout configuration file to the aforementioned specific translation configuration file, A method performed on a computer according to claim 49, comprising determining a reference in the specific translation configuration file to the specific definition configuration file.

52. The above-mentioned definition configuration file is generated as described above. To generate a unique identifier, A method performed on a computer according to claim 47, comprising incorporating the unique identifier into the definition configuration file.

53. The above translation configuration file is generated as described above. To generate a unique identifier, A method performed on a computer according to claim 47, comprising incorporating the unique identifier into the translation configuration file.

54. The above-mentioned layout configuration file is generated as described above. To generate a unique identifier, A method performed on a computer according to claim 47, comprising incorporating the unique identifier into the layout configuration file.

55. The computer-executed method according to claim 47, further defining a version of a runtime bundle for use with the third input data together with a configuration package including the layout configuration file.

56. The method executed on a computer according to claim 55, further comprising applying one or more integrity tests to the layout configuration file for one or more versions of the user interface library corresponding to the version of the runtime bundle.

57. A computing device, One or more processors, A computing device comprising: one or more memory devices that store computer-executable instructions causing the computing device to perform the method according to any one of claims 47 to 56 in response to execution by the one or more processors.

58. At least one non-temporary computer-readable storage medium having processor-executable instructions encoded on the at least one non-temporary computer-readable storage medium, wherein the processor-executable instructions, in response to execution, cause a computing device to perform the method according to any one of claims 47 to 56.

59. A method that is performed on a computer, Updating the status of a configuration file to unverified, wherein the configuration file relates to a configuration package corresponding to an interactive electronic document, and the configuration package includes (i) a definition configuration file that defines definition modes involved in the configuration of a set of views and the logic associated with the set of views, (ii) a translation configuration file that defines the configuration of translation modes involved in the consumption of the set of views in a desired natural language, and (iii) a layout configuration file that defines layout modes involved in the configuration of the layout of UI elements, and each of the definition configuration file, the translation configuration file, and the layout configuration file contains human-readable text data and is separated from each other, This causes the presentation of a listing of a second configuration file, including the aforementioned configuration file, where each configuration file of the second configuration file is classified as unverified and associated with the configuration package, The system receives input data indicating the selection of the aforementioned configuration file, This causes the aforementioned configuration file to be updated, resulting in the updated configuration file. Applying verification tests to the updated configuration file, wherein the verification tests are specific to the type of configuration file, Based on the application of the verification test, it is determined that the updated configuration file has been verified, A method performed on a computer, which includes adding the verified updated configuration file to the configuration package.

60. The method performed on a computer according to claim 59, further comprising classifying the verified updated configuration file as a verified configuration file.

61. The aforementioned update Determining that the aforementioned configuration file has been modified, Identifying the configuration package which includes the aforementioned configuration file, Determining that the second configuration file depends on the configuration file, A method performed on a computer according to claim 59, comprising classifying the second configuration file as an unverified configuration file.

62. The configuration file constitutes the definition form of the interactive electronic document, and the verification test is applied as described above. Execute at least one of either a no-code script or a low-code script, A method performed on a computer according to claim 59, comprising: automatically determining, in response to the aforementioned execution, a sufficient implementation of one or more logical statements or logical formulas.

63. The method executed on a computer according to claim 62, wherein each of the no-code script and the low-code script emulates an end-user response to one or more prompts defined in the configuration file.

64. The method performed on a computer according to claim 59, wherein the configuration file constitutes the translation mode of the interactive electronic document, and the application of the verification test includes applying a machine learning model for determining the validity or invalidity of the configuration file.

65. The machine learning model is a generative adversarial neural network (GANN), and applying the machine learning model is Using the GANN, determine the translation of text from a first natural language to a second natural language, by determining that the text corresponds to a natural language statement in the first natural language, and that the natural language statement is part of a prompt in the interactive electronic document. A computer-based method according to claim 64, comprising: using the GANN to determine the back translation of the determined text from the second natural language to the first natural language, and determining that an error exists in the translation of the text by comparing the back translation with the natural language statement.

66. The aforementioned configuration file constitutes the layout of the interactive electronic document, and the verification test is applied as described above. Applying one or more geometric conditions to the aforementioned configuration file to define sufficient visualization output, A method performed on a computer according to claim 59, comprising determining that one or more user interface elements rendered on a display device satisfy at least one of the one or more geometric conditions.

67. A computing device, One or more processors, A computing device comprising: one or more memory devices that store computer executable instructions causing the computing device to perform the method according to any one of claims 59 to 66 in response to execution by the one or more processors.

68. At least one non-temporary computer-readable storage medium having processor-executable instructions encoded on the at least one non-temporary computer-readable storage medium, wherein the processor-executable instructions, in response to execution, cause a computing device to perform the method according to any one of claims 59 to 66.

Images