BassemE/mulesoft-documentation-embeddings huggingface dataset:
DataWeave Release Notes | MuleSoft Documentation
# DataWeave Release Notes
DataWeave is the programming language designed by MuleSoft for data transformation. It is also the expression language Mule runtime engine uses to configure components and connectors.
Release notes for each DataWeave version include bug fixes, compatibility information, and patch update release details, in addition to new features and other information about DataWeave releases:
  *   *   * DataWeave 2.7.0 (This version of the product has reached End of Life.)
  *   * DataWeave 2.5.0 (This version of the product has reached End of Life.)
  * 

## DataWeave and Mule
DataWeave 2.9.0 is bundled with the Mule 4.9.0 release. For details about the Mule release, see Mule Runtime Engine 4.9.0 Release Notes.
## DataWeave Extension Release Notes
DataWeave enables you to implement and test your custom DataWeave modules and mappings and package them into libraries that you can share and reuse through Anypoint Exchange.
The DataWeave extension to Visual Studio Code enhances productivity when you’re building DataWeave libraries.
  *
Zuora AQuA Examples | MuleSoft Documentation
# Zuora AQuA Examples
## Example: Retrieve Details for an Account
This example retrieves the account details for the specified account ID and returns them in JSON format.
## Studio Flows
  * HTTP **Listener** Accepts data from HTTP requests.
  * **Get last job completed** Anypoint Connector for Zuora AQuA connects with Zuora and executes a query to retrieve the account details for the specified account ID. Add the **Get last job completed** operation to return the details of the last completed job.
  * **Transform Message** Outputs the results of the **Get last job completed** operation in JSON format.


## XML Flows
Paste this XML code into Anypoint Studio to experiment with the example flow.
```
<?xml version="1.0" encoding="UTF-8"?>
<mule xmlns:ee="http://www.mulesoft.org/schema/mule/ee/core"
	 xmlns:http="http://www.mulesoft.org/schema/mule/http"
	 xmlns:mule-zuora-aqua-connector="http://www.mulesoft.org/schema/mule/mule-zuora-aqua-connector" 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/ee/core http://www.mulesoft.org/schema/mule/ee/core/current/mule-ee.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/core http://www.mulesoft.org/schema/mule/core/current/mule.xsd
http://www.mulesoft.org/schema/mule/mule-zuora-aqua-connector http://www.mulesoft.org/schema/mule/mule-zuora-aqua-connector/current/mule-mule-zuora-aqua-connector.xsd">
	<mule-zuora-aqua-connector:config name="Zuora_Connector_Config" doc:name="Zuora Connector Config" doc:id="47cc7910-f0dd-418e-87b0-a3e2e32469f3" >
		<mule-zuora-aqua-connector:basic-connection username="${config.username}" password="${config.password}" baseUri="${config.baseUri}"/>
	</mule-zuora-aqua-connector:config>
	<http:listener-config name="HTTP_Listener_config" doc:name="HTTP Listener config" doc:id="2b371bd6-fa5e-4980-bdf4-e3edd7127d51">
		<http:listener-connection host="0.0.0.0" port="8081" />
	</http:listener-config>
	<configuration-properties doc:name="Configuration properties" doc:id="369942a7-1ad3-495d-b926-0efd29f3dfcc" file="application.properties" />
	<flow name="aqua-api-get-last-completed-job-demo-flow" doc:id="7396ef55-2a5b-44c9-9b5d-7adc7360cba6" >
		<http:listener doc:name="Listener" doc:id="54613a79-d327-41e8-bb3c-75f6f59acae4" config-ref="HTTP_Listener_config" path="/get-last-completed-job"/>
		<mule-zuora-aqua-connector:get-v1-batch-query-jobs-partner-project-by-partner-project doc:name="Get last job completed" doc:id="40c9467e-4b06-4781-b9e7-dcf34837d8f7" project="#[payload.project]" config-ref="Zuora_Connector_Config" partner="#[payload.partner]"/>
		<ee:transform doc:name="Transform Message" doc:id="5a72b67b-9a1c-4f4e-897c-07fa42a698ef" >
			<ee:message >
				<ee:set-payload ><![CDATA[%dw 2.0
output application/json
---
{
}]]></ee:set-payload>
			</ee:message>
		</ee:transform>
	</flow>
</mule>
```

## See Also
  * MuleSoft Help Center
  * Knowledge Base Articles
To Create a Server (EU Control Plane) | MuleSoft Documentation
# To Create a Server (EU Control Plane)
From the EU control plane, you can only create servers using Mule Runtime Agent version 1.9.2 and later. Ensure that you have installed this version in your Mule runtime environment.   
---  
To manage a remote server from the EU control plane you must run the `amc_setup` script to create a server by configuring the Runtime Manager Agent to communicate with Runtime Manager.
The procedures for creating a server are similar to those for creating a server in the US control plane. The difference is that you must use the `--region eu1` option when running `amc_setup` as shown in the following example:
```
./amc_setup --region eu1 -H 1234321xyzabc----16 your-eu-server-name
```

This flag ensures that the server connects to Runtime Manager in the EU control plane. When you click Add Server in the Runtime Manager > Servers tab, Runtime Manager in the EU control plane automatically inserts this flag in the generated script.
## Ports, IP Addresses, and Hostnames to Allowlist
In your network, you might need to allowlist ports, IP Addresses, and hostnames of various parts of the Anypoint Platform to allow the Runtime Manager Agent in a customer-hosted Mule runtime to communicate with MuleSoft-managed Anypoint Platform APIs and services. See Ports, IP Addresses, and Hostnames to Allowlist section of the To Install and Configure the Runtime Manager Agent documentation for general information.
For EU Control Plane, you must allowlist the following ports, IP addresses, and hostnames:
### Ports
Table 1. Ports, IP Addresses, and Hostnames to Allowlist **eu1.anypoint.mulesoft.com**  
---  
**analytics-ingest.eu1.anypoint.mulesoft.com**  
**runtime-manager.eu1.anypoint.mulesoft.com**  
### Dynamic IP Addresses
Some IP addresses used by Anypoint services are automatically assigned by the underlying cloud infrastructure, and therefore, might change in the future. For this reason, you should not implement an allowlist based on a specific IP address assigned to Anypoint services.
### Hostnames for Layer 7 Firewall Rules
Many firewall devices allow you to define Layer 7 Firewall Rules, in which you can filter by destination name or application type.
Include the following hostnames in your Layer 7 firewall rules:
Table 2. Hostnames Required in Firewall Rules **eu1.anypoint.mulesoft.com**  
---  
**analytics-ingest.eu1.anypoint.mulesoft.com**  
**runtime-manager.eu1.anypoint.mulesoft.com**  
## See Also
  * To Create a Server in Runtime Manager (Hybrid)
  * To Install and Configure the Runtime Manager Agent documentation
  * To Access the EU Control Plane
Monitoring Metrics from Dashboards | MuleSoft Documentation
# Monitoring Metrics from Dashboards
Dashboards in Anypoint Monitoring provide visibility into Mule apps and APIs that are deployed to your environments (for example, Production, Sandbox, or Design).
## Built-In Dashboards
Built-in dashboards contain graphs that plot current and historical data collected over a given time and date period. There is a built-in dashboard for each Mule application and API in each environment.
Figure 1. Example: Built-in Dashboard for a Mule Application
## Custom Dashboards
Availability: Advanced and Titanium tiers only  
---  
Custom dashboards in Anypoint Monitoring can bring together important metrics and data points that you need to see on one screen. You can specify the resources and metrics that you want to monitor, allowing you to:
  * Correlate diverse metrics
  * Perform comparative analysis
  * Differentiate between regular trends and anomalies
  * Isolate issues quickly


For example, you can compare live data with historic data to detect anomalies and expedite the troubleshooting process.
## Causes of No Data Points Messages for Dashboards
A dashboard in Anypoint Monitoring might return **No data points** instead of metrics. The following scenarios commonly cause the **No data points** message to appear:
  * You selected an incorrect time range.
For example, the app started yesterday, and you selected a day from the past week as your time range.
  * You removed the Monitoring property from the runtime.
  * The application for which you are trying to view metrics has stopped.
  * You selected a time range that is outside of the retention policy of a metric.
For example, API path or client IP metrics show only the last hour, and you selected yesterday as the time range.
  * You used an incorrect query.
For example, when using custom dashboards, you selected two app IDs at the same time using the query `WHERE app_id = app_1 AND app_id = app_2`.


## See Also
  * Built-in Application Dashboards
  * Configuring Custom Dashboards
  * API Analytics Dashboard
LDAP Connector 3.6 - XML and Maven Support | MuleSoft Documentation
# LDAP Connector 3.6 - 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 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/ldap
http://www.mulesoft.org/schema/mule/ldap/current/mule-ldap.xsd
```

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

## Add a POM File Dependency
The Apache Maven `pom.xml` file generated by Anypoint Studio contains dependencies for a Mule app. When 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>mule-ldap-connector</artifactId>
 <version>x.x.x</version>
 <classifier>mule-plugin</classifier>
</dependency>
```

Replace `<version>` 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 `ldap`.
  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 Examples.
## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Protecting Mule App Property Values Using RTFCTL | MuleSoft Documentation
# Protecting Mule App Property Values Using RTFCTL
Secure application properties are added in the Runtime Fabric cluster locally, stored securely, and scoped per environment. These properties are accessible in unencrypted form by Mule applications deployed in the scoped environment as custom properties.
Runtime Fabric protected properties always take precedence over application-level properties.
## Install rtfctl
The `rtfctl` utility is required to manage protected properties on Runtime Fabric locally. Follow the steps to install rtfctl before continuing with managing secure properties.
## Set Secure Properties
  1. Log into a controller node where `rtfctl` is installed.
  2. Run the following command to set a secure property to the Runtime Fabric under a specific environment, substituting the placeholder fields:
```
rtfctl apply secure-property --key <key> --value <value> --app-namespace <app_namespace> --namespace <rtf_namespace>
```

     * **< key>**: The key for the secure property used in the Mule application to reference the value.
     * **< value>**: The value for the secure property to store.
     * **< app_namespace>**: The Anypoint environment to scope this secure property to. Only applications deployed to this environment have access to this secure property.
     * **< rtf_namespace>**:System namespace scope, defaults to `rtf`.


## View Secure Properties
  1. Log into a controller node where `rtfctl` is installed.
  2. Run the following command to view the secure properties applied to the Runtime Fabric under a specific environment, substituting the placeholder fields:
```
sudo ./rtfctl get secure-properties -n <environment_id>
```

     * **< environment_id>**: The Anypoint environment ID to list the secure properties under.


## Access Secure Properties
You can access secure properties from inside your Mule application using `$key`, which is the key provided in the `rtfctl apply` command. You can retrieve the key the same way you retrieve any other configuration property.
## Remove Secure Properties
  1. Log into a controller node where `rtfctl` is installed.
  2. Run the following command to remove a secure property from the Runtime Fabric in a specific namespace:
```
sudo ./rtfctl delete secure-property <my_key> -n <namespace>
```

     * **< my_key>**: The key used in the Mule application to reference the secure property.
     * **< namespace>**: The namespace in which the secure property applies.


## See Also
  *   * Manage Proxies Used by Runtime Fabric
B2C Shop Connector 2.1 | MuleSoft Documentation
# B2C Shop Connector 2.1
No further updates or new versions are planned for this connector. Use Anypoint Connector for HTTP (HTTP Connector) instead. Refer to the migration guide.   
---  
Anypoint Connector for Salesforce Commerce Cloud B2C Shop APIs (B2C Shop Connector) enables a client to interact with the Commerce Cloud B2C API system as either a shop customer or as an agent shopping on behalf of a customer.
For information about compatibility and fixed issues, see Commerce Cloud B2C Shop Connector Release Notes.
Salesforce Commerce Cloud B2C Data Connector and Salesforce Commerce Cloud B2C Shop Connector cannot be run in the same application.   
---  
## Before You Begin
To use this connector, you must be familiar with:
  * The Salesforce Commerce Cloud Shop 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 Commerce Cloud B2C Shop Connector target resource
  * Anypoint Platform
  * Anypoint Studio version 7.1 or later
  * Salesforce-provided Commerce Cloud credentials (such as Client Id, Client Secret, and Scopes) necessary to access Shop API.


## Common Uses for the Connector
These are some common use cases for B2C Shop Connector:
  * Create a basket
  * Add items to a basket
  * Add shipping details
  * Place an order


Check the Examples for a simple use case.
## Audience
  * New user
To create your Mule app, see:
  * Using Anypoint Studio to Configure Commerce Cloud B2C Connector
  * Advanced user
  * Read the following:
  * XML and Maven Support


## Connection Types
B2C Shop Connector connections use the following authentication types:
  * Customers Auth Uses a Bearer Token, which is generated using the **Authorize Customer** operation
  * OAuth 2.0 Delegates user authentication to the service hosting the user account


For information about configuring authentication types, see Using Anypoint Studio to Configure Commerce Cloud B2C Shop Connector.
## Next Step
After you complete the prerequisites and try the 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
baseTypeOf | MuleSoft Documentation
# baseTypeOf
## baseTypeOf(t: Type): Type
Returns an the base type of the given type.
_Introduced in DataWeave version 2.3.0._
### Parameters
Name | Description  
---|---  
The type to check.  
### Example
This example shows how `baseTypeOf` behaves with different inputs.
#### Source
```
%dw 2.0
import * from dw::core::Types
type AType = String {format: "YYYY-MM-dd"}
output application/json
---
{
  a: baseTypeOf(AType)
}
```

#### Output
```
{
 "a": "String"
}
```
LDAP Connector 3.5 | MuleSoft Documentation
# LDAP Connector 3.5
Anypoint Connector for Lightweight Directory Access Protocol (LDAP) is a public standard that facilitates maintenance and access to distributed directories (such as network user privilege information) over an Internet Protocol (IP) network.
LDAP Connector supports both LDAP over SSL and LDAP over TLS.
Many LDAP servers are included in free-use open source projects and packages. The particulars of installing, running, and configuring LDAP servers fall outside the scope of this document.
For information about compatibility and fixed issues, see the LDAP Connector Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The LDAP Connector’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:
  * Credentials to access an OpenLDAP instance that supports LDAP v3
  * Anypoint Platform
  * Anypoint Studio version 7.0 or later


## Common Use Cases For the Connector
Common use cases for LDAP Connector include:
  * Adding user accounts to Active Directory
You can add business users to Active Directory groups defined on the base distinguished name (DN).
  * Retrieving user attributes
You can retrieve the basic attributes of a business user such as a user’s e-mail or phone number.


## Connection Types
LDAP connector supports three types of connections:
  * Basic
Communications are not encrypted.
  * SSL
Communications are encrypted using Secure Sockets Layer (SSL).
  * TLS
Communications are encrypted using Transport Layer Security (TLS).


You can use Basic (username and password) authentication for each of these connection types.
For more information about configuring connection types and authentication, see Using Studio to Configure LDAP Connector.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * LDAP Connector Reference
  * MuleSoft Help Center
SAP SuccessFactors Connector 5.0 XML and Maven Support | MuleSoft Documentation
# SAP SuccessFactors Connector 5.0 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 install 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/successfactors
http://www.mulesoft.org/schema/mule/successfactors/current/mule-successfactors.xsd
```

This example shows how the namespace statements are placed in the `<mule>` XML block:
```
<mule xmlns:successfactors="http://www.mulesoft.org/schema/mule/successfactors" 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/successfactors http://www.mulesoft.org/schema/mule/successfactors/current/mule-successfactors.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>com.mulesoft.connectors</groupId>
 <artifactId>mule-sap-successfactors-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 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 `successfactors`.
  4. Select the **SuccessFactors Connector - Mule 4** connector.
  5. Click **Dependency Snippets** near the upper-right of the screen.


## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Promoting an API Instance to Another Environment | MuleSoft Documentation
# Promoting an API Instance to Another Environment
Before promoting an API instance to another environment, ensure that you have the `Manage APIs Configuration` permission.
To promote an entity, you must have permissions to view and manage the entity. For example, you must have the `View Policies` and `Manage Policies` permissions to promote a policy.
## Promote an API Instance from Another Environment
  1. Navigate to **Anypoint Platform** > **API Manager**.
  2. In **API Administration** , click **Add API** and select **Promote API from environment**.
  3. Select the **Source Environment**.
  4. Select the **API** by entering the name of the API into the search field.
  5. Select the **API Version**.
  6. Select the **API instance label**.
  7. Optionally, uncheck any of the **Include in Promotion** options you want to exclude.
  8. Click **Promote**.
  9. Review and update the Runtime & Endpoint Configuration details as needed and click **Save**.


Promoting an API instance affects only the API definition, not the existing deployed applications subscribed to the instance. After promoting an API, the **API Label** remains the same, but the **API Instance ID** changes.
For existing applications that must subscribe to a promoted API instance:
  1. Update the **API Instance ID** within the application.
  2. Update the application’s client ID and secret (because each environment has a different client ID and secret).


## See Also
  * Granting Permission to Access an environment
  *   * Creating an API instance on API Manager
Append to Array | MuleSoft Documentation
# Append to Array
Use this action step to append a value to an existing array variable.
## Properties
The Append to Array action step contains the common properties **Description** , **Error Handling** , and **Name**.
## Inbound Variables
  * **Array to be extended**
The base array to extend.
  * **Array to append**
The array to append to the base array.
Use the wizard to specify a single value, or an array of values, or to map a variable. When manually defining the array elements, use the comma (`,`) to separate the values. If you define strings that contain commas, enclose the strings with quotes (`"`). For example, `"Hello, this is a single value", This is another value, testValue`.


## Outbound Variables
  * **New Array Count**
Outputs the total number of elements in the base array after appending the data.
  * **Appended Element Count**
Outputs the number of elements appended to the base array.


## See Also
  *   *
Mule Runtime Release Notes | MuleSoft Documentation
# Mule Runtime Release Notes
Mule follows semantic versioning to denote major, minor, and patch releases.
MuleSoft releases enhance the quality, capabilities, and security of Mule runtime engine (Mule). To take advantage of these improvements, it is important to adopt a strategy for upgrading your Mule version and to regularly update patches of your Mule deployments with the latest bug fixes and security enhancements.
To upgrade to a new Mule version, see Mule Upgrades and Patch Updates.
## Mule 4 Release Notes
  * Mule Runtime 4.9.0 Release Notes


  * Mule Runtime 4.8.0 Release Notes


  * Mule Runtime 4.7.0 Release Notes (This version of the product has reached End of Life.)


  * Mule Runtime 4.6.0 Release Notes


  * Mule Runtime 4.5.0 Release Notes (This version of the product has reached End of Life.)


  * Mule Runtime 4.4.0 Release Notes


  * Mule Runtime 4.3.0 Release Notes


## Mule Upgrades and Patch Updates
For Mule 4 and Mule 3 upgrades and patch updates:
  *   * Edge and LTS Releases for Mule (for Mule versions 4.5 and later)
  * Mule Upgrade Tool (for upgrading standalone Mule 4 instances, including minor versions and patch updates)
  * Mule Upgrades and Patch Updates (overview)
  *   * Upgrading Mule Runtime Engine (Versions 4.x to 4.n)
  * Upgrading Mule Runtime Engine(Versions 3.x to 3.n)


## Mule Services
  * HTTP Service Release Notes - Mule 4
  * OAuth Service Release Notes - Mule 4
  * Scheduler Service Release Notes - Mule 4
  * Mule SOAP Service Release Notes - Mule 4


## Anypoint Enterprise Security
  * Anypoint Security Release Notes
toHex | MuleSoft Documentation
# toHex
## toHex(number: Number): String
Transforms a decimal number into a hexadecimal number.
_Introduced in DataWeave version 2.2.0._
### Parameters
Name | Description  
---|---  
The input number.  
### Example
This example shows how `toHex` behaves with different inputs.
#### Source
```
%dw 2.0
import toHex from dw::core::Numbers
output application/json
---
{
  a: toHex(-1),
  b: toHex(100000000000000000000000000000000000000000000000000000000000000),
  c: toHex(0),
  d: toHex(null),
  e: toHex(15),
}
```

#### Output
```
{
 "a": "-1",
 "b": "3e3aeb4ae1383562f4b82261d969f7ac94ca4000000000000000",
 "c": "0",
 "d": null,
 "e": "f"
}
```

## toHex(number: Null): Null
Helper function that enables `toHex` to work with null value.
_Introduced in DataWeave version 2.2.0._
Create a Load Balancer with the Anypoint Platform CLI | MuleSoft Documentation
# Create a Load Balancer with the Anypoint Platform CLI
You can create a dedicated load balancer (DLB) using the Anypoint Platform CLI.
## Prerequisites
Before you create a load balancer:
  * Ensure that you are an administrator in the organization where you are creating the DLB.
  * Create an Anypoint Virtual Private Cloud (Anypoint VPC) instance in the organization where you want to create a DLB.
  * Create at least one certificate and private key for your certificate.


## Create a Load Balancer Using the CLI
Use this command to create a DLB from the CLI:
```
cloudhub load-balancer create myVPC myLB_name certificateName privateKey
```

This command specifies the Anypoint VPC instance _myVPC_ in which to create the DLB and the _certificateName_ and _privateKey_ that the DLB uses.
You cannot change the name of a DLB after you create it. To change the name, delete and re-create it using the new name.   
---  
The CloudHub DLB name cannot start with `internal-`.
## Enable TLS 1.0 on a DLB Using the CLI
Although TLS 1.0 is not recommended due to security vulnerabilities, you can enable support if required for communication with legacy clients.
You can enable TLS 1.0 support only on the default SSL endpoint of the DLB. Enabling TLS 1.0 support applies to the entire DLB, not a single SSL endpoint.
For security reasons, do not leave TLS 1.0 enabled. After you no longer need TLS 1.0, replace the default cipher suite, for example, with `NewDefault`.   
---  
To enable TLS 1.0 support on a DLB using the CLI:
  1. Run the following command to re-create the SSL endpoint for the _myLB_name_ load balancer and add TLS 1.0 support:
```
cloudhub load-balancer ssl-endpoint add --tlsv1 myLB_name certificateName privateKey
```

  2. Run the following command to set _certificateName_ as the default SSL endpoint for the _myLB_name_ load balancer:
```
cloudhub load-balancer ssl-endpoint set-default myLB_name certificateName
```

  3. Using the API, change the default cipher suite to `OldDefault`.
See Change the Default Cipher Suite to Support TLS 1.0.


## See Also
  * cloudhub load-balancer create
  * cloudhub load-balancer ssl-endpoint add
  * cloudhub load-balancer ssl-endpoint set-default
  * Add Certificates to a Dedicated Load Balancer
  *
Tutorials | MuleSoft Documentation
# Tutorials
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.
  * Develop the American Flights App:
Use Anypoint Code Builder to design and implement an API specification example called American Flights API that returns flight information from a MySQL database.
  * Iteratively Design and Implement an API Specification:
Scaffold an API specification into an interface to implement within your IDE, and sync changes to the specification with the interface without first publishing to Anypoint Exchange. For example, after adding a new endpoint to your API specification, you can re-scaffold the change into the interface to add a flow for that endpoint to the interface’s configuration XML file.
  * Implement a GraphQL API:
Implement a GraphQL API that you publish to Exchange.
  * Integrate Salesforce Data into Slack and Email Notifications:
Create an integration that notifies you through email or Slack when a new case is created in Salesforce.
mergeWith | MuleSoft Documentation
# mergeWith
## mergeWith<T <: Object, V <: Object>(source: T, target: V): ?
Appends any key-value pairs from a source object to a target object.
If source and target objects have the same key, the function appends that source object to the target and removes that target object from the output.
### Parameters
Name | Description  
---|---  
The object to append to the `target`.  
The object to which the `source` object is appended.  
### Example
This example appends the source objects to the target. Notice that `"a" : true,` is removed from the output, and `"a" : false` is appended to the target.
#### Source
```
%dw 2.0
import mergeWith from dw::core::Objects
output application/json
---
{ "mergeWith" : { "a" : true, "b" : 1} mergeWith { "a" : false, "c" : "Test"} }
```

#### Output
```
"mergeWith": {
  "b": 1,
  "a": false,
  "c": "Test"
}
```

## mergeWith<T <: Object>(a: Null, b: T): T
Helper function that enables `mergeWith` to work with a `null` value.
## mergeWith<T <: Object>(a: T, b: Null): T
Helper function that enables `mergeWith` to work with a `null` value.
Redis Connector 5.4 | MuleSoft Documentation
# Redis Connector 5.4
Anypoint Connector for Remote Dictionary Server (Redis Connector) is an open source, in-memory data structure store used to cache user profiles, create leader boards, track real-time activities on a website, and filter spam. You can use Redis Connector as a message queue, custom object store, and more.
## Before You Begin
To use this connector, you must be familiar with:
  * The Redis API
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements in a Mule flow
  * Global elements
  * How to create a Mule app using Anypoint Studio


Before creating an app, you must have access to the Redis target resource.
## Audience
  * New users, read:
    * Using Anypoint Studio to Configure Redis Connector
    * Examples, which provides use cases for the connector
  * Advanced users, read:
    * XML and Maven Support
    * Examples topics


## Connection Types
Redis Connector supports only password-based authentication. Redis Connector does not currently support Role-Based Access Control (RBAC).   
---  
Redis Connector uses the following connection types:
  * Clustered
  * NonClustered
  * Sentinel


## Next Step
After you complete the prerequisites and experiment with 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
  * Redis in Anypoint Exchange
  * Redis in EU Anypoint Exchange
  * MuleSoft Help Center
endsWith | MuleSoft Documentation
# endsWith
## endsWith(text: String, suffix: String): Boolean
Returns `true` if a string ends with a provided substring, `false` if not.
### Parameters
Name | Description  
---|---  
The input string (a `String`).  
The suffix string to find at the end of the input string.  
### Example
This example finds "no" (but not "to") at the end of "Mariano".
#### Source
```
%dw 2.0
output application/json
---
[ "Mariano" endsWith "no", "Mariano" endsWith "to" ]
```

#### Output
```
[ true, false ]
```

## endsWith(text: Null, suffix: Any): false
Helper function that enables `endsWith` to work with a `null` value.
_Introduced in DataWeave version 2.4.0._
Variable Handling | MuleSoft Documentation
# Variable Handling
Variable Handling enables you to perform multiple actions like mathematical operations, parse objects, read system variables, and also read and write variables for the automation workflow.
  * The action step Activity Parameters (AP) enables you to map variables that you can use not only in the Workflow, but also in the activities of the business process and gateways.
  * The Append to Array action step enables you to append a single value or an array to an existing array.
  * Use the Check Regex action step to search for a text fragment using a regular expression.
  * This action step enables you to compare two numerical or alphanumerical (case-sensitive and case-insensitive) values to each other, using different comparison methods.
  * The Combine Strings action step enables you to combine multiple variables into a single new variable.
  * This action step converts a given string or variable to any other variable type and makes it available as a set of new variables.
  * The Coordinates action step can be used to either specify a Variable of type Coordinates in the Workflow or to modify existing coordinates.
  * Use Generate date and time to create a configurable time stamp.
  * The Get Array Count action step returns the number of elements in an array.
  * The Json Query action step enables you to parse Json objects and to read individual values / elements from the object.
  * You can use this action step to perform mathematical calculations.
  * This action step simply copies the current clipboard content into a variable (see Section Using Variables) for further usage within the Workflow.
  * The Read from Array action step is used to access the content of an array.
  * The RunTime Variables action step enables you to use variables defined during runtime in a Workflow.
  * Session Based Variables
The Session Based Variables action step enables you to share variables between workflows that execute on the same session.
  * The Set Array Variable action step enables you to assign new values to an array.
  * The Set Variable action step assigns a new value to a variable.
  * The String Operations action step enables you to modify strings.
  * The String to Array action step enables you to split a string into arrays and to process them further in next action steps, such as with the Read from Array action step.
  * The action step User Account Decrypter enables you to accept the activity parameter User Account as an inbound variable and further process it as log-in data in next action steps.
  * This action step makes it possible to set up a simple string variable.
  * Workflow Based Variables
The Workflow Based Variables action step contains variables which can be used throughout the entire Workflow and which can be modified.
  * Use Write Clipboard to copy a piece of text to the clipboard.
abs | MuleSoft Documentation
# abs
## abs(number: Number): Number
Returns the absolute value of a number.
### Parameters
Name | Description  
---|---  
The number to evaluate.  
### Example
This example returns the absolute value of the specified numbers.
#### Source
```
%dw 2.0
output application/json
---
[ abs(-2), abs(2.5), abs(-3.4), abs(3) ]
```

#### Output
```
[ 2, 2.5, 3.4, 3 ]
```
Workbench Elements in Detail | MuleSoft Documentation
# Workbench Elements in Detail
The Workbench contains a graphical representation of a Workflow. The Workflow type shows as a watermark in the upper right corner. The Workbench is capable of holding several windows as tabs, which enables you to work on more than one project at a time. Hold the mouse pointer over a tab for a short time and the path to the folder where the project is stored shows as a tooltip.
Multiple Workflows organized in tabs  
---  
Project location tooltip  
Workflow type icon  
## Selecting Objects
To select an object, click on its icon. Selected objects show a blue border and their properties show in the Properties panel. Right-click to access a context menu for any Workbench element:
The context menu  
---  
The selected object  
To select more than one object, press and hold _Ctrl_ or _Shift_ while clicking to select the objects. If you drag an object into the Workbench, it is automatically selected.
## Context Menu Options
The context menu consists of the following elements:
  * () **Record**
Starts RPA Recorder to record an activity and append it to the workflow depending of the context:
    * If you click a Transaction element, the option changes to **Record Into** and adds the recorded activities at the end of the transaction.
    * If you click an action step, you can choose between **Record Before** and **Record After** to decide where to append the recorded actions.
  * **Disable/Enable**
Use this option to disable an action step and prevent its execution or to enable an action step that was previously disabled. Disabled action steps are greyed out on the workbench.
  * **Enable All Selected/Disable All Selected**
Use this option to disable or enable multiple action steps simultaneously.
  * **Save As Template**
Saves the selected action step and its settings as a template that you can use again later. See Managing User Templates for additional details about creating, importing, and exporting Templates.
  * **Select all steps of same type**
Selects all action steps of the same type as the one you have clicked on. This option enables you to change the properties of these action steps uniformly.
  * **Mapped to action steps**
Shows all incoming Pin variables associated with this action step. Click on the name of a variable to select the action step that populates that variable.
  * **Set Breakpoint**
Sets a breakpoint for an action step, which causes the Workflow to stop at this point during its execution in Debug mode.
  * **Rename**
Enables you to rename the selected element.
  * **Collapse All**
Collapses all levels of the Workflow to the highest level shown in the current view. Use the **Collapse All** () button to collapse individual elements.
  * **Expand All**
Fully expands all levels of the Workflow on view. Use the **Expand All** () button to expand individual elements.


## See Also
  * Workbench Toolbar Overview
  * Managing User Templates
  * Workflow Elements in Detail
Manage Blocked IP Addresses in Runtime Fabric | MuleSoft Documentation
# Manage Blocked IP Addresses in Runtime Fabric
In a Runtime Fabric with Anypoint Security enabled, you can unblock IP addresses and generate a list of blocked IP addresses, which you can view in Runtime Fabric logs.
## Prerequisites
To manage blocked IP addresses in Runtime Fabric you must:
  * Have a running Runtime Fabric
  * Have a DoS policy configured and deployed to Runtime Fabric


## Manage Blocked IP Addresses
  1. In Anypoint Platform go to **Management Center > Runtime Manager**.
  2. In the left navigation menu, click **Runtime Fabrics**.
  3. Select the Runtime Fabric for which to manage the blocked IP addresses.
  4. Select the **Inbound Traffic** tab.
  5. In the **Security Policies** section, click **Manage blocked IPs**.
  6. In the **Manage blocked IPs** dialog box, you can download a list of blocked IP addresses into a log file or unblock IP addresses.


## Unblock IP Addresses
  1. In the **Manage blocked IPs** dialog, to unblock an IP address or range of IP addresses, enter an IP address and CIDR in the **Unblock an IP Address** field. For example, to unblock a single IP address, enter: `192.0.2.0/32`. To unblock a range of IP addresses, enter: `192.0.2.0/24`.
  2. Click **Done**. When the IP addresses are successfully unblocked, an `Unblocked` message appears.


## Log Blocked IP Addresses
  1. To generate a list of blocked IP addresses, click **Log blocked IPs**. When the blocked IP addresses are successfully logged, a `Logged` message appears.
  2. To view the logs, follow the instructions in the View and Configure Logging for configuring log forwarding. The logs look similar to this:


```
{
	"body": [{
		"action": "BlockForever",
		"ip": "172.31.104.239",
		"category": "RoutingError"
	}, {
		"action": "BlockForever",
		"ip": "172.31.104.240",
		"category": "RoutingError"
	}, {
		"action": "BlockForever",
		"ip": "172.31.106.88",
		"category": "RoutingError"
	}, {
		"action": "BlockForever",
		"ip": "172.31.106.89",
		"category": "RoutingError"
	}, {
		"action": "BlockForever",
		"ip": "172.31.106.90",
		"category": "RoutingError"
	}, {
		"action": "BlockForever",
		"ip": "172.31.106.91",
		"category": "RoutingError"
	}, {
		"action": "BlockForever",
		"ip": "172.31.106.92",
		"category": "RoutingError"
	}, {
		"action": "BlockForever",
		"ip": "172.31.106.107",
		"category": "RoutingError"
	}],
	"hdr": {
		"logType": "EdgeJSON",
		"name": "doSActionsView",
		"time:": "2019-03-29 18:38:48"
	}
}
```

## See Also
  *   * HTTP Limits Policy
  * Denial Of Service Policy
  * Viewing and Configuring Logs in Runtime Fabric
Customizing the Parameters DSL | MuleSoft Documentation
# Customizing the Parameters DSL
To provide the best possible experience for the user, customize or limit some aspects of a component’s parameters. For example, you can hide irrelevant parameters for clarity.
## Receiving Strings As Reference Or As Value
Let’s say we have an operation like the following:
```
public void send(@Connection MyConnection connection, Object value) {
  connection.doSend(value);
}
```

Which will be invoked like this:
```
<demo:send value="requestPayload"/>
```

By default, Mule assumes that `requestPayload` is a reference to an object in the registry, like a global list or POJO. If instead we want the extension to actually receive the `requestPayload` string, we must modify the operation declaration, using the `@ParameterDsl` annotation:
```
public void send(@Connection MyConnection connection, @ParameterDsl(allowReferences = false) Object value) {
  connection.doSend(value);
}
```

This change explicitly disables the use of references, so the operation will receive the string value.
## Defining How Complex Types Can Be Used
Any Module is able to expose POJOs that conform to the Module API:
```
// This is the POJO declaration
public class Door {
 @Parameter
 private boolean isLocked;
 @Parameter
 private String color;
}
// This is the configuration
public class HouseConfig {
 @Parameter
 private Door mainDoor;
}
```

When having this kind of parameters, the Module developer has the responsibility to configure how the `Door` can be used in the DSL. For this, we have the `@TypeDsl` annotation, that allows you to configure two important things:
  * `allowInlineDefinition`: Defines if the POJO (in the example, the `Door`) can be declared inline for the element that uses it as parameter. If this value is `true`, then the user can declare:
```
<demo:config name="myConfig"> **(1)**
  <demo:door isLocked="true" color="red"/> **(2)**
</demo:config>
```

The config is declared as the container of the parameter  
---  
A `Door` is declared inline (in the `config`)  
  * `allowTopLevelDefinition`: Defines if the POJO (in the example, the `Door`) can be declared as a top-level element in the application. If this value is `true`, then the user can declare:
```
<demo:door name="MyGlobalDoor" isLocked="true" color="red"/> **(1)**
<demo:config name="myConfig" door-ref="MyGlobalDoor"/> **(2)**
```

A `Door` is declared as a global element of the application  
---  
The `config` is declared separately, referencing the global `Door` element by name with the `door-ref` attribute
Metrics for a Specific Asset and Version | MuleSoft Documentation
# Metrics for a Specific Asset and Version
Administrators and asset owners with contributor permission can view usage details for a specific API specification fragment, REST API asset, and their versions on the asset details page. This page identifies asset versions with overall high usage and versions with low usage. The usage rates can help you understand the performance and stickiness of specific asset versions within your organization and enable you to make informed decisions about reuse and improvements.
The following graphic shows the asset details page with usage and engagement metrics:
The following data is collected and analyzed:
  * Version
The version of the asset.
  * Created by
The name of the person who created this version of the asset.
  * Created on
The date that the asset was created.
  * Lifecycle state
Which state the asset is currently in. The states are In Development, Stable, or Deprecated.
  * Conformance
Conformance status appears for all REST APIs and AsyncAPIs. The status can be Conformant, Not Conformant, and Not Validated.
  * Engagement contribution
The engagement contribution is the percentage of usage of the given asset patch or minor version with regards to its respective minor or major version.
  * Downloads
The number of times the asset was downloaded from Exchange. You can sort by ascending or descending order.
  * API Designer imports
The number of times the asset was imported in to Design Center. You can sort by ascending or descending order.
  * Studio imports
The number of times the asset was imported in to Studio. You can sort by ascending or descending order.
  * All-time stats
    * Dependents
The number of dependent assets from the time the version was created.
    * Contracts
The number of approved contracts from the time the version was created.


## View Asset Version Engagement
To view usage and engagement metrics for the asset versions of API specification fragments and REST APIs:
  1. In the Exchange catalog, select an API specification fragment or REST API.
The asset details page displays the asset metadata.
  2. In the navigation bar, click **Asset versions engagement**.
The **Asset versions engagement** page displays.
  3. If you want to filter by date, select a date range from 7 days, 30 days, or 90 days.
The default date range is the last 7 days.
  4. If you want to export the usage data, click **Export to CSV**.


## See Also
  *   * Manage Lifecycle States