capacitor-gleap-plugin 19.0.0 → 19.1.0

package/CapacitorGleapPlugin.podspec

@@ -18,6 +18,6 @@ Pod::Spec.new do |s|
   s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
   s.ios.deployment_target = '15.0'
   s.dependency 'Capacitor'
-  s.dependency 'Gleap', '19.0.0'
+  s.dependency 'Gleap', '19.1.0'
   s.swift_version = '5.1'
 end

package/Package.swift

@@ -16,7 +16,7 @@ let package = Package(
         // Capacitor rewrites this to the app's Capacitor major version during `npx cap sync`.
         .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0"),
         // Native Gleap iOS SDK, released together with this plugin (same version).
-        .package(url: "https://github.com/GleapSDK/Gleap-iOS-SDK.git", from: "19.0.0")
+        .package(url: "https://github.com/GleapSDK/Gleap-iOS-SDK.git", from: "19.1.0")
     ],
     targets: [
         .target(

package/README.md

@@ -27,7 +27,7 @@ The plugin needs Capacitor 7 or later and an iOS deployment target of **15.0** o
 target 'App' do
   capacitor_pods
   # Add your Pods here
-  pod 'Gleap', :git => 'https://github.com/GleapSDK/Gleap-iOS-SDK.git', :tag => '19.0.0'
+  pod 'Gleap', :git => 'https://github.com/GleapSDK/Gleap-iOS-SDK.git', :tag => '19.1.0'
 end
 ```
 
@@ -82,6 +82,30 @@ await Gleap.setColorScheme({ colorScheme: isDarkTheme ? "dark" : "light", darkBa
 
 `setColorScheme` only takes effect when "Adapt to dark / light mode" is enabled in the Gleap dashboard; it then overrides the dashboard's color scheme. Before the first call the dashboard setting applies. In dark mode the widget uses the dark mode colors, logo, header image and composer glow set in the Gleap dashboard; without dark colors it keeps its normal colors. `lightBackgroundColor` / `darkBackgroundColor` override the background in light / dark mode. Can be called before or after `initialize`.
 
+## Protected conversation files
+
+With "Require authenticated file access" (Project settings → User identity), conversation files can only be opened by agents and by the verified customer the conversation belongs to. Identify the customer with a user hash (created on your server with the project's identity verification secret) on every app start:
+
+```typescript
+await Gleap.identify({ userId: "user-1", userHash: userHash, email: "jane@example.com" });
+```
+
+Email replies link attachments to your customer application URL with a `gleapFile` query parameter. If that URL opens your app (universal link / App Link), pass it to Gleap; the conversation opens once the customer is identified with a user hash:
+
+```typescript
+import { App } from "@capacitor/app";
+
+const launch = await App.getLaunchUrl();
+if (launch?.url) {
+  await Gleap.openProtectedFileFromUrl({ url: launch.url });
+}
+App.addListener("appUrlOpen", ({ url }) => {
+  Gleap.openProtectedFileFromUrl({ url });
+});
+```
+
+`openProtectedFileFromUrl` resolves `{ opened: false }` when the URL has no valid `gleapFile` parameter. On web the JavaScript SDK opens `?gleapFile=` links on page load by itself.
+
 ## API
 
 <docgen-index>
@@ -107,11 +131,13 @@ await Gleap.setColorScheme({ colorScheme: isDarkTheme ? "dark" : "light", darkBa
 * [`setNetworkLogPropsToIgnore(...)`](#setnetworklogpropstoignore)
 * [`attachNetworkLogs(...)`](#attachnetworklogs)
 * [`attachConsoleLogs(...)`](#attachconsolelogs)
+* [`logsFlushed(...)`](#logsflushed)
 * [`setEnvDataPropsToIgnore(...)`](#setenvdatapropstoignore)
 * [`registerAgentTool(...)`](#registeragenttool)
 * [`sendAgentToolResult(...)`](#sendagenttoolresult)
 * [`addListener('agentToolExecution', ...)`](#addlisteneragenttoolexecution-)
 * [`addListener('logConfigLoaded', ...)`](#addlistenerlogconfigloaded-)
+* [`addListener('flushLogs', ...)`](#addlistenerflushlogs-)
 * [`setTicketAttribute(...)`](#setticketattribute)
 * [`unsetTicketAttribute(...)`](#unsetticketattribute)
 * [`clearTicketAttributes()`](#clearticketattributes)
@@ -144,11 +170,14 @@ await Gleap.setColorScheme({ colorScheme: isDarkTheme ? "dark" : "light", darkBa
 * [`startConversation(...)`](#startconversation)
 * [`openConversation(...)`](#openconversation)
 * [`openConversations(...)`](#openconversations)
+* [`openProtectedFileFromUrl(...)`](#openprotectedfilefromurl)
 * [`startBot(...)`](#startbot)
 * [`showFeedbackButton(...)`](#showfeedbackbutton)
 * [`setDisableInAppNotifications(...)`](#setdisableinappnotifications)
 * [`setDisableEnvData(...)`](#setdisableenvdata)
 * [`setColorScheme(...)`](#setcolorscheme)
+* [`setCaptureEnabled(...)`](#setcaptureenabled)
+* [`setRemoteLogCollectionEnabled(...)`](#setremotelogcollectionenabled)
 * [`setLanguage(...)`](#setlanguage)
 * [`disableConsoleLogOverwrite()`](#disableconsolelogoverwrite)
 * [`enableDebugConsoleLog()`](#enabledebugconsolelog)
@@ -555,6 +584,25 @@ No-op on web, where the JavaScript SDK records the console itself.
 --------------------
 
 
+### logsFlushed(...)
+
+```typescript
+logsFlushed(options: { flushId: string; }) => Promise<void>
+```
+
+Answers a `flushLogs` event once the WebView console and network logs the plugin buffers were handed to the native
+SDK, so it collects the logs for a capture request with them. The plugin calls this for you on iOS and Android.
+No-op on web.
+
+| Param         | Type                              |
+| ------------- | --------------------------------- |
+| **`options`** | <code>{ flushId: string; }</code> |
+
+**Since:** 19.1.0
+
+--------------------
+
+
 ### setEnvDataPropsToIgnore(...)
 
 ```typescript
@@ -655,6 +703,28 @@ WebView log capture needs (network logs are only recorded when they are enabled
 --------------------
 
 
+### addListener('flushLogs', ...)
+
+```typescript
+addListener(eventName: 'flushLogs', listenerFunc: (data: { flushId: string; }) => void) => Promise<PluginListenerHandle>
+```
+
+Called on iOS and Android right before the native SDK collects the logs for a capture request: the plugin's
+WebView log capture hands over what it buffers (it pushes at most every 500 ms otherwise) and answers with
+`logsFlushed`. The native SDK waits at most 500 ms for the answer. The plugin listens for you.
+
+| Param              | Type                                                 |
+| ------------------ | ---------------------------------------------------- |
+| **`eventName`**    | <code>'flushLogs'</code>                             |
+| **`listenerFunc`** | <code>(data: { flushId: string; }) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+**Since:** 19.1.0
+
+--------------------
+
+
 ### setTicketAttribute(...)
 
 ```typescript
@@ -1237,6 +1307,32 @@ Opens the conversations tab (same as openConversation).
 --------------------
 
 
+### openProtectedFileFromUrl(...)
+
+```typescript
+openProtectedFileFromUrl(options: { url: string; }) => Promise<{ opened: boolean; }>
+```
+
+Open the conversation of a protected file from an emailed link.
+With "Require authenticated file access" enabled, email replies link attachments to your customer
+application URL with a `gleapFile` query parameter. If that URL opens your app (for example as a
+universal link / App Link), pass it here, e.g. from `App.addListener('appUrlOpen')` or
+`App.getLaunchUrl()` of `@capacitor/app`. `opened` is true when the URL carries a Gleap file reference.
+The conversation opens once the customer is identified with a user hash (`identify` with `userHash`);
+the link alone grants nothing. On web the JavaScript SDK handles `?gleapFile=` automatically on page load,
+so this resolves `{ opened: false }` there.
+
+| Param         | Type                          |
+| ------------- | ----------------------------- |
+| **`options`** | <code>{ url: string; }</code> |
+
+**Returns:** <code>Promise&lt;{ opened: boolean; }&gt;</code>
+
+**Since:** 19.0.1
+
+--------------------
+
+
 ### startBot(...)
 
 ```typescript
@@ -1341,6 +1437,53 @@ Can be called before or after initialize and applies live.
 --------------------
 
 
+### setCaptureEnabled(...)
+
+```typescript
+setCaptureEnabled(options: { enabled: boolean; }) => Promise<{ captureEnabled: boolean; }>
+```
+
+Enable or disable screenshots and screen recordings for capture requests: when a workflow, an AI agent or a
+teammate asks the user in the widget to show the issue, the widget steps aside, a small bar lets the user go to
+the right screen, and the SDK captures the app once they tap Capture (or records it between Start and Stop).
+Nothing is captured without that tap. While disabled, the widget only offers to upload a file.
+Enabled by default. Works on iOS, Android and web and can be called before or after initialize.
+
+| Param         | Type                               |
+| ------------- | ---------------------------------- |
+| **`options`** | <code>{ enabled: boolean; }</code> |
+
+**Returns:** <code>Promise&lt;{ captureEnabled: boolean; }&gt;</code>
+
+**Since:** 19.1.0
+
+--------------------
+
+
+### setRemoteLogCollectionEnabled(...)
+
+```typescript
+setRemoteLogCollectionEnabled(options: { enabled: boolean; }) => Promise<{ remoteLogCollectionEnabled: boolean; }>
+```
+
+Enable or disable sending the app's logs for capture requests: a workflow or an AI agent can ask for the logs
+while the app runs (no user action), and screenshots and recordings can bring the logs around them. The logs are
+what a bug report carries (console and network logs, custom data, env data, custom events; the replay only when
+it is asked for and enabled in the dashboard), and the existing settings still apply (e.g. setDisableEnvData).
+While disabled, log requests are answered as not supported and captures are sent without logs.
+Enabled by default. Works on iOS, Android and web and can be called before or after initialize.
+
+| Param         | Type                               |
+| ------------- | ---------------------------------- |
+| **`options`** | <code>{ enabled: boolean; }</code> |
+
+**Returns:** <code>Promise&lt;{ remoteLogCollectionEnabled: boolean; }&gt;</code>
+
+**Since:** 19.1.0
+
+--------------------
+
+
 ### setLanguage(...)
 
 ```typescript

package/android/build.gradle

@@ -55,5 +55,5 @@ dependencies {
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
-    implementation group: 'io.gleap', name: 'gleap-android-sdk', version: '19.0.0'
+    implementation group: 'io.gleap', name: 'gleap-android-sdk', version: '19.1.0'
 }

package/android/src/main/java/io/gleapplugins/capacitor/GleapPlugin.java

@@ -2,6 +2,8 @@ package io.gleapplugins.capacitor;
 
 import android.Manifest;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
@@ -12,6 +14,7 @@ import com.getcapacitor.annotation.CapacitorPlugin;
 import com.getcapacitor.annotation.Permission;
 import io.gleap.APPLICATIONTYPE;
 import io.gleap.Gleap;
+import io.gleap.GleapLogFlushHandler;
 import io.gleap.GleapLogLevel;
 import io.gleap.GleapNotInitialisedException;
 import io.gleap.GleapSessionProperties;
@@ -62,6 +65,12 @@ public class GleapPlugin extends Plugin {
     private volatile JSObject lastLogConfig;
     // Set by disableConsoleLogOverwrite: WebView console logs are no longer attached.
     private volatile boolean webViewConsoleLogsDisabled = false;
+    // Capture requests: log flushes the native SDK waits for (at most 500 ms) until the WebView log capture handed
+    // over what it buffers, by flush id.
+    private final Map<String, Runnable> pendingLogFlushes = new ConcurrentHashMap<>();
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    // An unanswered flush (e.g. the page reloaded) is forgotten after this; the SDK stopped waiting long before.
+    private static final long LOG_FLUSH_FORGET_MS = 1000;
 
     @Override
     public void load() {
@@ -119,6 +128,8 @@ public class GleapPlugin extends Plugin {
         // Set the application type
         Gleap.getInstance().setApplicationType(APPLICATIONTYPE.CAPACITOR);
 
+        registerLogFlushHandler();
+
         // A reloaded WebView calls initialize again: hand it the config that was already loaded.
         JSObject logConfig = lastLogConfig;
         if (logConfig != null) {
@@ -131,6 +142,76 @@ public class GleapPlugin extends Plugin {
         call.resolve(ret);
     }
 
+    /**
+     * Capture requests: before the native SDK collects the logs for a request, the WebView log capture hands over
+     * what it buffers (pushed at most every 500 ms otherwise). The SDK calls this on the main thread and waits at
+     * most 500 ms for done; without a flushLogs listener it does not wait.
+     */
+    private void registerLogFlushHandler() {
+        try {
+            implementation.setLogFlushHandler(
+                new GleapLogFlushHandler() {
+                    @Override
+                    public void onFlushRequested(Runnable done) {
+                        requestLogFlush(done);
+                    }
+                }
+            );
+        } catch (Exception | LinkageError ex) {
+            System.out.println(ex);
+        }
+    }
+
+    private void requestLogFlush(Runnable done) {
+        if (done == null) {
+            return;
+        }
+        if (!hasListeners("flushLogs")) {
+            done.run();
+            return;
+        }
+        final String flushId = UUID.randomUUID().toString();
+        pendingLogFlushes.put(flushId, done);
+        try {
+            JSObject data = new JSObject();
+            data.put("flushId", flushId);
+            notifyListeners("flushLogs", data);
+        } catch (Exception ex) {
+            finishLogFlush(flushId);
+            return;
+        }
+        mainHandler.postDelayed(
+            new Runnable() {
+                @Override
+                public void run() {
+                    pendingLogFlushes.remove(flushId);
+                }
+            },
+            LOG_FLUSH_FORGET_MS
+        );
+    }
+
+    private void finishLogFlush(String flushId) {
+        if (flushId == null) {
+            return;
+        }
+        Runnable done = pendingLogFlushes.remove(flushId);
+        if (done != null) {
+            try {
+                done.run();
+            } catch (Exception ignore) {}
+        }
+    }
+
+    /**
+     * The WebView log capture handed over what it buffered for the flush with this id.
+     */
+    @PluginMethod
+    public void logsFlushed(PluginCall call) {
+        finishLogFlush(call.getString("flushId"));
+        call.resolve();
+    }
+
     // Data region & host overrides. All of them must be called before initialize.
     @PluginMethod
     public void setRegion(PluginCall call) {
@@ -906,6 +987,50 @@ public class GleapPlugin extends Plugin {
         call.resolve(ret);
     }
 
+    /**
+     * Enables or disables screenshots and screen recordings for capture requests.
+     */
+    @PluginMethod
+    public void setCaptureEnabled(PluginCall call) {
+        Boolean enabled = call.getBoolean("enabled");
+        if (enabled == null) {
+            call.reject("No enabled value provided");
+            return;
+        }
+
+        try {
+            implementation.setCaptureEnabled(enabled);
+        } catch (Exception | LinkageError ex) {
+            System.out.println(ex);
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("captureEnabled", enabled);
+        call.resolve(ret);
+    }
+
+    /**
+     * Enables or disables sending the app's logs for capture requests.
+     */
+    @PluginMethod
+    public void setRemoteLogCollectionEnabled(PluginCall call) {
+        Boolean enabled = call.getBoolean("enabled");
+        if (enabled == null) {
+            call.reject("No enabled value provided");
+            return;
+        }
+
+        try {
+            implementation.setRemoteLogCollectionEnabled(enabled);
+        } catch (Exception | LinkageError ex) {
+            System.out.println(ex);
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("remoteLogCollectionEnabled", enabled);
+        call.resolve(ret);
+    }
+
     @PluginMethod
     public void showFeedbackButton(PluginCall call) {
         boolean show = call.getBoolean("show", false);
@@ -1260,6 +1385,24 @@ public class GleapPlugin extends Plugin {
         openConversations(call);
     }
 
+    // Emailed protected file link (gleapFile query parameter). The SDK opens the conversation
+    // once a verified identify (user hash) gave the session file access.
+    @PluginMethod
+    public void openProtectedFileFromUrl(PluginCall call) {
+        String url = call.getString("url");
+        if (url == null) {
+            call.reject("No url provided");
+            return;
+        }
+
+        boolean opened = implementation.openProtectedFileFromUrl(url);
+
+        // Build Json object and resolve success
+        JSObject ret = new JSObject();
+        ret.put("opened", opened);
+        call.resolve(ret);
+    }
+
     @PluginMethod
     public void startClassicForm(PluginCall call) throws GleapNotInitialisedException {
         if (!call.getData().has("formId")) {

package/dist/docs.json

@@ -436,6 +436,27 @@
         ],
         "slug": "attachconsolelogs"
       },
+      {
+        "name": "logsFlushed",
+        "signature": "(options: { flushId: string; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ flushId: string; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "19.1.0"
+          }
+        ],
+        "docs": "Answers a `flushLogs` event once the WebView console and network logs the plugin buffers were handed to the native\nSDK, so it collects the logs for a capture request with them. The plugin calls this for you on iOS and Android.\nNo-op on web.",
+        "complexTypes": [],
+        "slug": "logsflushed"
+      },
       {
         "name": "setEnvDataPropsToIgnore",
         "signature": "(options: { propsToIgnore: string[]; }) => Promise<{ envDataPropsToIgnoreSet: boolean; }>",
@@ -556,6 +577,34 @@
         ],
         "slug": "addlistenerlogconfigloaded-"
       },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'flushLogs', listenerFunc: (data: { flushId: string; }) => void) => Promise<PluginListenerHandle>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "'flushLogs'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "(data: { flushId: string; }) => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "19.1.0"
+          }
+        ],
+        "docs": "Called on iOS and Android right before the native SDK collects the logs for a capture request: the plugin's\nWebView log capture hands over what it buffers (it pushes at most every 500 ms otherwise) and answers with\n`logsFlushed`. The native SDK waits at most 500 ms for the answer. The plugin listens for you.",
+        "complexTypes": [
+          "PluginListenerHandle"
+        ],
+        "slug": "addlistenerflushlogs-"
+      },
       {
         "name": "setTicketAttribute",
         "signature": "(options: { key: string; value: string; }) => Promise<{ setTicketAttribute: boolean; }>",
@@ -1197,6 +1246,27 @@
         "complexTypes": [],
         "slug": "openconversations"
       },
+      {
+        "name": "openProtectedFileFromUrl",
+        "signature": "(options: { url: string; }) => Promise<{ opened: boolean; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ url: string; }"
+          }
+        ],
+        "returns": "Promise<{ opened: boolean; }>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "19.0.1"
+          }
+        ],
+        "docs": "Open the conversation of a protected file from an emailed link.\nWith \"Require authenticated file access\" enabled, email replies link attachments to your customer\napplication URL with a `gleapFile` query parameter. If that URL opens your app (for example as a\nuniversal link / App Link), pass it here, e.g. from `App.addListener('appUrlOpen')` or\n`App.getLaunchUrl()` of `@capacitor/app`. `opened` is true when the URL carries a Gleap file reference.\nThe conversation opens once the customer is identified with a user hash (`identify` with `userHash`);\nthe link alone grants nothing. On web the JavaScript SDK handles `?gleapFile=` automatically on page load,\nso this resolves `{ opened: false }` there.",
+        "complexTypes": [],
+        "slug": "openprotectedfilefromurl"
+      },
       {
         "name": "startBot",
         "signature": "(options: { botId?: string; showBackButton?: boolean; }) => Promise<{ startedBot: boolean; }>",
@@ -1302,6 +1372,48 @@
         "complexTypes": [],
         "slug": "setcolorscheme"
       },
+      {
+        "name": "setCaptureEnabled",
+        "signature": "(options: { enabled: boolean; }) => Promise<{ captureEnabled: boolean; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ enabled: boolean; }"
+          }
+        ],
+        "returns": "Promise<{ captureEnabled: boolean; }>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "19.1.0"
+          }
+        ],
+        "docs": "Enable or disable screenshots and screen recordings for capture requests: when a workflow, an AI agent or a\nteammate asks the user in the widget to show the issue, the widget steps aside, a small bar lets the user go to\nthe right screen, and the SDK captures the app once they tap Capture (or records it between Start and Stop).\nNothing is captured without that tap. While disabled, the widget only offers to upload a file.\nEnabled by default. Works on iOS, Android and web and can be called before or after initialize.",
+        "complexTypes": [],
+        "slug": "setcaptureenabled"
+      },
+      {
+        "name": "setRemoteLogCollectionEnabled",
+        "signature": "(options: { enabled: boolean; }) => Promise<{ remoteLogCollectionEnabled: boolean; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ enabled: boolean; }"
+          }
+        ],
+        "returns": "Promise<{ remoteLogCollectionEnabled: boolean; }>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "19.1.0"
+          }
+        ],
+        "docs": "Enable or disable sending the app's logs for capture requests: a workflow or an AI agent can ask for the logs\nwhile the app runs (no user action), and screenshots and recordings can bring the logs around them. The logs are\nwhat a bug report carries (console and network logs, custom data, env data, custom events; the replay only when\nit is asked for and enabled in the dashboard), and the existing settings still apply (e.g. setDisableEnvData).\nWhile disabled, log requests are answered as not supported and captures are sent without logs.\nEnabled by default. Works on iOS, Android and web and can be called before or after initialize.",
+        "complexTypes": [],
+        "slug": "setremotelogcollectionenabled"
+      },
       {
         "name": "setLanguage",
         "signature": "(options: { languageCode: string; }) => Promise<{ setLanguage: string; }>",

package/dist/esm/definitions.d.ts

@@ -293,6 +293,16 @@ export interface GleapPlugin {
         consoleLogsAttached: boolean;
     }>;
     /**
+    * Answers a `flushLogs` event once the WebView console and network logs the plugin buffers were handed to the native
+    * SDK, so it collects the logs for a capture request with them. The plugin calls this for you on iOS and Android.
+    * No-op on web.
+    *
+    * @since 19.1.0
+    */
+    logsFlushed(options: {
+        flushId: string;
+    }): Promise<void>;
+    /**
     * Set env data props to ignore. The given env data keys (exact and case-sensitive, e.g. "deviceName" or "currentUrl")
     * are removed before a ticket or conversation is sent. Each call replaces the previous list, an empty list resets it.
     * Can be called before or after initialize.
@@ -343,6 +353,16 @@ export interface GleapPlugin {
     */
     addListener(eventName: 'logConfigLoaded', listenerFunc: (config: GleapLogConfig) => void): Promise<PluginListenerHandle>;
     /**
+    * Called on iOS and Android right before the native SDK collects the logs for a capture request: the plugin's
+    * WebView log capture hands over what it buffers (it pushes at most every 500 ms otherwise) and answers with
+    * `logsFlushed`. The native SDK waits at most 500 ms for the answer. The plugin listens for you.
+    *
+    * @since 19.1.0
+    */
+    addListener(eventName: 'flushLogs', listenerFunc: (data: {
+        flushId: string;
+    }) => void): Promise<PluginListenerHandle>;
+    /**
     * Sets the value of a ticket attribute
     *
     * @since 13.5.0
@@ -671,6 +691,23 @@ export interface GleapPlugin {
         conversationsOpened: boolean;
     }>;
     /**
+    * Open the conversation of a protected file from an emailed link.
+    * With "Require authenticated file access" enabled, email replies link attachments to your customer
+    * application URL with a `gleapFile` query parameter. If that URL opens your app (for example as a
+    * universal link / App Link), pass it here, e.g. from `App.addListener('appUrlOpen')` or
+    * `App.getLaunchUrl()` of `@capacitor/app`. `opened` is true when the URL carries a Gleap file reference.
+    * The conversation opens once the customer is identified with a user hash (`identify` with `userHash`);
+    * the link alone grants nothing. On web the JavaScript SDK handles `?gleapFile=` automatically on page load,
+    * so this resolves `{ opened: false }` there.
+    *
+    * @since 19.0.1
+    */
+    openProtectedFileFromUrl(options: {
+        url: string;
+    }): Promise<{
+        opened: boolean;
+    }>;
+    /**
    * Start bot
    *
    * @since 10.0.3
@@ -733,6 +770,35 @@ export interface GleapPlugin {
         colorScheme: string;
     }>;
     /**
+    * Enable or disable screenshots and screen recordings for capture requests: when a workflow, an AI agent or a
+    * teammate asks the user in the widget to show the issue, the widget steps aside, a small bar lets the user go to
+    * the right screen, and the SDK captures the app once they tap Capture (or records it between Start and Stop).
+    * Nothing is captured without that tap. While disabled, the widget only offers to upload a file.
+    * Enabled by default. Works on iOS, Android and web and can be called before or after initialize.
+    *
+    * @since 19.1.0
+    */
+    setCaptureEnabled(options: {
+        enabled: boolean;
+    }): Promise<{
+        captureEnabled: boolean;
+    }>;
+    /**
+    * Enable or disable sending the app's logs for capture requests: a workflow or an AI agent can ask for the logs
+    * while the app runs (no user action), and screenshots and recordings can bring the logs around them. The logs are
+    * what a bug report carries (console and network logs, custom data, env data, custom events; the replay only when
+    * it is asked for and enabled in the dashboard), and the existing settings still apply (e.g. setDisableEnvData).
+    * While disabled, log requests are answered as not supported and captures are sent without logs.
+    * Enabled by default. Works on iOS, Android and web and can be called before or after initialize.
+    *
+    * @since 19.1.0
+    */
+    setRemoteLogCollectionEnabled(options: {
+        enabled: boolean;
+    }): Promise<{
+        remoteLogCollectionEnabled: boolean;
+    }>;
+    /**
    * Set Language
    *
    * @since 7.0.0