@uipath/skills 1.195.0

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/GetUsernamePasswordX.md

@@ -0,0 +1,66 @@
+# Get Username/Password
+
+`UiPath.Activities.System.GetUsernamePasswordX`
+
+Securely store and load usernames and passwords.
+
+**Package:** `UiPath.System.Activities`
+**Category:** System.Dialog
+**Platform:** Windows only
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| CredentialName | Credential Name | InArgument | `string` | No | — | The name used to look up the credential. Hidden in the designer by default; use `CredentialNameProperty` instead. |
+| OrchestratorCredentialName | Orchestrator credential name | InArgument | `string` | No | — | The name of the credential asset stored in Orchestrator. |
+| TimeoutInSeconds | Timeout (in seconds) | InArgument | `int` | No | — | How long to wait for user input before timing out. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| AppOrSite | App Or Site | `string` | — | A label identifying the application or site these credentials belong to, shown in the dialog prompt. |
+| AutosubmitTimeoutSeconds | Autosubmit timeout seconds | `int` | `AutosubmitTimeout` | Number of seconds before the dialog auto-submits when credentials are pre-filled. |
+| CredentialNameProperty | Credential Name Property | `string` | — | Design-time binding of the credential name; preferred over the `CredentialName` argument in the designer. |
+| CredentialsSource | Credentials source | `CredentialSource` | `CredentialSource.CredentialsManager` | Where to load the credentials from (Windows Credential Manager, Orchestrator asset, or prompt). |
+| ExistingCredentialWarning | Existing Credential Warning | `string` | — | Warning message displayed when a credential matching the given name already exists. |
+| MissingCredentialWarning | Missing Credential Warning | `string` | — | Warning message displayed when no matching credential is found. |
+| Password | Password | `string` | — | Design-time pre-fill for the password field. |
+| UserName | User Name | `string` | — | Design-time pre-fill for the username field. |
+
+### Output
+
+| Name | Display Name | Kind | Type | Description |
+|------|-------------|------|------|-------------|
+| Credential | Credential | OutArgument | `PasswordCredentials` | The retrieved or entered credentials, containing both username and secure password. |
+
+## Enum Reference
+
+### CredentialSource
+
+| Value | Description |
+|-------|-------------|
+| `CredentialsManager` | Load from the Windows Credential Manager |
+| `Orchestrator` | Load from an Orchestrator credential asset |
+| `Prompt` | Always show an interactive dialog to the user |
+
+## XAML Example
+
+```xml
+<ui:GetUsernamePasswordX AppOrSite="MyApp"
+                         CredentialsSource="CredentialsManager">
+  <ui:GetUsernamePasswordX.Credential>
+    <OutArgument x:TypeArguments="ui:PasswordCredentials">[myCredential]</OutArgument>
+  </ui:GetUsernamePasswordX.Credential>
+</ui:GetUsernamePasswordX>
+```
+
+## Notes
+
+- This activity is only supported on Windows.
+- The `Credential` output is a `PasswordCredentials` object whose `Password` property is a `SecureString`, keeping the secret out of plain memory.
+- When `CredentialsSource` is `Orchestrator`, provide `OrchestratorCredentialName` to identify the asset.
+- Hidden properties (`CredentialName`, `OrchestratorCredentialName`, `OrchestratorFolderPath`) are not visible in the Designer panel by default.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/If.md

@@ -0,0 +1,56 @@
+# If
+
+> **On the [Common Activity Card](../../../../common-activity-card.md)** — prefer the card for routine authoring.
+
+`System.Activities.Statements.If`
+
+Executes one of two contained activities depending on the value of a Boolean condition.
+
+**Package:** `System.Activities` (ships in .NET; referenced via `UiPath.System.Activities`)
+**Category:** Workflow
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| `Condition` | Condition | `InArgument` | `bool` | Yes | — | The Boolean expression evaluated once. `True` runs `Then`; `False` runs `Else`. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| `Then` | Then | `Activity` | — | Branch executed when `Condition` is `True`. Set via the nested `<If.Then>` element. |
+| `Else` | Else | `Activity` | — | Branch executed when `Condition` is `False`. Set via the nested `<If.Else>` element. Omit entirely when there is no else branch. |
+
+## XAML Example
+
+```xml
+<If xmlns="http://schemas.microsoft.com/netfx/2009/xaml/activities"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    DisplayName="If">
+  <If.Condition>
+    <InArgument x:TypeArguments="x:Boolean">
+      <VisualBasicValue x:TypeArguments="x:Boolean" ExpressionText="counter &lt; 10" />
+    </InArgument>
+  </If.Condition>
+  <If.Then>
+    <Sequence DisplayName="Then">
+      <!-- then branch -->
+    </Sequence>
+  </If.Then>
+  <If.Else>
+    <Sequence DisplayName="Else">
+      <!-- else branch -->
+    </Sequence>
+  </If.Else>
+</If>
+```
+
+## Notes
+
+- Both `If.Then` and `If.Else` slots **must wrap their body in `<Sequence>`** per Rule 24, even when the branch contains only one activity.
+- Omit `<If.Else>` entirely when the workflow has no else branch. Do not emit an empty `<If.Else></If.Else>` — it has no effect and clutters the workflow.
+- `activities get-default-xaml` for `If` returns `<If />` only — every property and both branch slots are invisible to the CLI; this doc is the only authoritative source for the shape.
+- For multi-branch decisions (`else if … else if … else`), use `UiPath.Core.Activities.IfElseIfV2` (see `ElseIf.md`) instead of nesting `If` inside `If.Else`.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/InvokeCode.md

@@ -0,0 +1,59 @@
+# Invoke Code
+
+`UiPath.Core.Activities.InvokeCode`
+
+Synchronously invokes VB.NET or C# code, optionally passing it a list of input arguments. This activity can also return out arguments to the caller workflow.
+
+**Package:** `UiPath.System.Activities`
+**Category:** Programming
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| ContinueOnError | Continue on error | InArgument | `bool` | No | — | When `True`, execution continues to the next activity even if this activity throws an error. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| Code | Code | `string` | — | The VB.NET or C# source code to execute. Required. Supports only string literals and String variables. |
+| Language | Language | `NetLanguage` | `NetLanguage.VBNet` | The programming language of the code snippet (`VBNet` or `CSharp`). |
+| Arguments | Arguments | `Dictionary<string, Argument>` | — | Named input/output argument bindings that make workflow variables available inside the code and allow returning values back to the workflow. |
+
+### Output
+
+_No dedicated output arguments. Return values are passed back through the `Arguments` dictionary using `OutArgument` or `InOutArgument` entries._
+
+## Enum Reference
+
+### NetLanguage
+
+| Value | Description |
+|-------|-------------|
+| `VBNet` | Visual Basic .NET (default) |
+| `CSharp` | C# |
+
+## XAML Example
+
+```xml
+<ui:InvokeCode Language="VBNet">
+  <ui:InvokeCode.Code>
+    <x:String>
+      result = input * 2
+    </x:String>
+  </ui:InvokeCode.Code>
+  <ui:InvokeCode.Arguments>
+    <x:Reference>invokeCodeArgs</x:Reference>
+  </ui:InvokeCode.Arguments>
+</ui:InvokeCode>
+```
+
+## Notes
+
+- Argument bindings in the `Arguments` dictionary use the variable name as the key; direction (`In`, `Out`, `InOut`) determines data flow.
+- The code snippet is compiled and executed at runtime in the same process as the robot; it has access to all .NET BCL types.
+- Use `InArgument` entries to pass data into the code and `OutArgument` entries to receive results back.
+- Both `VBNet` and `CSharp` are supported; choose the language that matches your Studio project settings for consistency.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/InvokeComMethod.md

@@ -0,0 +1,63 @@
+# Invoke Com Method
+
+`UiPath.Core.Activities.InvokeComMethod`
+
+Invokes a method of a specified COM object.
+
+**Package:** `UiPath.System.Activities`
+**Category:** Programming.Execute
+**Platform:** Windows only
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| MethodName | Method name | InArgument | `string` | Yes | — | The name of the method to invoke on the COM object. |
+| CLSID | CLSID | InArgument | `string` | No | — | The class identifier (CLSID) of the COM object to instantiate. Use either `CLSID` or `ProgID` to identify the target object. |
+| ProgID | ProgID | InArgument | `string` | No | — | The programmatic identifier (ProgID) of the COM object type. Use either `ProgID` or `CLSID`. |
+| ContinueOnError | Continue On Error | InArgument | `bool` | No | — | When `True`, execution continues to the next activity even if this activity throws an error. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| Arguments | Arguments | `Dictionary<string, Argument>` | — | Named parameter bindings passed to the COM method. |
+| BindingFlags | Binding flags | `BindingFlags` | — | Reflection binding flags controlling how the method is located and invoked. Supports multi-select. |
+
+### Output
+
+| Name | Display Name | Kind | Type | Description |
+|------|-------------|------|------|-------------|
+| Result | Result | OutArgument | `object` | The return value of the invoked COM method. Cast to the appropriate type as needed. |
+
+## Valid Configurations
+
+Provide exactly one of `CLSID` or `ProgID` to identify the COM server:
+
+| Scenario | Use |
+|----------|-----|
+| Known ProgID (e.g., `"Excel.Application"`) | `ProgID` |
+| Known CLSID GUID | `CLSID` |
+
+## XAML Example
+
+```xml
+<!-- Invoke a method using ProgID -->
+<ui:InvokeComMethod MethodName="Open">
+  <ui:InvokeComMethod.ProgID>
+    <InArgument x:TypeArguments="x:String">"Excel.Application"</InArgument>
+  </ui:InvokeComMethod.ProgID>
+  <ui:InvokeComMethod.Result>
+    <OutArgument x:TypeArguments="x:Object">[comResult]</OutArgument>
+  </ui:InvokeComMethod.Result>
+</ui:InvokeComMethod>
+```
+
+## Notes
+
+- This activity is only supported on Windows; COM is a Windows-specific technology.
+- `CLSID` and `ProgID` are mutually exclusive; supplying both may cause unexpected behaviour.
+- The `Result` is typed as `object`; use an Assign or Cast activity to convert it to the expected .NET type.
+- `BindingFlags` maps directly to `System.Reflection.BindingFlags`; the default (no flags set) uses standard late-binding invocation suitable for most COM objects.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/InvokeProcess.md

@@ -0,0 +1,70 @@
+# Invoke Process
+
+`UiPath.Core.Activities.InvokeProcess`
+
+Starts the specified process within the current robot execution. It waits for the invoked process to finish before resuming the execution. It returns output arguments.
+
+**Package:** `UiPath.System.Activities`
+**Category:** Workflow
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| `ProcessName` | Process Name / Package Name | `InArgument` | `string` | Yes | — | The name of the Orchestrator process (when invoking by process name) or the package name (when invoking by package name). The display name changes based on the `Invoke Process By` selection. |
+| `FolderPath` | Folder Path | `InArgument` | `string` | No | — | The Orchestrator folder path used to locate the process. In solution scope, this field becomes read-only when a process is selected by literal name. |
+| `EntryPointPath` | Entry point | `InArgument` | `string` | No | — | The entry point `.xaml` path within the package. Only visible when **Invoke Process By** is set to `ByPackageName`. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| `UsePackage` | Use package | `bool` | `True` | Determines whether the process is looked up by package name (and entry point) or by Orchestrator process name. |
+| `TargetSession` | Target Session | `InvokeProcessTargetSession` | `Current` | The session in which the process executes. |
+
+### Output
+
+| Name | Display Name | Kind | Type | Description |
+|------|-------------|------|------|-------------|
+| `OutputArguments` | Output Arguments | `OutArgument` | `Dictionary<string, object>` | A dictionary containing the output arguments returned by the invoked process after it completes. |
+
+## Valid Configurations
+
+| `UsePackage` | Visible fields |
+|---|---|
+| `False` (by process name) | `ProcessName` (as "Process Name"), `FolderPath`, `NotMappedEntryPointPath` (read-only placeholder showing the detected entry point) |
+| `True` (by package name) | `ProcessName` (as "Package Name"), `FolderPath`, `EntryPointPath`, deprecation warning info box |
+
+## XAML Example
+
+```xml
+<ui:InvokeProcess
+    xmlns:ui="clr-namespace:UiPath.Core.Activities;assembly=UiPath.System.Activities"
+    DisplayName="Invoke Process"
+    UsePackage="False">
+  <ui:InvokeProcess.ProcessName>
+    <InArgument x:TypeArguments="x:String">
+      <VisualBasicValue x:TypeArguments="x:String" ExpressionText="&quot;MyAutomation&quot;" />
+    </InArgument>
+  </ui:InvokeProcess.ProcessName>
+  <ui:InvokeProcess.FolderPath>
+    <InArgument x:TypeArguments="x:String">
+      <VisualBasicValue x:TypeArguments="x:String" ExpressionText="&quot;Shared&quot;" />
+    </InArgument>
+  </ui:InvokeProcess.FolderPath>
+  <ui:InvokeProcess.OutputArguments>
+    <OutArgument x:TypeArguments="scg:Dictionary(x:String, x:Object)" />
+  </ui:InvokeProcess.OutputArguments>
+</ui:InvokeProcess>
+```
+
+## Notes
+
+- The activity waits synchronously for the invoked process to finish before execution continues in the calling workflow.
+- **Invoke Process By** (`InvokeProcessBy`) is a designer-only radio-group control (`notMapped`) that sets `UsePackage` on the underlying activity and switches between process-name and package-name modes.
+- When invoking by package name, a deprecation warning info box is shown in the designer (`InvokeProcessInfoBox`).
+- In solution scope, `FolderPath` is automatically set from the selected process and becomes read-only; it is cleared if the process selection changes to a non-literal expression.
+- `Arguments` (the input/output argument dictionary passed to the process) is populated automatically by importing arguments from Orchestrator when a valid process and, if applicable, entry point are selected. Use the **Use an expression** menu action to switch to `ArgumentsVariable`, a single expression-based alternative. At runtime, `ArgumentsVariable` takes precedence over `Arguments` when both are set.
+- On non-Windows/Portable target frameworks, an incompatible target framework warning is displayed when a Legacy or Windows process is selected in solution scope.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/InvokeVBScript.md

@@ -0,0 +1,58 @@
+# Invoke VBScript
+
+`UiPath.Core.Activities.InvokeVBScript`
+
+Executes a specified VBScript, optionally passing it a list of input parameters.
+
+**Package:** `UiPath.System.Activities`
+**Category:** System.VBScript
+**Platform:** Windows only
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| FileName | VBScript file name | InArgument | `string` | Yes | — | The full file path of the `.vbs` script to execute. |
+| TimeoutMS | Timeout | InArgument | `int` | No | — | Maximum time in milliseconds to wait for the script to finish. Only applies when `WaitForOutput` is `True`. |
+| KillOnTimeout | KillOnTimeout | InArgument | `bool` | No | `False` | When `True`, forcibly terminates the VBScript process if the timeout is reached. |
+| RunInBatchMode | HidePopups | InArgument | `bool` | No | `False` | When `True`, suppresses display alerts, scripting errors, and input dialogs (runs silently). |
+| UnicodeSupport | UnicodeSupport | InArgument | `bool` | No | `False` | When `True`, enables correct handling of non-ASCII characters (e.g., Japanese) in arguments and output. |
+| WaitForOutput | WaitForOutput | InArgument | `bool` | No | `True` | When `True`, the activity waits for the script to complete before proceeding. When `False`, the script runs asynchronously and `TimeoutMS` is ignored. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| Arguments | Arguments | `List<InArgument<string>>` | `[]` | Ordered list of string arguments passed to the VBScript at runtime. |
+
+### Output
+
+| Name | Display Name | Kind | Type | Description |
+|------|-------------|------|------|-------------|
+| Result | Result | OutArgument | `string` | The standard output produced by the VBScript execution. |
+
+## XAML Example
+
+```xml
+<ui:InvokeVBScript WaitForOutput="True" TimeoutMS="10000" KillOnTimeout="True">
+  <ui:InvokeVBScript.FileName>
+    <InArgument x:TypeArguments="x:String">"C:\Scripts\MyScript.vbs"</InArgument>
+  </ui:InvokeVBScript.FileName>
+  <ui:InvokeVBScript.Arguments>
+    <InArgument x:TypeArguments="x:String">arg1</InArgument>
+    <InArgument x:TypeArguments="x:String">arg2</InArgument>
+  </ui:InvokeVBScript.Arguments>
+  <ui:InvokeVBScript.Result>
+    <OutArgument x:TypeArguments="x:String">[scriptOutput]</OutArgument>
+  </ui:InvokeVBScript.Result>
+</ui:InvokeVBScript>
+```
+
+## Notes
+
+- This activity is only supported on Windows; it relies on the Windows Script Host (`cscript.exe`).
+- Arguments are passed positionally; access them in the script via `WScript.Arguments(0)`, `WScript.Arguments(1)`, etc.
+- When `WaitForOutput` is `False`, the `Result` output will be empty because the process has not yet completed.
+- `RunInBatchMode` (`HidePopups`) uses the `/B` switch of `cscript`, suppressing all UI interaction from the script.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/InvokeWorkflow.md

@@ -0,0 +1,66 @@
+# Invoke Workflow File
+
+`UiPath.Core.Activities.InvokeWorkflowFile`
+
+Synchronously invokes a specified workflow, optionally passing it a list of input arguments.
+
+**Package:** `UiPath.System.Activities`
+**Category:** Workflow
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| `WorkflowFileName` | Workflow file name | `InArgument` | `string` | Yes | — | The path to the `.xaml` workflow file to invoke. In normal static calls, serialize as a plain relative path string, not an expression-wrapped string literal. |
+| `ArgumentsVariable` | Arguments Variable | `InArgument` | `Dictionary<string, object>` | No | — | Alternative to `Arguments`. When set, the caller passes a single dictionary instead of per-argument bindings. Use this OR `Arguments`, not both. |
+| `Timeout` | Timeout | `InArgument` | `TimeSpan` | No | — | Execution timeout. Unset = no timeout. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| `UnSafe` | Isolated | `bool` | `False` | When `True`, the invoked workflow runs in an isolated process. Required when `TargetSession` is non-`Current` (otherwise `CacheMetadata` raises a validation error). |
+| `TargetSession` | Target Session | `InvokeWorkflowTargetSession` | `Current` | The session in which the invoked workflow executes. Values: `Current` \| `Main` \| `PictureInPicture`. |
+| `Arguments` | Arguments | `Dictionary<string, Argument>` | empty | Dictionary of bound arguments keyed by the invoked workflow's declared argument names. Use `InArgument`/`OutArgument`/`InOutArgument` element kinds per argument direction. |
+
+### Log
+
+| Name | Display Name | Kind | Type | Default | Description |
+|------|-------------|------|------|---------|-------------|
+| `LogEntry` | Log Entry | `InArgument` | `LogEntryType` | `No` | Entry-log mode. Values: `No` \| `OnlyInvocation` \| `WithArguments`. |
+| `LogExit` | Log Exit | `InArgument` | `LogExitType` | `No` | Exit-log mode. Values: `No` \| `OnlySuccessfulReturn` \| `WithArguments`. |
+| `Level` | Log Level | `InArgument` | `LogLevel` | `Info` | Severity of entry/exit log lines (only emitted when `LogEntry`/`LogExit` are non-`No`). Same enum as `LogMessage.Level`. |
+
+## XAML Example
+
+```xml
+<ui:InvokeWorkflowFile
+    xmlns="http://schemas.microsoft.com/netfx/2009/xaml/activities"
+    xmlns:ui="http://schemas.uipath.com/workflow/activities"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    DisplayName="Invoke Workflow File"
+    UnSafe="False"
+    WorkflowFileName="Workflows\Process.xaml">
+  <ui:InvokeWorkflowFile.Arguments>
+    <InArgument x:TypeArguments="x:String" x:Key="in_invoiceId">
+      <VisualBasicValue x:TypeArguments="x:String" ExpressionText="invoiceId" />
+    </InArgument>
+    <OutArgument x:TypeArguments="x:Boolean" x:Key="out_isValid">
+      <VisualBasicReference x:TypeArguments="x:Boolean" ExpressionText="isValid" />
+    </OutArgument>
+  </ui:InvokeWorkflowFile.Arguments>
+</ui:InvokeWorkflowFile>
+```
+
+## Notes
+
+- **Invoke Workflow File** is a container/scope activity in the sense that it passes arguments to and receives output from the invoked workflow file.
+- The invoked workflow runs **synchronously** — the current workflow pauses until the invoked one finishes.
+- `WorkflowFileName` must be a plain project-relative path (`Workflows\Process.xaml`), not `[&quot;Workflows\Process.xaml&quot;]` or another expression-wrapped string. See `xaml/common-pitfalls.md` for the path-resolution failure mode.
+- When manually populating `Arguments`, use direct `InArgument` / `OutArgument` / `InOutArgument` children with `x:Key` matching the callee argument name. Do **not** wrap populated arguments in `scg:Dictionary`; Studio may clear dictionary-wrapped mappings on load. The empty dictionary returned by `activities get-default-xaml` is only correct for the empty state.
+- For C# XAML projects, replace `VisualBasicValue` / `VisualBasicReference` with `CSharpValue` / `CSharpReference` element-body bindings; do not use VB bracket shorthand for argument expressions.
+- Setting `Isolated` (`UnSafe`) to `True` runs the invoked workflow in a separate process for fault isolation; this incurs additional overhead.
+- `TargetSession` controls which robot session executes the invoked workflow (e.g. `Current`, `Main`, `PictureInPicture`).
+- `AssemblyName` is a non-browsable internal property and is not intended for manual configuration.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/IsMatch.md

@@ -0,0 +1,51 @@
+# Is Text Matching
+
+`UiPath.Core.Activities.IsMatch`
+
+Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.
+
+**Package:** `UiPath.System.Activities`
+**Category:** Formatting
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| `Input` | Text to search in | InArgument | `String` | Yes | — | The string in which to search for a match. |
+| `Pattern` | Pattern | InArgument | `String` | Yes | — | The regular expression pattern to match against. |
+| `TimeoutMS` | Timeout (ms) | InArgument | `Int32` | No | — | Maximum time in milliseconds allowed for the match operation. Leave empty for no timeout. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| `RegexOption` | Pattern options | `RegexOptions` | `IgnoreCase, Compiled` | Flags that control regular expression matching behavior. Multiple flags can be combined. |
+
+### Output
+
+| Name | Display Name | Kind | Type | Description |
+|------|-------------|------|------|-------------|
+| `Result` | Result | OutArgument | `Boolean` | `True` if the pattern finds at least one match in the input string; `False` otherwise. |
+
+### Enum Reference
+
+**`RegexOptions`** (flags, combinable): `None`, `IgnoreCase`, `Multiline`, `ExplicitCapture`, `Compiled`, `Singleline`, `IgnorePatternWhitespace`, `RightToLeft`, `ECMAScript`, `CultureInvariant`
+
+## XAML Example
+
+```xml
+<ui:IsMatch
+  xmlns:ui="clr-namespace:UiPath.Core.Activities;assembly=UiPath.System.Activities"
+  Input="[myText]"
+  Pattern="[&quot;\d{3}-\d{4}&quot;]"
+  RegexOption="IgnoreCase, Compiled"
+  Result="[isMatchResult]" />
+```
+
+## Notes
+
+- The default `RegexOption` is `IgnoreCase, Compiled`. Adjust this to change matching behavior (for example, use `None` for a case-sensitive match without JIT compilation overhead on one-off patterns).
+- Setting `TimeoutMS` prevents runaway backtracking on complex patterns against large inputs. A `RegexMatchTimeoutException` is thrown if the timeout expires.
+- The activity uses the .NET `Regex.IsMatch` static method, which caches the 15 most recently used patterns automatically.

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/JoinDataTables.md

@@ -0,0 +1,85 @@
+# Join Data Tables
+
+`UiPath.Core.Activities.JoinDataTables`
+
+Combines rows from two tables by using values common to each other, according to a Join rule.
+
+**Package:** `UiPath.System.Activities`
+**Category:** Programming > DataTable
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| DataTable1 | DataTable1 | InArgument | DataTable | Yes | — | The first (left) DataTable in the join. |
+| DataTable2 | DataTable2 | InArgument | DataTable | Yes | — | The second (right) DataTable in the join. |
+
+### Configuration
+
+| Name | Display Name | Type | Default | Description |
+|------|-------------|------|---------|-------------|
+| JoinType | JoinType | Property (JoinType) | — | The type of join to perform. See **Enum Reference** below. |
+| Arguments | Arguments | Property (List\<JoinOperationArgument\>) | — | The join conditions built using the designer's Join widget. Each condition pairs a column from DataTable1 with a column from DataTable2 using a comparison operator. All conditions are combined with AND. |
+
+### Output
+
+| Name | Display Name | Kind | Type | Description |
+|------|-------------|------|------|-------------|
+| OutputDataTable | Data Table | OutArgument | DataTable | The resulting joined DataTable. |
+
+## Join Conditions
+
+Each condition in **Arguments** references one column from each table and an operator. Only AND is supported as the logical operator between conditions.
+
+### Column reference
+
+Each side of a join condition is specified as an `InArgument` expression that evaluates to a column name (String), column index (Int32), or DataColumn object.
+
+### Supported join operators
+
+| Operator | Symbol |
+|----------|--------|
+| `LT` | `<` |
+| `GT` | `>` |
+| `LTE` | `<=` |
+| `GTE` | `>=` |
+| `EQ` | `=` |
+| `NOTEQ` | `!=` |
+
+## Enum Reference
+
+### JoinType
+
+| Value | Description |
+|-------|-------------|
+| `Inner` | Returns only rows where the join condition is satisfied in both tables. |
+| `Left` | Returns all rows from DataTable1 and matched rows from DataTable2. Unmatched rows from DataTable2 produce null values in the result. |
+| `Full` | Returns all rows from both tables. Rows without a match in the other table produce null values for the missing side. |
+
+## Notes
+
+- The `Arguments` property is populated via the visual Join widget in Studio Designer — it is not intended to be set manually in XAML.
+- `Column1` and `Column2` are internal designer-state properties (zero-based column counts) that track the column layout in the widget. They are not workflow arguments.
+- `Operation` is an internal property holding the join rule at runtime; it is not exposed as a designer argument.
+- The output is always a new DataTable; neither input table is modified.
+
+## XAML Example
+
+```xml
+<ui:JoinDataTables DisplayName="Join Data Tables"
+                   JoinType="Inner"
+                   xmlns:ui="clr-namespace:UiPath.Core.Activities;assembly=UiPath.System.Activities">
+  <ui:JoinDataTables.DataTable1>
+    <InArgument x:TypeArguments="sd:DataTable">[employeesTable]</InArgument>
+  </ui:JoinDataTables.DataTable1>
+  <ui:JoinDataTables.DataTable2>
+    <InArgument x:TypeArguments="sd:DataTable">[departmentsTable]</InArgument>
+  </ui:JoinDataTables.DataTable2>
+  <ui:JoinDataTables.OutputDataTable>
+    <OutArgument x:TypeArguments="sd:DataTable">[joinedTable]</OutArgument>
+  </ui:JoinDataTables.OutputDataTable>
+  <!-- Join conditions are configured via the visual widget in Studio -->
+</ui:JoinDataTables>
+```

package/skills/uipath-rpa/references/activity-docs/UiPath.System.Activities/26.4/activities/KillProcess.md

@@ -0,0 +1,67 @@
+# Kill Process
+
+`UiPath.Core.Activities.KillProcess`
+
+Terminates a specified process.
+
+**Package:** `UiPath.System.Activities`
+**Category:** System.Application
+
+## Properties
+
+### Input
+
+| Name | Display Name | Kind | Type | Required | Default | Description |
+|------|-------------|------|------|----------|---------|-------------|
+| Process | Process | InArgument | `Process` | No | — | A `System.Diagnostics.Process` object identifying the process to kill. Use this or `ProcessName`, not both. |
+| ProcessName | Process Name | InArgument | `string` | No | — | The name of the process to kill (without the `.exe` extension). Kills all matching processes. Use this or `Process`, not both. |
+| AppliesTo | Applies To | InArgument | `KillProcessApplyOn` | No | `KillProcessApplyOn.All` | Filters which instances of a named process to kill (All, current user, current session, or current desktop). Windows projects support all modes. |
+| ContinueOnError | Continue On Error | InArgument | `bool` | No | — | When `True`, execution continues to the next activity even if this activity throws an error. |
+
+### Configuration
+
+_No configuration properties._
+
+### Output
+
+_No output properties._
+
+## Valid Configurations
+
+Exactly one of `Process` or `ProcessName` must be provided (they belong to separate overload groups).
+
+| Scenario | Use |
+|----------|-----|
+| Have a `Process` object from Get Processes | `Process` argument |
+| Know only the process name | `ProcessName` argument |
+
+## Enum Reference
+
+### KillProcessApplyOn
+
+| Value | Description |
+|-------|-------------|
+| `All` | Kill all processes matching the name, regardless of owner |
+| `User` | Kill only processes owned by the current user (Windows only) |
+| `Session` | Kill only processes in the current Windows session |
+| `Desktop` | Kill only processes on the current Windows desktop |
+
+## XAML Example
+
+```xml
+<!-- Kill by name -->
+<ui:KillProcess ProcessName="notepad" AppliesTo="All" />
+
+<!-- Kill a specific process object -->
+<ui:KillProcess>
+  <ui:KillProcess.Process>
+    <InArgument x:TypeArguments="sd:Process">[myProcess]</InArgument>
+  </ui:KillProcess.Process>
+</ui:KillProcess>
+```
+
+## Notes
+
+- In Windows projects all `AppliesTo` filtering modes are available. In cross-platform projects only `All` is supported.
+- Killing a process by name terminates every running instance that matches; supply a `Process` object (from Get Processes) to target a single instance.
+- A `ProcessName` match is case-insensitive and should not include the `.exe` suffix.