BassemE/mulesoft-documentation-embeddings huggingface dataset:
HL7 EDI - XML and Maven Support | MuleSoft Documentation
# HL7 EDI - 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/hl7
http://www.mulesoft.org/schema/mule/hl7/current/mule-hl7.xsd
```

This example shows how the namespace statements are placed in the XML:
```
<mule xmlns:hl7="http://www.mulesoft.org/schema/mule/hl7"
	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/hl7
	http://www.mulesoft.org/schema/mule/hl7/current/mule-hl7.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-hl7-extension</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 `HL7 EDI`.
  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
Filtering Internal Mule HTTP Headers in Mule 3.x API Proxy | MuleSoft Documentation
# Filtering Internal Mule HTTP Headers in Mule 3.x API Proxy
To avoid internal Mule HTTP headers from being leaked to the backend implementation or from being included in the response, API proxies use the following filters by default:
  * To avoid the internal Mule HTTP header from being leaked to the backend implementation:
`<custom-processor class="com.mulesoft.gateway.extension.ProxyRequestHeadersProcessor" />`
  * To avoid the internal Mule HTTP header from being included in the response:
`<custom-processor class="com.mulesoft.gateway.extension.ProxyResponseHeadersProcessor" />`


Currently, there are no customizations available for these filters.
## See Also
Setting up the Partner Manager Environment | MuleSoft Documentation
# Setting up the Partner Manager Environment
Setting up the Anypoint Partner Manager environment involves the following:
  * Configuring Partner Manager deployment settings.
You can deploy Partner Manager to either CloudHub or Anypoint Runtime Fabric, and you can configure separate deployment settings for each business group environment. Configure Partner Manager deployment settings in access management, as described in Deploying Partner Manager Runtime Apps.
  * Configuring a payload storage API.
You must configure a payload storage API that provides Partner Manager with a standardized way to connect to your solution for storing transmission content. For more information, see Configuring a Payload Storage API.
  * Uploading your own, self-signed certificates, if you want to use them to establish secure connections with endpoints.
You can use CA-signed certificates instead of your own self-signed certificates.
For more information, see Certificate and Keystore Storage.
Message Box | MuleSoft Documentation
# Message Box
This action step is used to display a message box containing user-defined text and the buttons needed. It can be used at any point in a _Workflow_.
## Properties
**Text** The text you want to display in the message box
**Timeout** Defines the duration wait before it automatically closes the message box (only works if _Use timeout_ is selected)
**Title** Window title for the message box
**Use timeout** This option determines whether the message box should be closed automatically.
Getting to Know Bots | MuleSoft Documentation
# Getting to Know Bots
Besides a name, a description, a version, and a host, bots have the following properties:
**Property** | **Description**  
---|---  
State of the bot:
  * The bot is ready for use.
  * **STOPPED** : The bot has been stopped.
  * **OVERDUE** : The bot is no longer connecting to RPA Manager.
  * **UNKNOWN** : The status of the bot cannot be determined.
  * **RESTARTPENDING** : The bot is restarting.
  * **OUT OF SERVICE TIME** : The bot is outside of its assigned service times.

  
**Processing** | 
  * Pause symbol: The bot is currently not running any deployed processes.
  * Play symbol: The bot is currently running deployed processes.

  
  * Cross symbol: The bot should not be used in the test phase.
  * Check mark symbol: The bot can be used in the test phase.

  
**Production** | 
  * Cross symbol: The bot should not be used in the production phase.
  * Check mark symbol: The bot can be used in the production phase.

  
The timezone that the bot’s installation computer uses. The bot interprets all times for which no time zone is assigned to be set in its own time zone.  
**Licensed sessions** | 
  * Shield with a check mark symbol and a number: Maximum number of Secure Sessions the bot may use at the same time. This number depends on the hardware the bot is installed on.
  * Shield symbol: The bot has been configured for a Desktop Session. It cannot use Secure Sessions.

  
**Deployed sessions** |  Number of sessions that have been deployed to the bot for executing processes. The number of deployed sessions can exceed the number of licensed sessions. This may cause individual process executions to be skipped.  
## Before You Begin
  * At least one bot must be installed on a separate computer.
  * Ask an organization administrator in Access Management to assign you the required permissions:
Action | RPA Permission | Deprecated RPA Permission  
---|---|---  
Open the **Bot Management** module and view the bots. | RPA Bots Manager, RPA Operations Viewer, RPA Operations Manager, RPA Administrator | Robot Management Open  


## Find Bots
Open the **Bots** view in the **Bot Management** module to view all bots connected to RPA Manager. Newly installed bots connect automatically.
## See Also
  *   *   *   * Troubleshooting Bots
Map Object Elements as an Array | MuleSoft Documentation
# Map Object Elements as an Array
This DataWeave example uses the DataWeave `map` function to iterate through the object elements that match the key `book`. The input also includes the key `magazine`, which is ignored.
The example uses these DataWeave functions:
  * The multi-value selector `*book` to return an array with the elements that match the key `"book"`.
  * `map` to go through each object in the array that’s returned by the multi-value selector.


DataWeave Script:
```
%dw 2.0
var myInputExample = {
 "inventory": {
   "book" : {
    "category": "cooking",
    "title": "Everyday Italian",
    "author": "Giada De Laurentiis",
    "year": "2005",
    "price": "30.00"
   },
   "book" :{
    "category": "children",
    "title": "Harry Potter",
    "author": "J K. Rowling",
    "year": "2005",
    "price": "29.99"
   },
   "book" :{
    "category": "web",
    "title": "Learning XML",
    "author": "Erik T. Ray",
    "year": "2003",
    "price": "39.95"
   },
   "magazine" :{
    "category": "web",
    "title": "Wired Magazine",
    "edition": "03-2017",
    "price": "15.95"
   },
    "magazine" :{
    "category": "business",
    "title": "Time Magazine",
    "edition": "04-2017",
    "price": "17.95"
   }
  }
}
output application/json
---
items: myInputExample.inventory.*book map (item, index) -> {
   "theType": "book",
   "theID": index,
   "theCategory": item.category,
   "theTitle": item.title,
   "theAuthor": item.author,
   "theYear": item.year,
   "thePrice": item.price as Number
}
```

Output JSON:
```
{
 "items": [
  {
   "theType": "book",
   "theID": 0,
   "theCategory": "cooking",
   "theTitle": "Everyday Italian",
   "theAuthor": "Giada De Laurentiis",
   "theYear": "2005",
   "thePrice": 30.00
  },
  {
   "theType": "book",
   "theID": 1,
   "theCategory": "children",
   "theTitle": "Harry Potter",
   "theAuthor": "J K. Rowling",
   "theYear": "2005",
   "thePrice": 29.99
  },
  {
   "theType": "book",
   "theID": 2,
   "theCategory": "web",
   "theTitle": "Learning XML",
   "theAuthor": "Erik T. Ray",
   "theYear": "2003",
   "thePrice": 39.95
  }
 ]
}
```

## Related Examples
  * Map Data with DataWeave
  *   *   * 

## See Also
  *   * DataWeave Selectors
  *
Prepare to Migrate to Mule 4 | MuleSoft Documentation
# Prepare to Migrate to Mule 4
Mule 4 introduces many changes, so plan accordingly before attempting to migrate from Mule 3.
## When to Start Using Mule 4
MuleSoft recommends that you develop all **new** projects on Mule 4, provided that:
  * You and your team have updated your skills for Mule 4 through the documentation or formal training.
  * You have the proper deployment environment.


For projects deployed on Mule 3, use the Mule Migration Assistant (MMA) to avoid re-creating the application in Mule 4.
Migrate your applications if any one of the following conditions is met:
  * The 3.x version you are using reaches end of life.
  * You want to make significant updates to the existing applications.
  * You want to take advantage of key Mule 4 capabilities.
  * You decide to upgrade all your apps to Mule 4 because your organization requires all apps to be on one version (for some on-prem scenarios).


## Setting up Your Local Development Environment
First, download and install Anypoint Studio 7. If the Mule version that comes with Anypoint Studio does not match the Mule version you want to use for local deployments, download the desired 4.x version of Mule runtime engine.
## Getting Ready to Deploy
Next, you need to make sure your deployment environment is ready. Depending on which environment you have, different steps may be required.
Deployment Mechanism | Instructions  
---|---  
CloudHub | CloudHub is Mule 4 ready.  
Hybrid Deployment | Install Mule 4 on your servers.  
Anypoint Runtime Fabric | Runtime Fabric supports Mule 4.  
Anypoint Platform Private Cloud Edition (PCE) | PCE supports Mule 4.  
## Writing the Code
If you are performing a completely manual migration, you are ready to start building and deploying Mule 4 applications. Simply review Introduction to Mule 4 topics to get an overview of the migration process and understand changes introduced in Mule 4.
For guidance with an assisted migration using the Mule Migration Assistant (MMA), it is important to review the MMA documentation (on GitHub). 

Important
    
**Mule Migration Assistant (MMA) is subject to the terms and conditions described forCommunity connectors. Additionally, Mule Migration Assistant is distributed under the terms of the 3-Clause BSD License.**
Xero Accounting Connector 1.0 | MuleSoft Documentation
# Xero Accounting Connector 1.0
Anypoint Connector for Xero Accounting (Xero Accounting Connector) enables you to access the Xero Accounting APIs. Xero Accounting APIs expose accounting and related functions of the main Xero application and can be used for a variety of purposes, such as creating transactions like invoices and credit notes, to extracting accounting data via the Reports endpoint.
For compatibility information and fixed issues, see the Xero Connector Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The Xero Accounting API
  * Anypoint Connectors
  * Mule runtime (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have:
  * Credentials to access the Xero Accounting target resource
  * Anypoint Platform
  * Anypoint Studio 7.3 or later


## Authentication Types
Xero Connector connections use the OAuth 2.0 authentication method.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  *   * MuleSoft Help Center
envVar | MuleSoft Documentation
# envVar
## envVar(variableName: String): String | Null
Returns an environment variable with the specified name or `null` if the environment variable is not defined.
### Parameters
Name | Description  
---|---  
`variableName` | String that provides the name of the environment variable.  
### Example
This example returns a Mac command console (`SHELL`) path and returns `null` on `FAKE_ENV_VAR` (an undefined environment variable). `SHELL` is one of the standard Mac environment variables. Also notice that the `import` command enables you to call the function without prepending the module name to it.
#### Source
```
%dw 2.0
import * from dw::System
output application/json
---
{
  "envVars" : [
    "real" : envVar("SHELL"),
    "fake" : envVar("FAKE_ENV_VAR")
  ]
}
```

#### Output
```
"envVars": [
 {
  "real": "/bin/bash"
 },
 {
  "fake": null
 }
]
```
Sharing an OAS 3.0 API Specification as a RAML 1.0 Specification | MuleSoft Documentation
# Sharing an OAS 3.0 API Specification as a RAML 1.0 Specification
You can share an OAS 3.0 API specification in Anypoint Exchange as a RAML API specification. Other developers can then download the RAML version for use in Anypoint Studio or third-party IDEs or for implementation with API Manager.
  1. Import the OAS 3.0 API specification into API Designer.
  2. Click the three dots next to the filename in the **Files** pane and select **Duplicate**.
  3. In the **Duplicate As** dialog, select **RAML**.
  4. Set the root file of the project to the RAML version of the API specification.
  5. Publish the project to Anypoint Exchange.


If you want to share an OAS 3.0 specification in OAS 2, download your OAS 3.0 specification from API Designer as-is and then convert it to OAS 2.0 by using a tool such as APIMatic transformer.  
---
prop | MuleSoft Documentation
# prop
## prop(propertyName: String): String | Null
Returns the value of the property with the specified name or `null` if the property is not defined.
### Parameters
Name | Description  
---|---  
`propertyName` | The property to retrieve.  
### Example
This example gets the `user.timezone` property.
#### Source
```
%dw 2.0
import * from dw::Runtime
output application/dw
---
{ "props" : prop("user.timezone") }
```

#### Output
```
{ props: "America/Los_Angeles" as String {class: "java.lang.String"} }
```
Approved Members Not Created or Emailed | MuleSoft Documentation
# Approved Members Not Created or Emailed
If your Winter '20 Salesforce organization has the member approval workflow active, and approving a member and refreshing the screen removes the member from the list without creating the new user or sending the new user email, either set the approver’s language to `English` or add the approver’s language.
To set the approver’s language to English, configure the approver user in the `SelfRegister` component and set the locale to `English`.
To add the approver’s language:
  1. Open Salesforce setup.
  2. Open company settings.
  3. Open language settings.
  4. Enable the appropriate languages and locales by enabling end-user languages, enabling platform-only languages, or enabling both.
  5. Add the language matching the approver user profile to the list of displayed languages.
Web Service Consumer Connector 1.7 | MuleSoft Documentation
# Web Service Consumer Connector 1.7
Anypoint Connector for Web Service Consumer (Web Service Consumer Connector) consumes a SOAP web service from a Mule app to acquire data from an external source. In many cases, you can use Anypoint Connector for Workday (Workday Connector) or Anypoint Connector for ServiceNow (ServiceNow Connector) to connect to a service provider, however, when no connector is available for a specific web service, the easiest way to consume the service is to use the Web Service Consumer Connector.
The main features of the connector include:
  * Ability to consume DOC literal web services
  * Use of SOAP multipart messages
  * Use of SOAP headers
  * Support for a DataSense for SOAP headers, SOAP body, and attachments
  * Use of embedded DataWeave transformations inside the operation
  * Support for a unified experience for SOAP with attachments and MTOM handling
  * Custom HTTP configuration as a transport
  * Support for Web Service Security (WS Security)


Web Service Consumer Connector doesn’t support RPC WSDLs (Remote procedure call Web Service Descripting Language).   
---  
## Before You Begin
To use this connector, you must be familiar with:
  * SOAP and WSDLs
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements in a Mule flow
  * Global elements
  * DataWeave
  * Creating a Mule app using Anypoint Studio


Before creating an app, you must have access to Anypoint Studio.
## Next Step
After you complete the prerequisites, 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
  * Web Service Consumer in Exchange
  * MuleSoft Help Center
Monitoring a Composer Flow | MuleSoft Documentation
# Monitoring a Composer Flow
After activation, you can monitor active Composer flows.
  1. From the sidebar, click **Flows**.
  2. Click the name of a flow to display the flow detail page.


The flow detail page shows each time the flow runs and whether or not that run was successful. The run history is retained for a maximum of 14 days or 1000 records, whichever occurs first.
## See Also
  * Mulesoft Composer: Overview
  * MuleSoft Composer: Getting Started
  * Composer Connector Reference
  * Knowledge Articles
Getting Started with API Catalog CLI | MuleSoft Documentation
# Getting Started with API Catalog CLI
After you become familiar with the API Catalog CLI concepts covered in Autocataloging APIs Using API Catalog CLI, you are ready to get started autocataloging your APIs.
## Before You Begin
To grant permission to run the API Catalog CLI commands that interact with Anypoint Platform:
  * Enable **API Catalog Contributor**.
  * If you are authenticating using a connected app, set the **View Environment** scope to the main environment for your organization.


Permissions must be set in **Access Management** by an Anypoint Platform user with administrative permission.   
---  
See the Access Management documentation for details on managing permissions.
## Get Started with API Catalog CLI
To get started with API Catalog CLI:
  1. Install API Catalog CLI.
  2. Get familiar with the general use of API Catalog, such as how to pass authentication information and how to use the general command flags.
  3. Create a descriptor file to identify the APIs to publish.
  4. Catalog an asset using API Catalog CLI and view it in Anypoint Exchange.


Consider testing the process end-to-end locally by running the commands at a command prompt before adding the commands to your CI/CD pipeline or custom scripts.   
---  
## See Also
  * Autocataloging APIs Using API Catalog CLI
Step 3. Create the Automation Project | MuleSoft Documentation
# Step 3. Create the Automation Project
After evaluating and approving a process for automation, create an automation project from the approved process proposal and assign it a category. You can either use a category that exists in your organization or you can create a new one.
## Step 3.1: Create a Category
To create a category, follow these steps:
  1. In the navigation panel of RPA Manager, click the **Process Automation** module.
  2. Open the **Process Management** view.
  3. Click **Create**.
  4. In the **Name** field, write `Web Automations`.
  5. Click **OK**.


## Step 3.2: Create the Automation Project
After you create a category, follow these steps to create your automation project:
  1. In the navigation panel, click the **My RPA** module.
  2. Open **My Backlog**.
  3. Search for the **MuleSoft newsletter sign-up** project in the process list and click the **Start automation** () button.
  4. Provide the necessary information for the project:
     * In **Process name** , write `MuleSoft newsletter sign-up`.
     * In **User** , select **Design** , **Build** , **Test** , and **Production** to ensure your user has access to all phases of this automation project.
     * In **Category** , select the **Web Automations** category, created in the previous step.
     * Deselect **Use Process Board**.
  5. Click **Save**


## Next Steps
Now that you’ve created an automation project, it’s time to move to the design phase, in which you create the BPMN diagram for the process.
Continue with Step 4: Design the BPMN diagram for the automation
## See Also
  * Starting Automation of Approved Processes
Cryptography Module - Additional Configuration | MuleSoft Documentation
# Cryptography Module - Additional Configuration
After you complete basic Cryptography Module configuration, you can perform additional configuration tasks.
## Configure Use Random Initialization Vectors
Configure the **Use random IVs** field to use random initialization vectors (IVs). If you configure this field, the decryption algorithm expects the IVs to be added to the beginning of the ciphertext during decryption.
Follow these steps for the configuration:
  1. In Anypoint Studio, drag a Cryptography Module operation to your flow, for example **Jce sign**.
  2. Select the operation from the flow.
  3. In the operation configuration screen, click the plus sign to access the module global configuration.
  4. In the **Global Element Properties** window, enable the **Use random IVs** field.


In the **XML editor** window, the configuration looks like this:
```
crypto:jce-config name="Crypto_Jce" doc:name="Crypto Jce" keystore="/Users/MuleSoft/Desktop/jcekeystore.jks" password="mulesoft" useRandomIVs="true">
		<crypto:jce-key-infos >
			<crypto:jce-symmetric-key-info keyId="key100" alias="jceclient100" password="mulesoft" />
		</crypto:jce-key-infos>
	</crypto:jce-config>
```

## See Also
  * Cryptography Module Examples
  * Cryptography Module Reference 2.0
Jira Connector 1.1 | MuleSoft Documentation
# Jira Connector 1.1
Anypoint Connector for Jira (Jira Connector) synchronizes data and automates business processes between Jira and third-party applications, either on-premises or in the cloud.
Jira Connector is only for the Cloud version.   
---  
Jira is a software development platform to help agile product development teams triage and track their work from inception to launch. Jira Connector enables organizations of all sizes to establish scalable and sustainable product development workflows by connecting Jira to other tools in the organization such as the customer service platforms, project management tools, and others.
For compatibility information and fixed issues, see the Jira Connector Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The Jira APIs
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have:
  * Credentials to access the target Jira resource
  * Anypoint Studio version 7.3.5 or later


## Common Use Cases for the Connector
Automate business processes by integrating Jira with other IT tools and systems in your enterprise such as messaging, CRM, customer service, and others.
Possible use cases include:
  * Enhance customer experience by connecting Jira with your customer service platform, thereby reducing the cycle times between when a customer raises an issue through a customer service platform, like Salesforce’s Sales Cloud, and when that issue gets added to the product team’s work backlog in Jira.
  * Streamline crossteam handoffs by ensuring that the updated information on every issue is available across all systems and stakeholders. For example, when the engineering team marks a customer issue as resolved, update the status across your CRM and customer support platforms, so the customer-facing teams (sales and support) are notified immediately.
  * Foster team collaboration and improve productivity by automating the flow of information between Jira and your team’s communication platform, so that when a new issue gets added to the backlog or an issue gets updated, relevant team members are notified so the appropriate next steps can be taken.


## Authentication Types
Jira Connector connections use the following authentication methods:
  * Basic authentication Uses a username and password for authentication
  * OAuth2 Delegates user authentication to the service hosting the user account


Jira Connector does not support authentication via personal access tokens (PATs).   
---  
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  *   * MuleSoft Help Center
underscore | MuleSoft Documentation
# underscore
## underscore(text: String): String
Replaces hyphens, spaces, and camel-casing in a string with underscores.
If no hyphens, spaces, and camel-casing are present, the output will match the input.
### Parameters
Name | Description  
---|---  
The input string.  
### Example
This example replaces the hyphens and spaces in the input. Notice that the input "customer" is not modified in the output.
#### Source
```
%dw 2.0
import * from dw::core::Strings
output application/json
---
{
  "a" : underscore("customer"),
  "b" : underscore("customer-first-name"),
  "c" : underscore("customer NAME"),
  "d" : underscore("customerName")
}
```

#### Output
```
{
  "a": "customer",
  "b": "customer_first_name",
  "c": "customer_name",
  "d": "customer_name"
}
```

## underscore(text: Null): Null
Helper function that enables `underscore` to work with a `null` value.
Configuring Single Signout | MuleSoft Documentation
# Configuring Single Signout
As Administrator, you can configure single signout if you use SAML. OpenID Connect doesn’t support single signout. Using single signout, a user or user agent can sign out of an authenticated environment and ensure that both service providers and identity servers process the signout correctly.
The following procedure shows how to perform single signout and control where the user is redirected after signing out. To redirect the user to a different page, set up the redirect in your PingFederate configuration by adding a `redirect_uri` query parameter to the SLO Service URL. Anypoint Platform routes the user to that page rather than to the Anypoint Platform sign-in page.
  1. In PingFederate, for example, click the SP Configuration for the Anypoint Platform.
  2. In **Browser SSO > Configure Browser SSO > SAML Profiles**, ensure that these fields are set:
     * IdP-Initiated SSO
     * IdP-Initiated SLO
     * SP-Initiated SLO
  3. In **Protocol Settings > Configure Protocol Settings**, configure a SLO Service URL with the following values:
     * Binding: POST
     * Endpoint URL
Set `PARTNER_SP_ID` to the correct value: `https://anypoint.mulesoft.com/accounts/logout/receive-id`
  4. Redirect users to your sign-in page using the following URL:
```
https://anypoint.mulesoft.com/accounts/logout/receive-id?redirect_uri=https%3A%2F%2Fanypoint.mulesoft.com%2Faccounts%2Flogin%2Fyour-domain
```

Alternatively, redirect users to your portal page using the following URL:
```
https://anypoint.mulesoft.com/accounts/logout/receive-id?redirect_uri=https%3A%2F%2Fanypoint.mulesoft.com%2Fapiplatform%2Fyour-domain%2F%23%2Fportals
```

  5. In **Allowable SAML Bindings** , click **Redirect**.
  6. In **Encryption Policy** , choose either **none** or **the entire assertions** , then save and exit Protocol Settings and Browser SSO.
  7. When viewing the SP Configuration for Anypoint Platform, go to **Credentials > Configure Credentials**.
  8. Set **Signature Verification Settings > Manage Signature Verification Settings > Trust Model to Unanchored**, and import the certificate from the following location:
`http://docs.mulesoft.com/downloads/access-management/anypoint-platform-slo.pem`
  9. Make this certificate the active certificate.


## See Also
  * Configure SAML for SSO
IBM MQ Connector XML and Maven Support | MuleSoft Documentation
# IBM MQ 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 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/ibm-mq
http://www.mulesoft.org/schema/mule/ibm-mq/current/mule-ibm-mq.xsd
```

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


## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Configure the Mutual TLS Authentication | MuleSoft Documentation
# Configure the Mutual TLS Authentication
The following example shows how to configure Anypoint Connector for AMQP (AMQP Connector) to connect to an AMQP broker with mutual TLS (mTLS) authentication. To configure the global configuration connection you need:
  * A client truststore that includes the Certificate Authority’s certificates that are required for the server validation.
  * A client keystore that provides the client private key and certificate that are required for the authentication.
  * To enable the parameters **Use TLS** and **Use SNI** on the AQMP global configuration in Anypoint Studio.


## Configure the Connection
To configure the Mutual TLS authentication connection in Studio, follow these steps:
  1. Navigate to the **Global Elements** tab and click **Create**.
  2. In the filter box, type `AMQP`.
  3. Select **AQMP Config**.
  4. Click **OK**.
  5. In the **General** tab, for the **Connection** section, set the following parameters:
     * **Host** : `localhost`
     * **Port** : `${rabbitmq.tls.port}`
  6. Select the **Use tls** and **Use sni** parameters boxes.
  7. Click the **TLS** tab.
  8. For **TLS Configuration** select **Edit inline**.
  9. In the **Trust Store Configuration** section, set the following parameters:
     * **Path** : `mtls/truststore.jks`
     * **Password** : `test`
  10. In the **Key Store Configuration** section, set the following parameters:
     * **Path** : `mtls/test.jks`
     * **Alias** : `test`
     * **Key Password** : `test`
     * **keyPassword** : `test`
  11. Click **OK**.


In Studio, the AMQP global configuration with TLS authentication looks like this:
Figure 1. AMQP Mutual TLS Authentication configuration
## XML for Configuring Mutual TLS Authentication
In the XML editor, the configuration looks like this:
```
<amqp:connection host="localhost" port="${rabbitmq.tls.port}" useTls="true" useSasl="true" >
      <tls:context >
        <tls:trust-store path="mtls/truststore.jks" password="test" type="jks" />
        <tls:key-store type="jks" path="mtls/test.jks" alias="test" keyPassword="test" password="test" />
      </tls:context>
</amqp:connection>
```

## See Also
  *   * MuleSoft Help Center
isPeriodType | MuleSoft Documentation
# isPeriodType
## isPeriodType(t: Type): Boolean
Returns `true` if the input is the Period type.
_Introduced in DataWeave version 2.3.0._
### Parameters
Name | Description  
---|---  
The type to check.  
### Example
This example shows how `isPeriodType` behaves with different inputs.
#### Source
```
%dw 2.0
import * from dw::core::Types
type APeriod = Period
output application/json
---
{
  a: isPeriodType(APeriod),
  b: isPeriodType(Period),
  c: isPeriodType(String),
}
```

#### Output
```
{
 "a": true,
 "b": true,
 "c": false
}
```
native | MuleSoft Documentation
# native
## native(String): Nothing
Internal method used to indicate that a function implementation is not written in DataWeave but in Scala.
Cryptography Module | MuleSoft Documentation
# Cryptography Module
Cryptography Module provides cryptography capabilities to a Mule application. Its main features include:
  * Symmetric encryption and decryption of messages.
  * Asymmetric encryption and decryption of messages.
  * Message signing and signature validation of signed messages.


The module supports these strategies to encrypt and sign your messages:
  * JCE Provides cryptography capabilities of Java Cryptography Extension.
  * PGP Provides signing and encryption using Pretty Good Privacy.
  * XML Provides signing and encryption of XML documents or elements.


Additionally, the module offers two general operations to calculate and validate stream checksums. For details, refer to Cryptography Module Reference 1.x
## See Also
  * Introduction to Anypoint Connectors
  * Salesforce Help Center
Migrating Message Properties | MuleSoft Documentation
# Migrating Message Properties
In Mule 3, there are several property scopes that you can use for different purposes. In Mule 4, most of these scopes have been removed.
## Invocation Properties
Invocation properties are now called `variables` in Mule 4. Their behavior is exactly the same as in Mule 3.
## Inbound Properties, Outbound Properties, Inbound and Outbound Attachments
These scopes do not exist in Mule 4. See Intro Mule Message for more information about migration.
## See Also
Introduction to Mule 4: The Mule Message
Mule Message Structure
Variables in Mule Events
Registering and Running Flex Gateway in Connected Mode | MuleSoft Documentation
# Registering and Running Flex Gateway in Connected Mode
Before you can use your Flex Gateway to configure API instances, you must register and start the gateway.
There are three ways to register Flex Gateway in Connected Mode:
  * Register and Run using a Username and Password: If you have a username and password for Anypoint Platform, you can use these credentials to register your Flex Gateway.
  * Register and Run using a Connected App: If you do not have a username or password for Anypoint Platform, you can use connected app credentials to register your Flex Gateway.
  * Register and Run using a Token: If you do not have a username or password for Anypoint Platform, you can use a registration token generated by the Runtime Manager UI. The token is valid for four hours.
Use Case 2: Organization-Owned API Exposed to a Non-Organization-Owned API Consumer | MuleSoft Documentation
# Use Case 2: Organization-Owned API Exposed to a Non-Organization-Owned API Consumer
Use case two covers all patterns of a scenario in which an organization-owned API is exposed to a non-organization-owned API consumer; for example, when a user makes a request to your public-facing API.
## Pattern 5: Organization Internal API exposed to a Non-Organization External Consumer
In pattern five, the infrastructure of the organization-owned API is isolated from the API consumer. The consumer can access the exposed API only via the internet. In this use case, you deploy Flex Gateway as an ingress.
The following diagram shows the physical implementation of a scenario in which an organization-owned internal API is exposed to a non-organization-owned external consumer on Kubernetes. The diagram assumes that the firewall terminates the incoming external mTLS connection.
## Pattern 6: Organization External API exposed to a Non-Organization External Consumer
In pattern six, Flex Gateway acts as an intermediary between two external network entities. Flex Gateway runs as an ingress and egress that applies secure communication and policy enforcement.
The following diagram shows the physical implementation of a scenario in which an organization external API is exposed to an non-organization external consumer on Kubernetes. The diagram assumes that the firewall terminates the external mTLS connections.
## See Also
  * Use Case 1: Organization-Owned API Exposed to an Organization-Owned API Consumer
  * Use Case 3: Non-Organization-Owned API Exposed to an Organization-Owned API Consumer
  * Use Case 4: Non-Organization-Owned API Exposed to a Non-Organization-Owned API Consumer
Resource Matchers | MuleSoft Documentation
# Resource Matchers
Anypoint Code Builder 
Anypoint Studio 
## getResourceAsStream(String)
Returns the resource from the path String as a stream.
Example
```
<set-payload
 value="#[MunitTools::getResourceAsStream('util/files/example.txt')]"/>
```

## getResourceAsReusableStream(String)
Returns the resource from the path String as a reusable stream.
Example
```
 <set-payload
  value="#[MunitTools::getResourceAsReusableStream('util/files/example.txt')]"/>
```

## getResourceAsString(path:String,encoding:String)
Returns the resource from the path String as a String, where the second parameter (encoding) is optional.
Example
```
<set-payload
 value="#[MunitTools::getResourceAsString('util/files/example.txt')]"/>
```

You can also specify the encoding:
Example
```
<set-payload
 value="#[MunitTools::getResourceAsString('util/files/exampleISO.txt', 'ISO-8859-1')]"/>
```

## getResourceAsByteArray(String)
Returns the resource from the path String as a byte array.
Example
```
 <set-payload
  value="#[MunitTools::getResourceAsByteArray('util/files/example.txt')]"/>
```

## queueSize(String)
Returns the size of the queue specified inside `#[MunitTools::queueSize()]`.
For example, to assert the size of a queue named `QUEUE_SIZE`:
Example
```
<munit:execution>
 <munit-tools:queue queueName="QUEUE_SIZE">
  <munit-tools:value>#['EXAMPLE']</munit-tools:value>
 </munit-tools:queue>
</munit:execution>
<munit:validation>
 <munit-tools:assert-that expression="#[MunitTools::queueSize('QUEUE_SIZE')]" is="#[MunitTools::equalTo(1)]"/>
</munit:validation>
```

## createMessage(payload: Any, mimeType: String|Null , attributes: Any, attributeMimeType: String|Null)
Creates a Mule message with the specified attributes.
Example
```
<munit:execution>
   <set-payload value="#[MunitTools::createMessage( 'ITEM-1', 'text/plain', { property : 'ATTRIBUTE-1'}, null )]"/>
 </munit:execution>
```

## See Also
  *   * Core Matchers Reference
  * String Matchers Reference
  * Comparable Matchers Reference
Using Aggregators in a Cluster | MuleSoft Documentation
# Using Aggregators in a Cluster
Aggregators don’t work with multiple workers and a persistent object store because clustering isn’t available in CloudHub.   
---  
Aggregators Module works in a cluster out-of-the-box environment. However, to prevent an unexpected behavior consider the following:
When an asynchronous aggregation is defined and the first element arrives, it is scheduled in the primary node of the cluster. Because new values can arrive in any node of the cluster, we need a way to notify and make the primary node schedule that aggregation. To do that, another task in the primary node periodically determines whether it is necessary to schedule a new aggregation or not. This can lead to a problem if the interval between checks for new aggregation scheduling is much longer than the actual timeout of the aggregation, because the aggregation could be over before it is scheduled, or there might be errors in the time computation.
To avoid this issue, configure the frequency at which the primary node checks for new aggregations to schedule. Define this value using either:
  * The global configuration property `mule.aggregatorsSchedulingPeriod` (in milliseconds)
  * The system property `-M-Dmule.aggregatorsSchedulingPeriod`


For further information about how to configure global or system properties, see the configuring properties documentation.
## See Also
  * Aggregators Module Reference
  * MuleSoft Help Center
Enabling Forwarding When Using firewalld | MuleSoft Documentation
# Enabling Forwarding When Using firewalld
`firewalld` is an iptables controller that defines rules for persistent network traffic. If you are using `firewalld` with a Red Hat Enterprise Linux (RHEL) 7.x operating system, you must enable forwarding on the docker0 device. You must also forward any packets being sent from or to the 10.0.0.0/8 subnet.
## To Determine if You Are Using firewalld
To determine if your system is using firewalld, run the following command:
```
systemctl status firewalld.service
```

If firewalld is installed, this command returns the following:
```
$ sudo systemctl status firewalld.service
* firewalld.service - firewalld - dynamic firewall daemon
Loaded: loaded (/usr/lib/systemd/system/firewalld.service; enabled; vendor preset: enabled)
Active: inactive (dead)
Docs: man:firewalld(1)
```

If `firewalld is not installed, this command returns an error message.
## Enable Forwarding
To enable forwarding on the docker0 device, run the following commands:
```
firewall-cmd --permanent --direct --add-rule ipv4 filter FORWARD 1 -o docker0 -j ACCEPT -m comment --comment "docker subnet"
firewall-cmd --permanent --direct --add-rule ipv4 filter FORWARD 1 -s 10.0.0.0/8 -j ACCEPT -m comment --comment "docker subnet"
```

To enable forwarding on the 10.0.0.0/8 subnet, run the following commands:
```
firewall-cmd --permanent --direct --add-rule ipv4 filter INPUT 1 -s 10.0.0.0/8 -j ACCEPT -m comment --comment "docker subnet"
firewall-cmd --permanent --direct --add-rule ipv4 filter INPUT 1 -d 10.0.0.0/8 -j ACCEPT -m comment --comment "docker subnet"
```

## Verify Forwarding
To verify that forwarding rules are in place, run the following command:
```
firewall-cmd --permanent --direct --get-all-rules
```

The output should look like the following example:
```
ipv4 filter FORWARD 1 -o docker0 -j ACCEPT -m comment --comment 'docker subnet'
ipv4 filter FORWARD 1 -s 10.0.0.0/8 -j ACCEPT -m comment --comment 'docker subnet'
ipv4 filter INPUT 1 -s 10.0.0.0/8 -j ACCEPT -m comment --comment 'docker subnet'
ipv4 filter INPUT 1 -d 10.0.0.0/8 -j ACCEPT -m comment --comment 'docker subnet'
```

These rules are node level. This means you must run and verify them on every node, both controller and worker nodes, for Runtime Fabric to work correctly when firewalld is active.   
---
Workday Connector 14.1 | MuleSoft Documentation
# Workday Connector 14.1
Anypoint Connector for Workday (Workday Connector) provides access to standard Workday operations. Workday is a Software-as-a-Service (SaaS) solution developed by Workday, Inc. Workday provides a set of software apps for financial and human capital management, such as human resources, staffing, recruiting, and performance.
Workday Connector provides operations that you can use to perform tasks for educational organizations, human resources, professional services, payroll, and benefits administration.
For compatibility information and fixed issues, see the Workday Connector release notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The Workday API
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have access to:
  * The Workday target resource
  * Anypoint Studio version 4.1.1 or later


## Audience
  * New users, read:
    * Using Anypoint Studio to Configure Workday Connector
    * Examples, which provide one or more use cases for the connector
  * Advanced users, read:
    * XML and Maven Support
    * Examples, which provide one or more use cases for the connector


For a major or minor release, see Upgrading and Migrating to Workday Connector 14.x.
## Common Use Case for the Connector
Use Workday Connector to start any of Workday’s standard operations, such as creating a position request in Workday or adding a fund to a financial management service.
## Exchange Templates and Examples
Anypoint Exchange provides templates that you can use as starting points for your apps and examples that illustrate a complete solution.
  * Workday and ServiceNow Worker Bidirectional Sync
  * Salesforce and Workday Bidirectional Sync
  * Workday Worker to ServiceNow Service Request Migration
  * Salesforce to Workday Financials Account - Customer Migration
  * Workday and ServiceNow Employee Aggregation
  * Workday and Salesforce Worker Aggregation
  * Workday to ServiceNow Service Worker Migration
  * Workday Worker to ServiceNow Service Request Broadcast
  * Workday Worker to ServiceNow User Broadcast
  * Workday to Salesforce Worker Case Broadcast


## Next Step
After you complete the prerequisites and try the templates and examples, you are ready to create your own 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