BassemE/mulesoft-documentation-embeddings huggingface dataset:
Configuring Permissions | MuleSoft Documentation
# Configuring Permissions
Cloud IDE 
Desktop IDE 
**Open Beta Release** : The **cloud IDE is in open beta**. Any use of Anypoint Code Builder in its beta state is subject to the applicable beta services terms and conditions, available from the IDE.
Manage user access to Anypoint Code Builder and Anypoint Platform features used by the cloud and desktop IDEs. Use Access Management to grant permissions directly to individual users or assign permissions to teams to which the users belong.
## Required Permissions
These permissions are required:
  * Cloud IDE users only:
**Anypoint Code Builder Developer** allows a user to launch Anypoint Code Builder from Anypoint Platform.
  * Cloud and desktop IDE users:
    * Set these Anypoint Exchange permissions so that users can download and publish assets:
    * Set these Runtime Manager permissions to enable services related to CloudHub and CloudHub 2.0, such as deploying applications:
      * **Read applications**
      * **Create applications**
      * **Delete applications**
    * Set the Design Center Developer permission so that users can view and create APIs.


For a complete list of permissions, see Permissions Available in Anypoint Platform.
## Before You Begin
Log in to Anypoint Platform on your US or EU cloud host.
Show me how
  * US cloud (non-EU host): Anypoint Platform (US)
  * EU cloud (EU host): Anypoint Platform (EU)


If you do not have an Anypoint Platform account, you can sign up from one of the hosts.
## Grant Permissions to Users
To grant permissions to an individual user:
  1. In Anypoint Platform, navigate to **Access Management**.
For the Anypoint Platform URL, see Before You Begin.
  2. Assign permissions to the user by following the steps in Grant Permissions to Users.


The user can now develop using Anypoint Code Builder.
## Grant Permissions to Teams
To grant the permission to a team:
  1. In Anypoint Platform, navigate to **Access Management**.
For the Anypoint Platform URL, see Before You Begin.
  2. If you haven’t started using Teams in Access Management, click **Try New Features** > **Start Using These Features** to opt in to Teams.
  3. Follow the steps in Configuring Teams:
     * If necessary, create the team and add users.
     * Assign permissions to the team.


The members of the team can now develop using Anypoint Code Builder.
## See Also
  * Getting Started with Anypoint Code Builder
  * Resource Organization and Access Control with Business Groups
Loop | MuleSoft Documentation
# Loop
A _Loop_ allows you to repeat the same _Transaction_ and action steps two or more times.
## Properties
  * **At end of loop** Sets how the _Loop_ should be exited after all iterations have been executed. Available options are _Exit with error_ or _Exit without error_.
  * **Increment Value** Value the _Loop_ counter increments by on each iteration.
  * **Iteration Count** Sets how often the _Loop_ will be executed. Default value is 2.
  * **Start Value** Value the _Loop_ counter starts with.


## Inbound Variables
**Iteration Count** Sets how often the _Loop_ will be executed. Default value is 2.
**Start Value** Value the _Loop_ counter starts with.
**Increment Value** Value the _Loop_ counter increments by on each iteration.
## Outbound Variables
**Iteration** Returns the current value of the _Loop_ counter
Session Based Variables | MuleSoft Documentation
# Session Based Variables
Use Session Based Variables to share variables accross all workflows that run inside the same session.
You can define session variables of the following types:
  * Alphanumeric
  * Integer
  * Floating-point
  * Boolean
  * Array
  * User account
  * Web Session ID.


Use the Set Variable and the Set Array Variable action steps to overwrite the initial variable values with new values at a later point in the Workflow.
You can include only one instance of Session Based Variables in a Workflow and it must be in the Workflow Initialization section.
## Properties
See Common Properties.
## Inbound Variables
This action step has no inbound variables.
## Outbound Variables
All Session Based Variables are outbound variables. Variables are specified in the format _Workflow Based Variables. <variableName>_.
Session Based Variables show in Variable Mappings only for action steps that support that type of variable.
## Wizard
To create new variables:
  1. Click **Add new parameter**.
  2. Select the type of variable to create.
  3. Specify the variable’s name, description, and value.


To delete variables, click the **Delete Variable** () button.
## Sharing Session Based Variables Between Workflows
To share Session Based Variables, create the variables in each workflow using the same variable name and type. When a workflow updates a variable, any successive workflow that reads the same variable uses the updated value of said variable.
## See Also
  * Workflow Based Variables
  *   *
isUpperCase | MuleSoft Documentation
# isUpperCase
## isUpperCase(text: String): Boolean
Checks if the `text` contains only uppercase characters.
_Introduced in DataWeave version 2.2.0._
### Parameters
Name | Description  
---|---  
The input string.  
### Example
This example shows how `isUpperCase` behaves with different inputs and sizes.
#### Source
```
%dw 2.0
import isUpperCase from dw::core::Strings
output application/json
---
{
 "a": isUpperCase(null),
 "b": isUpperCase(""),
 "c": isUpperCase(" "),
 "d": isUpperCase("ABC"),
 "e": isUpperCase("aBC"),
 "f": isUpperCase("A C"),
 "g": isUpperCase("A1C"),
 "h": isUpperCase("A/C")
}
```

#### Output
```
{
 "a": false,
 "b": false,
 "c": false,
 "d": true,
 "e": false,
 "f": false,
 "g": false,
 "h": false
}
```

## isUpperCase(text: Null): Boolean
Helper function that enables `isUpperCase` to work with a `null` value.
_Introduced in DataWeave version 2.2.0._
Requesting Access to a Portal for Salesforce Users | MuleSoft Documentation
# Requesting Access to a Portal for Salesforce Users
Salesforce users can request portal access when they don’t have Single Sign-On (SSO) configured.
Before you request access, confirm that you don’t have a Single Sign-On (SSO) configuration. Having an SSO configuration can cause issues in the portal. For example, you might not see all APIs available to you if they are not available in the SSO configuration.
If the request access component is available on a portal, Salesforce users can request access. Users can request access by entering their username and clicking the **Requests access** button or the **Submit request** button.
When the request is approved, an email is sent with login information.
## See Also
  *   *
Access Asset and Developer Portals | MuleSoft Documentation
# Access Asset and Developer Portals
As an administrator, you can view the resources and methods of an API, and access other details, such as publish date and mocking service, from Anypoint Exchange (Exchange). You can view the API in an asset portal (private) or a public portal.
## Access an Asset Portal
Before you access an asset portal, ensure that you meet one of the following conditions:
  * The portal is listed in the organization’s public developer portal.
  * The portal is private but you have Portals Viewer access.


To access an asset portal:
  1. Navigate to **Anypoint Platform** > **API Manager**.
  2. In **API Administration** , click the name of the API instance that you want to access.
  3. Click **Actions** and select **View API in Exchange**.
The portal for the selected asset is displayed in an Exchange window. You can also share and make the portal public in Anypoint Exchange.


## Access a Public Portal
To access an organization’s public portal:
  1. Navigate to **Exchange** > **Public portal**.
  2. From the developer portal page, select the asset that you want to access.


## See Also
  * Anypoint Platform developer portal
p | MuleSoft Documentation
# p
## p(propertyName: String): String
This function returns a string that identifies the value of one of these input properties: Mule property placeholders, System properties, or Environment variables.
For more on this topic, see Configure Properties.
### Parameters
Name | Description  
---|---  
`propertyName` | A string that identifies property.  
### Example
This example logs the value of the property `http.port` in a Logger component.
#### Source
```
<flow name="simple">
 <logger level="INFO" doc:name="Logger"
  message="#[Mule::p('http.port')]"/>
</flow>
```
atBeginningOfHour | MuleSoft Documentation
# atBeginningOfHour
## atBeginningOfHour(dateTime: DateTime): DateTime
Returns a new `DateTime` value that changes the `Time` value in the input to the beginning of the specified _hour_.
The minutes and seconds in the input change to `00:00`.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
The `DateTime` value to reference.  
### Example
This example changes the `Time` value within the `DateTime` input to the beginning of the specified _hour_.
#### Source
```
%dw 2.0
import * from dw::core::Dates
output application/json
---
{
  "atBeginningOfHourDateTime": atBeginningOfHour(|2020-10-06T18:23:20.351-03:00|)
}
```

#### Output
```
{
 "atBeginningOfHourDateTime": "2020-10-06T18:00:00-03:00"
}
```

## atBeginningOfHour(localDateTime: LocalDateTime): LocalDateTime
Returns a new `LocalDateTime` value that changes the `Time` value in the input to the beginning of the specified _hour_.
The minutes and seconds in the input change to `00:00`.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
`localDateTime` |  The `LocalDateTime` value to reference.  
### Example
This example changes the `Time` value within the `LocalDateTime` input to the beginning of the specified hour.
#### Source
```
%dw 2.0
import * from dw::core::Dates
output application/json
---
{
  "atBeginningOfHourLocalDateTime": atBeginningOfHour(|2020-10-06T18:23:20.351|)
}
```

#### Output
```
{
 "atBeginningOfHourLocalDateTime": "2020-10-06T18:00:00"
}
```

## atBeginningOfHour(localTime: LocalTime): LocalTime
Returns a new `LocalTime` value that changes its value in the input to the beginning of the specified _hour_.
The minutes and seconds in the input change to `00:00`.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
`localTime` |  The `LocalTime` value to reference.  
### Example
This example changes the `LocalTime` value to the beginning of the specified hour.
#### Source
```
%dw 2.0
import * from dw::core::Dates
output application/json
---
{
  "atBeginningOfHourLocalTime": atBeginningOfHour(|18:23:20.351|)
}
```

#### Output
```
{
 "atBeginningOfHourLocalTime": "18:00:00"
}
```

## atBeginningOfHour(time: Time): Time
Returns a new `Time` value that changes the input value to the beginning of the specified _hour_.
The minutes and seconds in the input change to `00:00`.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
The `Time` value to reference.  
### Example
This example changes the `Time` value to the beginning of the specified hour.
#### Source
```
%dw 2.0
import * from dw::core::Dates
output application/json
---
{
  "atBeginningOfHourTime": atBeginningOfHour(|18:23:20.351-03:00|)
}
```

#### Output
```
{
 "atBeginningOfHourTime": "18:00:00-03:00"
}
```
Testing Your Module | MuleSoft Documentation
# Testing Your Module
Testing ensures that a piece of code works correctly. Testing a module is more than simply creating test cases for the business logic. A lot of testing of the interaction between the Module and Mule is required to ensure compatibility with the Mule ecosystem.
Here are a series of articles that explain in detail how to test your module. It provides a step-by-step introduction on how to test a module. It explains the basis of a Module Test Case and how to execute a simple operation from a Module.
  * Writing your first test case (with FlowRunner)
String to Array | MuleSoft Documentation
# String to Array
The _String to Array_ action step allows you to split a string into arrays and to process them further in the subsequent action steps, such as with the _Read from Array_ action step.
## Properties
**Input String** (string, empty with the default setting, must not be empty) String that can be entered using the keyboard or in the wizard, including with the help of the pin variables.
**Separator** Define a separator that the string is to be separated after. In the wizard, you also have the option of entering the separator via a pin variable.
The separator may comprise more than one character, such as //, or also be a space.
## Inbound Variables
**Input String** (string, empty with the default setting, must not be empty) String that can be entered using the keyboard or in the wizard, including with the help of the pin variables.
**Separator** Define a separator that the string is to be separated after. In the wizard, you also have the option of entering the separator via a pin variable.
## Outbound Variables
**ResultAsArray** The converted string is output as an array.
## Example
String = DE 123456789
Separator = space
Array output = DE;123456789
String = 1234567/123/456
Separator = /
Array output 1234567;123;456
Business Events | MuleSoft Documentation
# Business Events
Mule applications collect _business event_ information (such as transaction execution time, errors, success or failure results, and message payload information) about flows and message processors that handle your _business transactions_ :
  * Events map to message processors and connectors and are the low-level details of a transaction. Events are not supported in batch processing.
  * Transactions are logical groupings of related events that often correspond to a business view of the system, at the flow level.


## Business Event Types
You can track two types of business events: _default events_ and _custom events_.
Default event tracking is supported by all connectors and selected message processors. Enabling default events for these elements enables you to perform advanced debugging at runtime. You can enable default event tracking at either the flow level or the message processor level. See Configure Default Events Tracking for configuration details.
Custom event tracking is supported by the Custom Business Event component. Custom events are always tracked, enabling you to monitor high-level activities in your flow that are relevant to your business. See Custom Business Event Component for configuration details.
## Monitoring Business Events
You can enable Insight in Runtime Manager to monitor business events at runtime. These events can help you analyze the root cause of failures, isolate performance bottlenecks, and test for compliance with company procedures.
Certain default events are tracked automatically after you enable Insight, but you must enable others in your application before they are tracked.
See the Insight documentation for more details.
## Best Practices for Business Events
Consider the following recommended practices when configuring business events tracking:
  * Enable default events only for processes that have particular value to you. To filter out unnecessary information, determine which stages within a business transaction you need to track, and enable tracking for only those stages.
  * Use custom events to track key process indicators: for example, "Total Order Amount" or "Tracking Number" to surface the high-level business activities in your flow.
  * Customize the transaction ID so that meaningful information, such as an order number, an employee identification number, or a shipment tracking number, is displayed for a transaction. This practice makes analysis and debugging easier and more intuitive at runtime.


## See Also
  *   * Transaction Management
  * Configure Default Events Tracking
  * Custom Business Event Component
MUnit Cookbook | MuleSoft Documentation
# MUnit Cookbook
Anypoint Code Builder 
Anypoint Studio 
This section links to examples that demonstrate common MUnit usages.
Example | Description  
---|---  
Mocking Resources for Your Tests |  Mocking test code for your MUnit tests.  
Mocking a Message Before and Inside a Foreach Processor |  Mocking a processor that can return different payloads.  
Testing and Mocking Errors |  Mocking expected errors in your code.  
Testing with Environment Properties |  Loading different environment values to your MUnit tests.  
Using Utility Classes From a Test |  Using custom Java classes in your MUnit tests.  
Configuring FTP Server Utility in an MUnit Test |  Configuring an FTP utility to test your FTP server connections.  
Configuring DB Server Utility in an MUnit Test |  Configuring a database utility to test your database connections.  
Patching the Embedded Mule Runtime Engine Version |  Configuring MUnit to run against a patched Mule runtime engine version.  
Test Domain-Based Applications |  Testing Mule applications that inherit a Mule domain.  
Testing a Flow with a Scheduler Source |  Testing a flow that is triggered by a scheduler.  
Recording a Test from an Exchange Example |  Using the MUnit test recorder.  
Testing a Processor That Stores Data in a Target Variable |  Ensuring that the assertions check the content of the stored variable.
MuleSoft AI Chain Connector 1.0 XML and Maven Support | MuleSoft Documentation
# MuleSoft AI Chain Connector 1.0 XML and Maven Support
Although you can manually code a Mule app in XML, it is more efficient to use Anypoint Code Builder or Studio:
  * If you manually code a Mule runtime engine (Mule) app in XML, either from the Anypoint Code Builder or Studio XML editor, or from a text editor, you can access the connector from your app by adding reference statements to both your XML Mule flow and the Apache Maven `pom.xml` file.
  * If you add the connector in Anypoint Code Builder or Studio, the XML is automatically populated the code with the connector’s namespace and schema location and it also adds a dependency to the `pom.xml` file.


## Add a Namespace for the Connector
Paste the following code inside the `mule` tag of the header of your configuration XML:
```
http://www.mulesoft.org/schema/mule/ms-aichain
http://www.mulesoft.org/schema/mule/ms-aichain/current/mule-ms-aichain.xsd
```

This example shows how the namespace statements are placed in the `<mule>` XML block:
```
<mule xmlns:ms-aichain="http://www.mulesoft.org/schema/mule/ms-aichain"
  xmlns:http="http://www.mulesoft.org/schema/mule/http"
	xmlns="http://www.mulesoft.org/schema/mule/core"
	xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.mulesoft.org/schema/mule/core
	http://www.mulesoft.org/schema/mule/core/current/mule.xsd
  http://www.mulesoft.org/schema/mule/http
	http://www.mulesoft.org/schema/mule/http/current/mule-http.xsd
  http://www.mulesoft.org/schema/mule/ms-aichain
	http://www.mulesoft.org/schema/mule/ms-aichain/current/mule-ms-aichain.xsd">
```

## Add a POM File Dependency
The Apache Maven `pom.xml` file generated by Anypoint Code Builder and Studio contains dependencies for a Mule app. If you code a Mule app manually, include this XML snippet in your `pom.xml` file to enable access to this connector:
```
<dependency>
 <groupId>com.mulesoft.connectors</groupId>
 <artifactId>mule4-aichain-connector</artifactId>
 <version>x.x.x</version>
 <classifier>mule-plugin</classifier>
</dependency>
```

Replace `x.x.x` with the version that corresponds to the connector you are using.
To get the most up-to-date `pom.xml` file information:
  1. Go to Anypoint Exchange.
  2. In Exchange, click **Login** and supply your Anypoint Platform username and password.
  3. In Exchange, search for `muleSoft ai chain`.
  4. Select the connector.
  5. Click **Dependency Snippets** near the upper right of the screen.


## See Also
  * MuleSoft AI Chain Connector Overview
  * MuleSoft AI Chain Connector Reference
  * MuleSoft AI Chain Connector - Additional Configuration
Cannot Create Applications When Application Limit is Reached | MuleSoft Documentation
# Cannot Create Applications When Application Limit is Reached
This issue can occur if the maximum number of 10,0000 client applications is reached. To resolve this issue, check for inactive client applications and revoke access. If you have a significant number of inactive client applications, contact your customer success partner.
Amazon SNS 4.7 Additional Configuration Information | MuleSoft Documentation
# Amazon SNS 4.7 Additional Configuration Information
## IAM User Permissions
To use Amazon SNS Connector for an AWS Identity and Access Management (IAM) user, that user must:
  * Be a trusted entity for a specific role with rights to perform the Amazon Security Token Service `AssumeRole` action.
  * Have at least an `AmazonSNSReadOnlyAccess` policy to perform all SNS Connector read operations.
  * Have an `AmazonSNSFullAccess` policy to perform all SNS Connector operations.


## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Compression Module XML and Maven Support | MuleSoft Documentation
# Compression Module XML and Maven Support
Although you can manually code a Mule app in XML, it is more efficient to use Anypoint Studio.
If you manually code a Mule runtime engine (Mule) app in XML, either from the Anypoint Studio XML editor or from a text editor, you can get access to the connector in your app by adding reference statements to both your XML Mule flow and the Apache Maven `pom.xml` file.
When you add the connector in Studio, Studio automatically populates the XML code with the connector’s namespace and schema location. It also adds a dependency to the `pom.xml` file.
## Add a Namespace for the Connector
Paste the following code inside the `<mule>` tag of the header of your configuration XML:
```
http://www.mulesoft.org/schema/mule/compression
http://www.mulesoft.org/schema/mule/compression/current/mule-compression.xsd
```

This example shows how the namespace statements are placed in the `<mule>` XML block:
```
<mule xmlns:compression="http://www.mulesoft.org/schema/mule/compression"
	xmlns:ee="http://www.mulesoft.org/schema/mule/ee/core"
	xmlns:http="http://www.mulesoft.org/schema/mule/http"
	xmlns:file="http://www.mulesoft.org/schema/mule/file"
	xmlns="http://www.mulesoft.org/schema/mule/core"
	xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.mulesoft.org/schema/mule/core
	http://www.mulesoft.org/schema/mule/core/current/mule.xsd
	http://www.mulesoft.org/schema/mule/file
	http://www.mulesoft.org/schema/mule/file/current/mule-file.xsd
	http://www.mulesoft.org/schema/mule/http
	http://www.mulesoft.org/schema/mule/http/current/mule-http.xsd
	http://www.mulesoft.org/schema/mule/ee/core
	http://www.mulesoft.org/schema/mule/ee/core/current/mule-ee.xsd
	http://www.mulesoft.org/schema/mule/compression
	http://www.mulesoft.org/schema/mule/compression/current/mule-compression.xsd">
```

## Add a POM File Dependency
The Apache Maven `pom.xml` file generated by Anypoint Studio contains dependencies for a Mule app. If you code a Mule app manually, include this XML snippet in your `pom.xml` file to enable access to this connector:
```
<dependency>
 <groupId>org.mule.modules</groupId>
 <artifactId>mule-compression-module</artifactId>
 <version>x.x.x</version>
 <classifier>mule-plugin</classifier>
</dependency>
```

Replace `x.x.x` with the version that corresponds to the connector you are using.
To obtain the most up-to-date `pom.xml` file information:
  1. Go to Anypoint Exchange.
  2. In Exchange, click **Login** and supply your Anypoint Platform username and password.
  3. In Exchange, search for `compression`.
  4. Select the connector.
  5. Click **Dependency Snippets** near the upper right of the screen.


## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Deployment Properties for Mule Applications | MuleSoft Documentation
# Deployment Properties for Mule Applications
Cloud IDE 
Desktop IDE 
When deploying a Mule application to CloudHub, Anypoint Code Builder relies on a configuration in `deploy.json`. Mule applications are integration or implementation projects.
Example:
```
{
 "runtime": "4.7-e-java17",
 "workerSize": 0.1,
 "applicationName": "my-integration-app",
 "workers": 1,
 "autoStart": true
}
```

The `deploy.json` and `deploy_ch2.json` files contain the following properties for deployments of Mule applications to CloudHub and CloudHub 2.0, respectively, from Anypoint Code Builder.
Property | Description | Host  
---|---|---  
Provides the Mule runtime version used by the project. |  CloudHub or CloudHub 2.0  
Sets the worker memory relative to a single worker or a number of available workers. The default is `0.1`. For more information, see CloudHub Workers in the CloudHub documentation.  
Sets the replica specific amount of memory capacity and processing power. The default value is `0.1`. For more information, see CloudHub 2.0 Replicas in the CloudHub 2.0 documentation. |  CloudHub 2.0  
`applicationName` |  Provides the hyphenated, lowercase name of the Mule application. |  CloudHub or CloudHub 2.0  
Sets the number of Mule runtime instances for running this Mule application. The default is `1`. For more information, see CloudHub Workers in the CloudHub documentation.  
Sets dedicated instances of Mule runtime engine for running this Mule application. The default is `1`. For more information, see CloudHub 2.0 Replicas in the CloudHub 2.0 documentation.  
Indicates whether to start the application automatically after the deployment process completes. The default value is `true`. |  CloudHub or CloudHub 2.0  
`deploymentModel` |  Indicates the model by which you want the replicas of your application to be updated or redeployed. The default value is `rolling`. For more information, see Rolling Update vs. Recreate Deployment Model in the CloudHub 2.0 documentation. |  CloudHub 2.0  
`ObjectStoreV2` |  Indicates whether Object Store v2 is enabled for this application. The default value is `true`. For more information, see Object Store v2 Overview |  CloudHub or CloudHub 2.0  
## See Also
  * Deploying Mule Apps to CloudHub and CloudHub 2.0
Maintenance and Upgrade Policy | MuleSoft Documentation
# Maintenance and Upgrade Policy
All maintenance to the Runtime Manager console, platform services, and worker cloud (see CloudHub Architecture) is performed during the maintenance windows specified in the Status page, except for critical security issues, which are fixed immediately.
MuleSoft policy is to perform all maintenance transparently and without any downtime to your integrations running in the worker cloud wherever possible. In cases where downtime for the console, platform services, or workers is unavoidable, MuleSoft communicates these maintenance windows at least eight hours in advance and typically seven days in advance, with the exception of critical security patches, which might be fixed immediately.
View the current status and detailed service history for the Runtime Manager console, CloudHub platform services, and the CloudHub worker cloud:
  * US: status.mulesoft.com
  * EU: eu1-status.mulesoft.com
  * MuleSoft Government Cloud: gov-status.mulesoft.com


## See Also
  * Product Versioning and Back Support Policy
Azure Key Vault Properties Provider 2.0 | MuleSoft Documentation
# Azure Key Vault Properties Provider 2.0
Azure Key Vault Properties Provider is a configuration that enables you to retrieve your secrets from a secure Azure cloud service before your Mule app runs.
For information about compatibility and fixed issues, refer to the Azure Key Vault Properties Provider Release Notes.
## Before You Begin
To use this properties provider, you must be familiar with:
  * The Azure Key Vault API
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * How to create a Mule app using Anypoint Studio


Before creating an app, you must have:
  * Mule Enterprise Edition
  * Credentials to access the Azure Key Vault target resource
  * Anypoint Platform
  * Anypoint Studio version 7.3.5 or later


## Common Use Cases for the Properties Provider
With Azure Key Vault Properties Provider, secrets can be retrieved in the pre-runtime phase, which means secrets are populated before the Mule app is deployed.
## Connection Types
Connectors can use the Azure Key Vault Properties Provider in their configurations, for example:
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * Azure Key Vault Properties Provider Reference
  * MuleSoft Help Center
Salesforce Commerce Cloud B2C Data Connector XML and Maven Support | MuleSoft Documentation
# Salesforce Commerce Cloud B2C Data Connector XML and Maven Support
Although you can manually code a Mule app in XML, it is more efficient to use Anypoint Studio:
  * If you manually code a Mule runtime engine (Mule) app in XML, either from the Anypoint Studio XML editor or from a text editor, you can access the connector from your app by adding reference statements to both your XML Mule flow and the Apache Maven `pom.xml` file.
  * If you add the connector in Studio, Studio automatically populates the XML code with the connector’s namespace and schema location and it also adds a dependency to the `pom.xml` file.


## Add a Namespace for the Connector
Paste the following code inside the `mule` tag of the header of your configuration XML:
```
http://www.mulesoft.org/schema/mule/commerce-cloud-dataapi
http://www.mulesoft.org/schema/mule/commerce-cloud-dataapi/current/mule-commerce-cloud-dataapi.xsd
```

This example shows how the namespace statements are placed in the `<mule>` XML block:
```
<mule xmlns:commerce-cloud-dataapi="http://www.mulesoft.org/schema/mule/commerce-cloud-dataapi"
xmlns:http="http://www.mulesoft.org/schema/mule/http"
	xmlns="http://www.mulesoft.org/schema/mule/core"
	xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.mulesoft.org/schema/mule/core
	http://www.mulesoft.org/schema/mule/core/current/mule.xsd
	http://www.mulesoft.org/schema/mule/http
	http://www.mulesoft.org/schema/mule/http/current/mule-http.xsd
	http://www.mulesoft.org/schema/mule/commerce-cloud-dataapi
	http://www.mulesoft.org/schema/mule/commerce-cloud-dataapi/current/mule-commerce-cloud-dataapi.xsd">
</mule>
```

## Add a POM File Dependency
The Apache Maven `pom.xml` file generated by Anypoint Studio contains dependencies for a Mule app. If you code a Mule app manually, include this XML snippet in your `pom.xml` file to enable access to this connector:
```
<dependency>
  <groupId>com.mulesoft.connectors</groupId>
  <artifactId>commerce-cloud-dataapi</artifactId>
  <version>x.x.x</version>
  <classifier>mule-plugin</classifier>
</dependency>
```

Replace `x.x.x` with the version that corresponds to the connector you are using.
To obtain the most up-to-date `pom.xml` file information:
  1. Go to Anypoint Exchange.
  2. In Exchange, click **Login** and supply your Anypoint Platform username and password.
  3. In Exchange, search for `commerce cloud b2c`.
  4. Select the connector.
  5. Click **Dependency Snippets** near the upper right of the screen.


## Next Step
After completing your namespace and `pom.xml` file, you can try the Example.
## See Also
  * MuleSoft Help Center
WSS Module 1.2 | MuleSoft Documentation
# WSS Module 1.2
Anypoint WSS module enables you to process and validate an inbound SOAP request against a given Web Service Security (WSS) extension configuration to, for example, validate the request’s signature, perform an LDAP authentication, or decrypt the inbound message. The WSS module also enables you to sign your response by adding a WSS header to it, or to encrypt your outbound message.
For information about compatibility and fixed issues, see WSS Module Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The WSS module’s API
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * How to create a Mule app using Anypoint Studio


Before creating an app, you must have access to:
  * The WSS module target resource
  * Anypoint Platform
  * Anypoint Studio version 7.x or later
  * Web Services Security (WSS) extension for SOAP


## Common Use Cases For the Connector
The WSS module enables you to validate WSS headers in inbound SOAP requests to your application to:
  * Decrypt a SOAP envelope according to the encryption information
  * Validate a signature
  * Verify the freshness of the message using `timestamp` information
  * Verify the `Username` and `Password` credentials of `UsernameToken`
  * Verify the `LDAP` credentials of `UsernameToken`
  * Determine whether `UsernameToken` is expired
  * Determine whether a SAML assertion expired
  * Verify the signature of a SAML assertion.
  * Verify that a SAML assertion has a specific confirmation method.


Using the WSS module, you can also add WSS headers to your outbound SOAP response to:
  * Encrypt some or all of your SOAP message content
  * Sign your SOAP message


See the WSS Module Examples section for detailed examples.
## Audience
  * New user
To create your Mule app, see:
    * Studio Configuration to help extend your understanding of WSS module.
    * Examples, with use case information for the connector
  * Advanced user
Read the following:
    * XML and Maven Support
    * Examples, with use case information for the connector


## Next Step
After you complete the prerequisites and experiment with templates and examples, you are ready to create an app and configure the connector using Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  *   * MuleSoft Help Center
capitalize | MuleSoft Documentation
# capitalize
## capitalize(text: String): String
Capitalizes the first letter of each word in a string.
The function treats every non-alphabetic character as a separator and replaces underscores with spaces. For example, `capitalize("a*s_b’s")` results in `"A*S B’S"`.
### Parameters
Name | Description  
---|---  
The string to capitalize.  
### Example
This example capitalizes a set of strings.
#### Source
```
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
 "a" : capitalize("customer"),
 "b" : capitalize("customer_first_name"),
 "c" : capitalize("customer NAME"),
 "d" : capitalize("customerName"),
 "e" : capitalize("a*s_b’s")
}
```

#### Output
```
{
 "a": "Customer",
 "b": "Customer First Name",
 "c": "Customer Name",
 "d": "Customer Name",
 "e": "A*S B’S"
}
```

## capitalize(text: Null): Null
Helper function that enables `capitalize` to work with a `null` value.
Comparison of Mule 3 and Mule 4 Policies | MuleSoft Documentation
# Comparison of Mule 3 and Mule 4 Policies
Policies in Mule versions 3 and 4 differ based on how they are implemented and the level of support provided.
Feature | Mule 3 | Mule 4  
---|---|---  
Default expression language |  Uses MEL expressions |  Uses DataWeave 2.0  
External dependencies, such as libraries or resources cannot be included in the policy and must be available in the runtime |  Policies can package resources, eliminating the dependency with the runtime.  
Performance |  Partial non-blocking processing |  Full non-blocking processing  
Not supported |  Fully supported and enforced  
Execution order |  Throttling, Rate Limiting, and CORS executed first. Other policies can be reordered |  All policies, except CORS, can be reordered  
Resource-level support |  Restricted to RAML-based APIs |  Support extended to HTTP-based APIs and RAML-based APIs  
Class loader isolation |  Not supported |  Supported between application libraries, extensions, and runtime libraries  
Policy addition |  Spike Control  
Authentication support |  HTTP Basic Authentication based on the Simple Security Manager or LDAP Security Manager policies |  Simple Basic Authentication and LDAP Basic Authentication policies, including Security Manager configuration  
Rate Limiting support |  Non-configurable quota shared between nodes and configured clusters. | 
  * Configurable quota, including:
    * Ability to expose headers
    * Ability to clusterize the quota

  
Configuration |  Header propagation occurs by default |  Header propagation does not occur by default, but can be configured for Token Enforcement, Rate Limiting, and other default policies  
Customization |  Support to build custom policy templates based on XML schema language | 
  * Powerful engine for building custom policies, using the XML schema language
  * Improved error handling
  * Support for all MuleSoft components
  * Isolation between policies and application
  * Can be applied to outbound requests, coming back from the backend services
  * Can package additional libraries
  * Versioning support provided for policies when uploaded to Exchange.

  
The implementation and user experience for custom policies differs considerably in versions Mule 3 and Mule 4. For more information about custom policies for your Mule version, see the respective Custom policies section.
## See Also
  *
with | MuleSoft Documentation
# with
## with<V, U, R, X>(toBeReplaced: ((V, U) -> R) -> X, replacer: (V, U) -> R): X
Helper function that specifies a replacement element. This function is used with `replace`, `update` or `mask` to perform data substitutions.
### Parameters
Name | Description  
---|---  
`toBeReplaced` | The value to be replaced.  
The replacement value for the input value.  
### Example
This example replaces all numbers in a string with "x" characters. The `replace` function specifies the base string and a regex to select the characters to replace, and `with` provides the replacement string to use.
#### Source
```
%dw 2.0
output application/json
---
{ "ssn" : "987-65-4321" replace /[0-9]/ with("x") }
```

#### Output
```
{ "ssn": "xxx-xx-xxxx" }
```
RPA Bot Overview | MuleSoft Documentation
# RPA Bot Overview
RPA Bots are software robots that carry out any RPA processes assigned to them. To execute the processes, RPA Bots require a computer where the applications required for the processes are installed, along with specific configurations for the execution and specific instructions, which are the activities created in RPA Builder for each process step.
The Bot Management module in RPA Manager enables you to manage your bots. Every Bot is registered through an API key. After the installation, the bot connects with RPA Manager automatically at defined intervals. You can then assign licenses and service times to the bot, deploy processes for the bot to execute, and monitor the bot’s status and the results of the process runs it carries out.
## See Also
  *
round | MuleSoft Documentation
# round
## round(number: Number): Number
Rounds a number up or down to the nearest whole number.
### Parameters
Name | Description  
---|---  
The number to evaluate.  
### Example
This example rounds decimal numbers to the nearest whole numbers.
#### Source
```
%dw 2.0
output application/json
---
[ round(1.2), round(4.6), round(3.5) ]
```

#### Output
Handling Expired Access Tokens | MuleSoft Documentation
# Handling Expired Access Tokens
Most services providers return (or should return) access tokens with a limited lifespan. In general, access tokens usually expire about 30 to 60 minutes after being issued, although this is not a standard that strictly enforced by providers.
In the same way, providers often provide a refresh token with the access token. The refresh token is a second token that can be used to replace an expired access token with a fresh one, without the need to perform the dance again.
Unfortunately, there is no enforced standard that the SDK can use to automatically detect a token expiration scenario and obtain a new one. Different APIs communicate that in different ways. That is why the `AccessTokenExpiredException` exception exists.
```
public void someOperation(@Connection SalesforceRestClient client) { **(1)**
  Response response = client.performSomeOperation(); **(2)**
  if (response.getStatusCode() == 401) { **(3)**
    throw new AccessTokenExpiredException(); **(4)**
  }
}
```

The example above uses an imaginary REST client to perform an operation. It assumes that this rest client was created through a `ConnectionProvider` annotated with `@AuthorizationCode`.  
---  
It performs the operation and gets a `Response` object that contains information of the HTTP call.  
The example assumes that a status code of 401 (`unauthorize`) means that the token has expired.  
It throws the `AccessTokenExpiredException`.  
When the SDK detects this exception, it automatically performs the refresh dance and retries the operation with a new access token.
Note that in real life, different APIs notify you of the access token expiration in different ways. Some give you clients that throw exceptions, while others give you custom messages. You need to research the remote API to determine the best way to account for this.
Streaming | MuleSoft Documentation
# Streaming
In Mule 4, streaming allows automatic and transparent repeatable streams (see About Streaming below for details).
There are two types of streaming:
  *   * 

## See Also
MUnit Event Processors | MuleSoft Documentation
# MUnit Event Processors
Anypoint Code Builder 
Anypoint Studio 
MUnit has a set of dedicated event processors to validate, assert, and mock the content and status of the Mule event so you can run automatic tests against your Mule applications.
## See Also
  * Assertion Event Processor
  * Set Event Processor
  * Mock When Event Processor
  * Verify Event Processor
  * Spy Event Processor
  * Storage Event Processors
  * Queue Event Processors
indexOf | MuleSoft Documentation
# indexOf
## indexOf(array: Array, value: Any): Number
Returns the index of the _first_ occurrence of the specified element in this array, or `-1` if this list does not contain the element.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
The array of elements to search.  
The value to search.  
### Example
This example shows how `indexOf` behaves given different inputs.
#### Source
```
%dw 2.0
output application/json
---
{
 present: ["a","b","c","d"] indexOf "c",
 notPresent: ["x","w","x"] indexOf "c",
 presentMoreThanOnce: ["a","b","c","c"] indexOf "c",
}
```

#### Output
```
{
  "present": 2,
  "notPresent": -1,
  "presentMoreThanOnce": 2
 }
```

## indexOf(theString: String, search: String): Number
Returns the index of the **first** occurrence of the specified String in this String.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
`theString` | The string to search.  
The string to find within `theString`.  
### Example
This example shows how the `indexOf` behaves under different inputs.
#### Source
```
%dw 2.0
output application/json
---
{
 present: "abcd" indexOf "c",
 notPresent: "xyz" indexOf "c",
 presentMoreThanOnce: "abcdc" indexOf "c",
}
```

#### Output
```
{
  "present": 2,
  "notPresent": -1,
  "presentMoreThanOnce": 2
 }
```

## indexOf(array: Null, value: Any): Number
Helper method to make indexOf null friendly
_Introduced in DataWeave version 2.4.0._
X12 EDI Connector 2.17 Control Numbers | MuleSoft Documentation
# X12 EDI Connector 2.17 Control Numbers
Using the Write operation in the Anypoint Connector for X12 EDI Connector (X12 EDI Connector), you can generate control numbers on the generated X12 payload by:
  * Managing global control numbers through control number keys
  * Managing identifier combination control numbers
  * Using your own control number


## Manage Global Control Numbers Through Control Number Keys
If your organization or your trading partner have must maintain unique interchange, group, or transaction set control numbers across different identifier combinations and document types:
  * Set the configuration `Use supplied values` to `false`.
  * Leverage the control number key configurations (at the configuration level or operation level) to set a key unique to the partner.
By default, the control number key configurations pass dynamically at the operation level. You can then use this group control number key across different identifiers and transaction types for the same partner.


## Manage Identifier Combination Control Numbers
If you want the connector to automatically maintain control number sequencing based on the sender/receiver identifiers and you do not require global control numbers at a partner level, then set the Write configuration `Use supplied values` to `false`. When no value passes into the optional interchange, group, or transaction number key configurations, the sender/receiver identifier combination is the default.
## Use Your Own Control Number
If you must generate the control numbers and use them on the EDI payload, you can set the parameter `Use supplied values` to `true`, and map the control number on the payload in the DataWeave map.
Clear Web Element | MuleSoft Documentation
# Clear Web Element
This _Web Automation_ object is used to clear the content of fields on a website or in a web application. _Clear Element_ can be used on text entry fields. It does not have any additional properties or wizard functions.
## Properties
**Webelement Find Options**
  * **Screenshot The recorded screenshot is displayed here.**
  * **Use Regex to find Window (Enable Regex) Use this function if you want to use Regex when searching the window.**


Other Properties that are the same in all action steps in the _Web Automation_ are described in the section on **Common Properties**. For reasons of clarity they are not shown here.
## Inbound Variables
**Element XPath**
**Window Title**
## Outbound Variables
The action step _Clear Element_ possesses no outbound variables.
Troubleshooting Registration Issues | MuleSoft Documentation
# Troubleshooting Registration Issues
When registering Anypoint Flex Gateway, you might encounter issues caused by incorrect access permissions, and so on. The following topics provide possible causes for registration issues and describe how to troubleshoot:
  * Performing Registration as a User Without Necessary Access Permissions


## Performing Registration as a User Without Necessary Access Permissions
Executing the registration command without having correct permissions can result in an error:
```
Couldn't execute register command successfully: rpc error: code = Internal desc = handler returned neither error nor response message
```

### Cause
This issue occurs when the credentials that you provide for registration do not have the required permissions.
### Solution
To resolve this error, perform the following steps:
  1. Navigate to **Access Management** as the organization administrator.
  2. Select **Users** from the main menu.
  3. Select the target organization user from the **Users** menu.
  4. From the **Permissions** tab, select **Runtime Manager**.
  5. Specify the environment in which to apply your permissions.
  6. Select the following from the **Select access** dropdown menu:
     * _Manage Servers_
     * _Read Servers_
  7. Click the **+** button.


Re-running the registration command should now result in success.
Re-ordering Policies | MuleSoft Documentation
# Re-ordering Policies
This procedure describes how to re-order policies provided by Anypoint Platform other than CORS, Throttling, and Rate Limiting policies. These policies have the highest precedence. If you apply these policies, you cannot set other policies at a higher level.
You can set the order of execution of policies for a custom policy by configuring the policy tag or the before or after blocks.
  1. In Anypoint Platform, click **API Manager** , and in API Administration, click the **API version**.
  2. On the API version details page, select **Policies**.
  3. At the top of the list of any applied policies, click **Edit Policy Order** to change the priority.
  4. In **Reorder Applied Policies** , use the up and down arrows to rearrange the order of policies. For example, if you apply Rate Limiting, IP Allowlist, and XML Threat Protection policies, you can reorder only IP Allowlist and XML Threat Protection. This is because Rate Limiting takes precedence over other policies.
  5. Click **Apply order**.


## See Also
  * Disabling, Editing, or Removing a Policy
  *