chore: update external content [CI skip]

Author: github-actions[bot]

external_docs/make/userinteraction/useronboarding/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "User onboarding",
+  "position": 10,
+  "link": {
+    "type": "generated-index"
+  }
+}

external_docs/make/userinteraction/useronboarding/guiderecorder.md

@@ -0,0 +1,67 @@
+---
+sidebar_position: 40
+title: Guide recorder
+---
+
+# Guide Recorder
+
+## What is Guide recorder?
+
+In Simplicité [version 6.3](/versions/release-notes/v6-3), **Guide Recorder** is a helper tool to build a guide tour directly while navigating the UI.  
+
+It allows guide creators to **capture each step of a guide**, define instructions, and configure actions interactively.  
+
+
+## How to Access Guide Recorder
+
+Access to **Guide Recorder** is restricted:  
+
+- Users must have the `GUIDE_MAKER` responsibility.  
+- Users must have read access to the **DomainSocialUser** domain.  
+
+Without domain access, Guide Recorder will not be visible, even if the user has the `GUIDE_MAKER` responsibility.  
+
+The menu can be found under **User Interaction > User Onboarding** in the application.    
+
+![](img/useronboarding/guiderecorder.png)  
+
+## Guide Recorder Usage
+
+To create a guide using Guide Recorder:
+
+1. **Navigate to the target screen** where you want to start the guide.  
+2. **Activate Guide Recorder** from the menu.  
+3. For each step in the guide:  
+   - **Right-click** on the UI element you want to highlight.  
+   - **Enter the step details** in the dialog that appears:   
+     - **Step name** – The internal name of the step, used to identify it within the guide. Keep it short and descriptive (e.g., "Login Button").  
+     - **Tooltip short title** – A brief title shown in the tooltip to summarize the step for the user. Usually one line (e.g., "Click to log in").  
+     - **Tooltip long info** – Detailed instructions or explanations displayed in the tooltip. Provide context, guidance, or warnings (e.g., "Click this button to access your dashboard after entering your credentials.").  
+     - **Selector** – The CSS or UI element selector that identifies the target element for the step. This is usually captured automatically but can be adjusted if needed.  
+     - **Position** – The placement of the tooltip relative to the target element. Options: `top`, `bottom`, `left`, `right`. Choose a position that is clearly visible.  
+     - **Next event** – Defines what happens after the step is completed. Options include "Click", "Input Text", "Navigate to page", or "Wait for user interaction". Controls the flow to the next step.  
+
+     ![](img/useronboarding/guiderecorder2.png)    
+4. **Repeat the process** for every step of the guide.  
+5. **Save the guide** once all steps are captured.  
+
+### Tips for Effective Guides
+
+- Keep instructions **concise and clear**.  
+- Highlight only **necessary elements** to avoid clutter.  
+- Test the guide in **preview mode** to ensure steps execute correctly.  
+
+## Managing Guides
+
+After recording steps:
+
+- **Edit Steps** – modify titles, descriptions, or actions if needed.  
+- **Reorder Steps** – change the sequence of the guide if necessary.  
+- **Preview the Guide** – simulate the guide as an end-user to verify clarity.  
+- **Publish** – make the guide available to end-users.  
+
+
+
+
+
+

external_docs/make/userinteraction/useronboarding/guidesusage.md

@@ -0,0 +1,61 @@
+---
+sidebar_position: 30
+title: Guides Usage
+---
+
+# Guides Usage
+
+## What is Guides Usage?
+
+In Simplicité [version 6.3](/versions/release-notes/v6-3), **Guides Usage** provides visibility into how onboarding guides are actually used by end-users.  
+
+It tracks **who played a guide, when, and how far they went**, and aggregates this data into **[pivot tables](/make/userinterface/objectsrendering/pivot-table)** for managers or administrators.  
+
+With Guides Usage, you can:
+- Measure **adoption of guides** after a release.  
+- Track **completion rates**.  
+- Identify **inactive users**.  
+- Compare usage across **dates, users, and guides**.  
+
+
+## How to Access Guides Usage?
+
+Access to **Guides Usage** is restricted:  
+
+- Users must have the `GUIDE_MAKER` responsibility.  
+- They must also have read access to the **DomainSocialUser** domain.  
+
+Without this domain access, the usage data (user names, logins, history) will not be visible, even if the user has the `GUIDE_MAKER` responsibility.  
+ 
+The menu is available from **User interaction > User onboarding** in the application navigation.  
+
+
+## Guides Usage List
+
+The list displays **tracking events** for each guide launch:
+
+- **Date** – when the guide was played.  
+- **Guide Name** – identifier of the guide.  
+- **Guide Target Object** – the context where the guide was launched (e.g. a business object, dashboard...etc.).  
+- **User Login / User Name** – the user who played the guide.  
+- **Last Step** – last step reached (completed or interrupted).  
+
+
+## Guides Usage pivot tables 
+
+Beyond the list, **pivot table** summarize adoption.
+By monitoring Guides Usage, administrators and project managers can:
+- Ensure onboarding content is actually used.  
+- Validate whether guides **help reduce support requests**.  
+- Plan **updates to guides** if adoption is low.  
+
+### Metrics by User
+A **pivot table (User × Guide)** displays how many times each user played each guide.
+
+### Metrics by Date
+A **time-based pivot table** highlights period of activity, showing how often guides were used within a given timeframe (day, week, month).  
+
+
+
+
+

external_docs/make/userinteraction/useronboarding/img/useronboarding/guide.gif

@@ -0,0 +1,133 @@
+---
+sidebar_position: 20
+title: User guides
+---
+
+# User Guides
+
+## What is a User Guide?
+In Simplicité [version 6.3](/versions/release-notes/v6-3), a **User Guide** is an interactive tour designed to onboard users and help them understand how to use the application.  
+A guide can walk the user through various parts of the UI, highlighting steps, actions, and interactions.
+
+User Guides can be:
+- Launched from any **view**, **home page**, **business object**, **dahboard**, **Domain home** or **external object**.  
+- Restricted to a **limited period of availability**.  
+- Made visible only to **specific user groups**.  
+- Composed of multiple **steps**:
+  - On a single page.  
+  - Across several asynchronous pages or dialogs.  
+  - With required user interactions (clicking a button, completing a field, etc.).  
+
+With User Guides, Simplicité provides a structured, interactive way to onboard users and support application adoption.
+
+## How to Create a User Guide?
+
+### Accessing Guides
+Users with the `GUIDE_MAKER` responsibility gain access to the **Guides** menu, which includes:
+
+1. **User guides** – full definitions of guides with step settings and permissions.  
+2. **Guides usage** – tracking information (who used a guide and when).  
+3. **Guide recorder** – a helper tool to build a guide skeleton directly while navigating the UI.  
+
+### Creating a Guide
+1. Go to **User Interaction > User guides**.  
+2. Click **Create** a new Guide.  
+3. Define the following properties:
+   - **Name** – unique key for the guide.  
+   - **Module name** – the [module](/make/project/module) to which the guide belongs.  
+   - **Target object** – Simple view, home page, business object, dashboard, domain home or external object.  
+   - **Availability period** – optional start/end dates.  
+   - **Order** - defines the order of display when multiple guides are available.  
+   - **Auto launch** – automatically launches the guide when the user first accesses the target object.    
+   - **Tour settings** – advanced options such as display style, navigation controls, or steps.    
+
+4. Define **steps** for the guide:
+   - Page or dialog context.  
+   - Target element in the UI.  
+   - Step description/instruction.  
+   - Expected user interaction (click, input, validate, etc.).  
+
+5. Save the guide and test it in the UI.
+
+![](img/useronboarding/guide1.png)  
+### Creating a Tour
+A **Tour** is a structured JSON object that defines a guide with **steps**, **conditions**, and **exit behavior**.
+
+#### Structure of a Tour
+```js
+{
+    name: "GuideName",
+    condition: { ... },       // Launch conditions and access rules
+    steps: [ { ... }, ... ],  // List of guide steps
+    exitToast: { ... }        // Optional message at the end of the tour
+}
+```
+#### Launch Conditions
+The condition defines when and how the tour can be launched:
+- context - location in which the tour is launched.  
+- inst - instance name of the target object/view.  
+- access - function to check user permissions.  
+- init - optional logic to verify the page or elements are ready.  
+```js
+condition: {
+    context: "list",            // Launch context: "list", "form", etc.
+    inst: "the_ajax_Object",    // Technical instance name of the target object
+    access: function(ctn) {     // Optional access control function
+        return $grant.accessCreate("ObjectName") && $grant.accessUpdate("ObjectName");
+    },
+    init: function(ctn, tour) { // Optional initialization logic
+        // Example: check if a button exists before starting
+        let btn = $(".objlist.object-MyObject button[data-action='create']", ctn);
+        if (!btn.length) return null; // stop playing
+        return true; // ready to go
+    }
+}
+```
+#### Defining Steps
+Each step guides the user through an action or element:  
+- step - identifier for the step.  
+- title - multilingual step title.  
+- info - optional description text.  
+- attach - tooltip positioning and target element.  
+- next - how to proceed to the next step (event or condition).
+```js
+{
+    step: "step-id",
+    title: { FRA: "Titre", ENU: "Title" },
+    info: { FRA: "Description", ENU: "Description" },
+    attach: { pos: "bottom", align: "center", sel: "CSS selector" },
+    next: { event: "click", condition: function(ctn, obj, tour){ return true; } }
+}
+```
+#### Exit Message
+At the end of a tour, you can display an optional message:
+```js
+{
+exitToast: { FRA: "Merci et à bientôt !", ENU: "Thank you and see you soon!" }
+}
+```
+
+### Using the Guide Recorder
+The **Guide Recorder** (experimental feature) helps create a guide quickly:
+1. Run through the desired journey in the UI.  
+2. Right-click on elements you want to include as guide steps.  
+3. Simplicité generates a **guide skeleton** with generic DOM selectors.  
+4. Refine the guide:
+   - Adjust selectors for stability.  
+   - Add missing steps.  
+   - Define permissions.  
+
+The recorder provides a starting point; the guide designer must complete the setup for a functional onboarding tour.
+
+## How Users Access Guides
+
+### GUIDE_USER Responsibility
+End-users need the `GUIDE_USER` responsibility to access guides.  
+
+Guides can be:
+- **Automatically launched** (once per user).  
+- **Replayed** at any time with a button in the UI.  
+
+![](img/useronboarding/guide.gif)  
+
+