BassemE/mulesoft-documentation-embeddings huggingface dataset:
Upgrading and Migrating SAP SuccessFactors Connector to Version 5.0 | MuleSoft Documentation
# Upgrading and Migrating SAP SuccessFactors Connector to Version 5.0
Upgrade Anypoint Connector for SAP SuccessFactors (SuccessFactors Connector) to version 5.x.
## Supported Upgrade Paths
From Version | To Version  
---|---  
## Changes in This Release
SAP SuccessFactors Connector 5.0 includes these changes.
  * Basic Authentication is now deprecated.
  * In OAuth SAML Bearer Assertion Authentication:
    * **The private key from the X.509 certificate.** and **The authorisation url.** fields are removed.
For more information about how to generate a keystore file, refer to Generate a Keystore File.
    * **Key store** , **Store password** , **Type** , and **Certificate alias** fields are added.
    * **Scopes** is moved from the **Advanced** tab to the **General** tab.


## Upgrade Prerequisites
Before you perform the upgrade, you must create a backup of your files, data, and configurations in case you need to restore to them.
## Upgrade Steps
Follow these steps to perform the upgrade:
  1. In Anypoint Studio, create a Mule project.
  2. In the **Mule Palette** view, click **Search in Exchange**.
  3. In **Add Dependencies to Project** , enter `successfactors` in the search field.
  4. In **Available modules** , select **SuccessFactors** and click **Add**.
  5. Click **Finish**.
  6. Verify that the SAP SuccessFactors Connector dependency version is `5.0.0` in the `pom.xml` file in the Mule project.


Studio upgrades the connector automatically.
### Verify the Upgrade
After you install the latest version of the connector, follow these steps to verify the upgrade:
  1. In Studio, verify that there are no errors in the **Problems** or **Console** views.
  2. Verify that there are no problems in the project `pom.xml` file.
  3. Test the connection to verify that the operations work.


## Troubleshoot
If there are problems with caching the parameters and caching the metadata, try restarting Anypoint Studio.
### Revert the Upgrade
If it is necessary to revert to the previous version of SAP SuccessFactors Connector, change the `sap-successfactors-connector` dependency version `5.0.0` in the project’s `pom.xml` to the previous version.
You must update the project’s `pom.xml` in Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * SAP SuccessFactors Connector Reference
  * MuleSoft Help Center
Header Injection Policy | MuleSoft Documentation
# Header Injection Policy
API Manager supports policies for adding HTTP headers from a request or response. The policies take effect before sending the request or response. The Header Injection policy performs the following actions:
  * Adds one or more headers into a request from the client to the backend service, or overrides the value of an existing header.
  * Adds one or more headers into a response from the backend service to the client, or overrides the header value in a response from the backend service.


## Applying the Header Injection Policy
Perform the following steps to apply the policy:
  1. From your left navigation, select **API Administration**.
  2. Select the version to which you want to apply the policy.
  3. From your left navigation, select **Policies**.
The policies details page appears.
  4. Click **Apply New Policy**.
The Select Policy dialog box appears.
  5. From the policy list, select the **Header Injection** radio button and click **Configure Policy**.
The Apply Header Injection policy page appears.
  6. In the Inbound Header Map box, type the key-value pair for the inbound header and click .
For example, type `in-header` in the box and type `3` in the value box.
  7. In the Outbound Header Map box, type the key-value pair for the outbound header.
For example, type `out-header` in the box and type an `4` in the value box. Optionally, you can include MEL expressions in the value of the header.
For example, include the following expression to substitute the name of the user-agent in the header text.
`'#[message.inboundProperties['user-agent']]'`
  8. Click **Apply**.
The Policies page is displayed with the Header Injection policy that you added.
Mule Components | MuleSoft Documentation
# Mule Components
The main building blocks of Mule applications are components. Components execute business logic on the messages that flow through your Mule applications. There are a couple types of component: Core components and the components that belong to connectors and modules.
## Core Components
These are individual components that are part of the core of the functionality of Mule Runtime. Here is a sampling of the features that core components let you add to your apps:
  * Asynchronous processing of parts of a flow or subflow
  * Batch processing of messages
  * Initiating subflows
  * Logging
  * Setting payloads
  * Transforming messages with the DataWeave language
  * Creating Try scopes in your flows so that you can catch and respond to errors


For example, the Choice router is a component that dynamically routes messages through a flow according to a set of DataWeave expressions that evaluate message content. Each expression is associated with a different routing option. The effect is to add conditional processing to a flow, similar to an `if`/`then`/`else` code block in most programming languages.
Figure 1. A List of the Core Components in Anypoint Studio
For component documentation, see Core Components.
## Connectors
Connectors group together components that were created to facilitate the integration of MuleSoft applications with any external resources, such as third-party APIs or standard integration protocols. They enable connectivity to SaaS and on-premises applications, systems, and services.
For example, the Salesforce Connector provides components that let you use the Salesforce platform APIs to perform a large number of different operations.
Figure 2. The Salesforce connector and its operations listed in Anypoint Studio
## Modules
Modules group together components that were created to add flexibility to your applications by allowing you to aggregate values compress data, use Java features, use extra features for processing JSON, and more. The features that modules offer are more at the level of traditional application coding.
For example, the XML module provides components that can process and extract data from an XML document.
Figure 3. The XML module and its components listed in Anypoint Studio
## See Also
  * Connectors and Modules (for Mule 4)
Update Your User Profile | MuleSoft Documentation
# Update Your User Profile
When you sign in to the configured IdP for the first time, an Anypoint user is created using your IdP information.
Your user profile includes a username, your name, and email address. Typically, the OpenID Connect `userinfo` endpoint provides a `preferred_username` claim that contains the authenticated user’s username. However, some IdPs such as OpenAM and PingFederate do not support the `preferred_username` claim. Therefore, when Anypoint Platform creates a user, the `email` and `sub` claim values comprise the username if the `preferred_username` claim isn’t present. Claims are made in the following order: `preferred_username`, `email`, `sub`. If a username is created as a single string of random characters and does not have an email address defined, the string may be returning the `sub` claim that the `id` token and `userinfo` endpoint show for the user.
To update user profile information from your configured IdP, sign in to Anypoint Platform through the IdP. When you sign in, your user profile is automatically updated with the information from the IdP.
Adding Policy Implementation Files to Published Policy Definition | MuleSoft Documentation
# Adding Policy Implementation Files to Published Policy Definition
When a policy definition asset is published in Exchange, the asset details page displays a **Pending** flag next to **Implementations** in the left navigation bar. The flag indicates that the policy implementation has not been added. Add the policy implementation files to the policy definition to enable the policy to be available in runtime. The required implementation files are a binary file such as a WebAssembly (WASM) file for Flex Gateway or JAR for Mule 4 runtime and a YAML metadata file.
Before adding the policy implementation files, ensure that the policy definition asset is in the Stable state.
To add the policy implementation files:
  1. In Exchange, select the policy asset to open the asset details page.
  2. Click **Implementations** in the left navigation bar.
  3. Click **Add implementation**.
  4. Enter the name for the implementation.
  5. Click **Choose file** to select the JAR or WebAssembly file.
  6. Click **Choose file** to select the YAML file.
  7. To edit the GroupId, AssetId, Version, and API version, click **Advanced**.
Exchange generates the group ID, asset ID, and version. You can change these values. You can also change an API asset’s version and API version separately. The advanced settings are most often used to change the asset version.
  8. Click **Add implementation**.
The implementation displays in the **Manage implementations** table. From this table, manage the implementation versions of a policy asset. See Manage Versions for more information.
RPA Bot Overview | MuleSoft Documentation
# RPA Bot Overview
RPA Bots are software robots that carry out any RPA processes assigned to them. To execute the processes, RPA Bots require a computer where the applications required for the processes are installed, along with execution configurations and instructions, which are the activities created in RPA Builder for each process step.
The Bot Management module in RPA Manager enables you to manage your bots. Every bot is registered through an API key. After the installation, the bot connects with RPA Manager at defined intervals. You can then assign licenses and service times to the bot, deploy processes for the bot to execute, and monitor the bot’s status and the results of the process runs it carries out.
## See Also
  *
Troubleshooting Einstein AI Connector 1.2 | MuleSoft Documentation
# Troubleshooting Einstein AI Connector 1.2
## Empty API Instance URL Error
If you receive the `Empty API Instance URL` error, confirm that you completed Einstein Generative AI setup correctly for your Salesforce org. For more information, see Set Up Einstein Generative AI.
## See Also
  * MuleSoft Help Center
  *
FTP Connector | MuleSoft Documentation
# FTP Connector
Anypoint Connector for FTP (FTP Connector) provides access to files and folders on an FTP server. FTP connector operations manage file transfers by using File Transfer Protocol (FTP). The connector’s main features include:
  * The ability to read files or fully list directory contents on demand.
  * Support for common FTP operations such as creating directories and copying, moving, renaming, and deleting files.
  * Support for locking files.
  * File matching functionality.
  * A design that is consistent with the File and FTP Connectors.
The same set of operations is available using these two connectors, and they behave similarly.


## Representation of File Attributes
Mule 4 provides a message structure of a payload and attributes in which the data moves around, making that payload a file content. The attributes provide an object that contains metadata on the payload and information such as the file’s name, path, size, and timestamps. For FTP Connector and SFTP Connector, these attributes are known as _file attributes_.
In Mule 4, messages comprise _file content_ (a payload) and _file attributes_ (metadata about the payload, such the file’s name, path, size, and timestamps. The file attributes also describe the format in which a payload is represented by including a file’s encoding and MIME type.
## Before You Begin
To use this connector, you must be familiar with:
  * 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 Anypoint Platform and Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * MuleSoft Help Center
MuleSoft Accelerator for Retail | MuleSoft Documentation
# MuleSoft Accelerator for Retail
MuleSoft Accelerator for Retail empowers retail IT teams to unlock data from systems including ERP, CRM, MDM, commerce, and marketing to activate digital projects faster. Retail IT teams can take advantage of pre-built APIs, connectors, implementation templates, and reference architecture to create customer 360 profiles.
## Use Cases
The following use cases are supported by the MuleSoft Accelerator for Manufacturing:
  * Customer profile sync - The Customer profile sync use case enables retail developers to create a customer 360 view by unlocking customer data from disparate systems.
  * Sales order sync - The Sales order sync use case enables retail developers to create and update sales orders across relevant applications.
  * Product sync - The Product sync use case enables retail developers to update product details in Salsify across relevant applications.
  * Real-time inventory management - The Real-time inventory management use case enables customers to make an informed decision of their online purchase based on real-time inventory of a product in nearby stores.
  * Deliver relevancy with CDP - The Deliver relevancy with CDP use case enables retail developers to combine customer profile data in a standardized format.


## See Also
  *   *   *   * MuleSoft Accelerator for Retail on Exchange
Sleep Processor | MuleSoft Documentation
# Sleep Processor
Anypoint Code Builder 
Anypoint Studio 
The Sleep processor allows you to pause your test for a specific time. You can use this processor to simulate a delay in the processing of the flow:
```
<munit-tools:sleep time="100" timeUnit="MILLISECONDS"/>
```
    
Numerical value for the unit of time that your test waits before going to sleep. 

`timeUnit` 
    
The unit in which the `time` value is measured.
Possible values are:
  * `MILLISECONDS` (default)
  * `MICROSECONDS`
  * `MINUTES`
  * `NANOSECONDS`
  * `SECONDS`
isUriType | MuleSoft Documentation
# isUriType
## isUriType(t: Type): Boolean
Returns `true` if the input is the Uri type.
_Introduced in DataWeave version 2.3.0._
### Parameters
Name | Description  
---|---  
The type to check.  
### Example
This example shows how `isUriType` behaves with different inputs.
#### Source
```
%dw 2.0
import * from dw::core::Types
type AUri = Uri
output application/json
---
{
  a: isUriType(AUri),
  b: isUriType(Uri),
  c: isUriType(String),
}
```

#### Output
```
{
 "a": true,
 "b": true,
 "c": false
}
```
Importing a Connector from Exchange | MuleSoft Documentation
# Importing a Connector from Exchange
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.
Anypoint Connectors provide operations for retrieving, modifying, and sending data to and from systems. In addition to the built-in connectors that Anypoint Code Builder provides, you can download many other connectors from Anypoint Exchange.
  * Import a Connector from the Canvas
  * Import a Connector with a Command


## Import a Connector from the Canvas
To import a connector from Exchange and add it to your configuration:
  1. {open-config-xml}, such as `my-project-name.xml`.
  2. Click (**Show Mule graphical mode**) in the activity bar to open the UI canvas if it doesn’t open automatically.
  3. Add the connector the same way you added other components from the canvas:
    1. In the canvas, click the (**Add component**) icon.
    2. In the **Add Component** panel, click **Connectors**.
    3. Click the connector name and then click the operation to add, such as **Publish** :
    4. If the connector is not available locally, click the (**Search in Exchange**) toggle:
Search locally  
---  
Search in Exchange  
    5. Select the connector to add to your project. You can select from connector versions that are compatible with your Mule runtime and Java version set in Project Properties.
    6. Select the operation from the **Add Component** panel.


## Import a Connector with a Command
To import a connector from Exchange to use later in your project:
  1. {open-config-xml}, such as `my-project-name.xml`.
  2. Click (**Show Mule graphical mode**) in the activity bar to open the canvas if it doesn’t open automatically.
  3. Open the Command Palette.
Show me how
     * Use the keyboard shortcuts:
       * Mac: Cmd+Shift+p
       * Windows: Ctrl+Shift+p
     * In the desktop IDE, select **View** > **Command Palette**.
     * In the cloud IDE, click the (menu) icon, and select **View** > **Command Palette**.
  4. Select the following command:
```
MuleSoft: Import Asset from Exchange
```

  5. Select **Connector**.
  6. Search for the connector name to import, such as "MQ," for example:
  7. Select the connector.
  8. At the prompt, select the version of the connector to import, such as `v4.0.3`.
Anypoint Code Builder imports the connector and makes it available in the Components list.


For more information about the connectors available on Exchange, see Connectors. For more information about Exchange, see Exchange (US) or Exchange (EU) and Anypoint Exchange Overview.
Instance Conformance | MuleSoft Documentation
# Instance Conformance
You can check for API instance information conformance using a custom or MuleSoft-provided ruleset. A ruleset provided by MuleSoft that validates API instance information is:
  * Mule API Management Best Practices


After Anypoint API Governance identifies conformance issues in your API instances:
  1. View the governance validation report to get information about the issues.
  2. If the issues are in the instance configuration, fix the instance using API Manager.
  3. If the issues are instance-related issues in the specification, fix the specification using Design Center.


Use the information in the governance validation report to determine why the conformance failed.
## View Rule Details in the Rulesets
For more information about fixing the issues, open the ruleset in Exchange and view the descriptions and messages for the rules that your API doesn’t conform to.
### Example Rules and Recommended Fixes
The following table shows some example rules and the actions to take to fix conformance to those rules:
Rule | Aspect | Recommended Fix  
---|---|---  
<policy-name-a> policies should be configured before <policy-name-b> policies |  An instance ID |  In API Manager, rearrange the policies for the instance as suggested in the rule.  
The API instance has no <policy-name> policy applied |  An instance ID |  In API Manager, add the specified policy to the instance.  
All API Instances server URLs should be described in the API specification |  A specification |  Edit the specification and add descriptions for all its API instance URLs.  
## See Also
  * Governing API Instances
  * Monitoring API Conformance
  * Specification Conformance
localTime | MuleSoft Documentation
# localTime
## localTime(parts: LocalTimeFactory): LocalTime
Creates a `LocalTime` value from values specified for `hour`, `minutes`, and `seconds` fields.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
`Number` values for `hour`, `minutes`, and `seconds` fields. Valid values are 0 through 23 for the `hour`, 0 through 59 for `minutes`, and 0 through 59 (including decimals, such as 59.99) for `seconds` fields. You can specify the name-value pairs in any order, but the output is ordered as a default `LocalTime` value, such as `10:10:10`. The input fields are parts of a `LocalDateTimeFactory` type.  
### Example
This example shows how to create a value of type `LocalTime`.
#### Source
```
%dw 2.0
import * from dw::core::Dates
output application/json
---
{
 newLocalTime: localTime({ hour: 12, minutes: 30, seconds: 40})
}
```

#### Output
```
{
  "newLocalTime": "12:30:40"
}
```
APIkit Compatibility | MuleSoft Documentation
# APIkit Compatibility
The following table shows the compatibility between APIkit modules and the corresponding Mule versions:
Module | Mule 3 | Mule 4  
---|---|---  
APIkit for AsyncAPI  
APIkit for GraphQL  
APIkit for OData v2  
APIkit for OData v4  
APIkit for REST  
APIkit for SOAP  
Some versions of APIkit are compliant with FIPS 140-2 standards. For more information about versions of APIkit that meet these compliance standards, see the APIkit Release Notes. Additionally, learn about Mule runtime FIPS 140-2 Compliance Support.
## Language and Protocol Support
Language/protocol | Version  
---|---  
AsyncAPI spec  
2.0 and 4.0  
OpenAPI Specification (OAS) | 2.0 and 3.0  
RESTful API Modeling Language (RAML) | 1.0 and 0.8  
1.1 and 1.2  
## Next Steps
Depending on the language and protocols you want to use to develop your Mule application, choose the APIkit module that best suits your needs.
  * APIkit for AsyncAPI
  *   * APIkit for OData V2
  * APIkit for OData V4
  *   *
Flex Gateway Version Lifecycle | MuleSoft Documentation
# Flex Gateway Version Lifecycle
Starting with Flex Gateway 1.9, MuleSoft introduces two new release channels, Edge and Long-term Support (LTS). These release channels are available for both Managed and Self-Managed Flex Gateway.
## Edge and LTS Releases for Flex Gateway
Consider the information in this table to determine which release channel best suits your requirements.
Channel Type | Release Cadence | Differentiators | Support Coverage  
---|---|---|---  
Three times per year
  * March
  * November

|  Includes new features more often and has a shorter support period for each release. |  Flex Gateway 1.9 and later
  * Four months Standard Support
  * Four months Extended Support

Flex Gateway 1.8 and earlier
  * See MuleSoft Support Policy.

  
Once a year |  Bundles new features in an annual release and has a longer support period for each release. |  Flex Gateway 1.9 and later
  * Twelve months Standard Support
  * Twelve months Extended Support

Flex Gateway 1.8 and earlier
  * See MuleSoft Support Policy.

  
For detailed information and support timeframes for Flex Gateway 1.8 and earlier, see the MuleSoft Support Policy.
## Deployment Models and Lifecycle Management
Flex Gateway lifecycle management varies depending on the release channel and the type of gateway. Managed Flex Gateway instances are auto-upgraded regularly, and any available patches are applied once a month. Self-managed gateways are never patched or upgraded automatically.
Action | Managed Gateway | Self-Managed Gateway  
---|---|---  
Auto-upgrade |  Managed Gateways are auto-upgraded to the latest minor version within their respective channels (Edge or LTS).
  * Edge: Three times per year
  * LTS: Once a year

|  No auto-upgrade capabilities  
Monthly auto-patching |  Available for Flex Gateway versions that are within the support period for their respective channels (Edge or LTS).  
Self-upgrade |  You can manually upgrade to the latest version that matches your release channel (Edge or LTS) before the scheduled automatic upgrade. |  Always available  
You can revert to the previous version if it’s still within the release channel support period. |  Available to the previously used version  
Until End of Extended Support  
Keep running |  Until End of Extended Support  
Supportability |  Standard Support (auto-upgrade ensures that managed gateways are always on the latest Edge or LTS version). |  Until End of Extended Support. See the MuleSoft Support Policy for more information.  
For information on patching, upgrading, rolling back, or deleting a gateway, see Maintaining a Flex Gateway.
Schema Element Visibility in Anypoint DataGraph | MuleSoft Documentation
# Schema Element Visibility in Anypoint DataGraph
You can hide the fields, types or query methods that you don’t want to have visible in the unified schema. The fields, types, or query methods that you hide make them unavailable for querying.
Managing the visibility of your schema elements keeps your unified schema manageable and clean. You can modify the visibility of your elements later.
In Anypoint DataGraph, the elements that you choose to hide are _hidden_ , and the elements that you choose to unhide are _visible_.
By default, all nested types are hidden. If you wish to add a nested type to the unified schema, and query it, you must unhide it first.
You cannot hide a method that you configured to be a default query method, or a field that you configured as a primary key.
## Manage Visibility of Schema Elements
Hiding or unhiding elements in your API schema allows you to control the granularity of information that is available in the unified schema.
In the API schema, choose the object, field, or method for which you want to manage visibility, and click the **Hidden/Visible** toggle.
You must hide or unhide elements _before_ adding them to the unified schema.
HL7 v2 to FHIR Converter | MuleSoft Documentation
# HL7 v2 to FHIR Converter
The HL7 v2 to FHIR converter comes with a ready to use template for HL7 v2 to FHIR conversion, which is based on the guidance provided by the HL7 v2 to FHIR Implementation Guide. This template can be extended or modified to meet specific conversion requirements.
## Functional diagram
## Advantages
  * Removes manual work associated with HL7 v2 and FHIR conversion following HL7 identified mappings
  * Supports the most commonly used HL7 v2 message formats
  * HL7 connector is preconfigured for this use case to easily read HL7 v2 messages
  * Solution can be extended to support any custom fields and segments
  * Highly performant with underlying DataWeave engine


## See Also
  * MuleSoft Accelerator for Healthcare
Configuring LDAP in Anypoint Platform Private Cloud | MuleSoft Documentation
# Configuring LDAP in Anypoint Platform Private Cloud
Configure user management using LDAP version 3 for Anypoint Platform Private Cloud Edition (Anypoint PCE). User management through LDAP is available only for Anypoint PCE.
  1. From Anypoint Platform, click **Access Management > External Identity**.
A form for configuring LDAP appears.
  2. In the LDAP configuration form, set the connection settings for your LDAP service.
     * Host
The host name of your LDAP server. If you are using TLS in your ldap server, use `ldaps://mulesoft.com` use this host name: `ldap://mulesoft.com`
     * Port
The port used to communicate to your LDAP server. The default ldap port is `389`. The default ldaps port is `636`.
     * Self-Signed Cert
Mark this check box if you are using a self-signed certificate on your LDAP server. Use a Self-Signed certificate for testing your connection to the LDAP server.
     * Bind DN
The distinguished names for the user making the LDAP queries. For example, `uid=admin,ou=people,dc=mulesoft,dc=com`.
     * Password
The password for the LDAP server. For example,`examplepassphrase`.
     * Connection Timeout
The timeout frame (in seconds) for a connection. For example, `10`.
     * Operation Timeout
The timeout frame (in milliseconds) for an operation. For example, `30000`.
  3. Set up search bases and filters
     * User
The base level for your user search base object. For example, `uid=admin,dc=mulesoft,dc=com`.
Group
The base level for your groups search base object. For example, `ou=groups,dc=mulesoft,dc=com`.
  4. Set the distinguished names for your user and group
     * User
The distinguished name for your user search base object. For example,`uid={{username}},ou=people.dc=mulesoft,dc=com`.
     * Group
The distinguished name for your groups search base object. For example, `ou=groups,dc=mulesoft,dc=com`.
     * Search filters
       * User by Username
The search filter to find users by user name. For example, `(&(objectClass=inetOrgPerson)(uid={{username}}))`.
       * User by Email
The search filter to find users by email. For example, `(&(objectClass=inetOrgPerson)(mail={{email}}))`.
       * Group by GroupName
The search filter to find groups by groupName. For example, `(&(objectClass=groupOfNames)(cn={{groupName}}))`.
       * User’s Groups by Username
The search filter to find user groups by userName. For example, `(&objectClass=GroupOfNames)(member=uid={{username}},ou=people,dc=mulesoft,dc=com))`.
  5. Map the User fields
     * Username
Field that represents the user name. For example, `uid`.
     * Email
Field that represents the email. For example, `mail`.
     * First Name
Field that represents the first name. For example, `givenName`.
Last Name
Field that represents the last name. For example, `sn`.
     * ID
ID for your user. For example, `uid`.
  6. Map the group fields
     * Group Name
Field that represents your Group name. For example,`cn`.
     * ID
Field that represents your groups Id. For example, `bcd6b4c4-aec5-4493-be1b-8e2e8eecf662`.
  7. Save the configuration.
FTPS Connector XML and Maven Support | MuleSoft Documentation
# FTPS 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/ftps
http://www.mulesoft.org/schema/mule/ftps/current/mule-ftps.xsd
```

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


## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Indexed Readers in DataWeave | MuleSoft Documentation
# Indexed Readers in DataWeave
In DataWeave, some readers of input data (such as XML, JSON, and CSV) support an indexed strategy to avoid loading the whole document in memory while still allowing random access just like in the in-memory strategy. DataWeave uses indexed readers when the input is larger than a certain configurable threshold or if the `indexedReader` setting is set to `true`.
The trade-off for managing files that wouldn’t fit in memory is to write the files to a temporary file in disk and index the document content beforehand, which also takes time and disk space.
Indexed readers can process input files up to 20 GB. For bigger files use the streaming strategy, which is faster. Despite this mode being more limited in functionality, there’s no maximum input size limitation for streaming readers.
The actual max input file size supported is difficult to estimate because it depends on the content of the input.
The following list shows the limits on different parts of the input file:
  * Max nesting depth: `4096`
  * Max individual value size: `4 GB`
  * Tokens: `​​2^32-1` (approximately 4 billion) A token is either a key/value pair, object-start or array-start, that limits the max input file size. The amount of the max input file size is irrespective of the size of each token in the file. The bigger your average value length, the bigger your input file size can be because what is important is the amount of tokens, not their size.


The following examples show input file size samples:
In this example, the max input file size is between 40 GB and 50 GB:
```
[
 {
  "name": "Mariano",
  "lastName": "Achaval"
 },
 ...
]
```

The following example is similar to the previous one but minified where the max file size is approximately 30 GB:
```
[{"name":"Mariano","lastName":"Achaval"},...]
```

The following example shows a minified array of numbers `1`. DataWeave supports only approximately 8 GB of such file:
```
[1,1,1,1,1,1,...]
```

## Large Strings Management
When processing a `String` with a size larger than 1.5 MB, DataWeave automatically splits the value in chunks to avoid out-of-memory issues. This feature works only with `JSON` and `XML` input data.
You can configure the threshold that DataWeave uses to determine when to process a string using this splitting strategy by modifying the following system property:
```
com.mulesoft.dw.max_memory_allocation
```

Note that using this feature has a negative impact on performance due to splitting strings and accessing them through local storage. If your environment has enough resources to load all content in memory, you can also disable this string management feature completely by setting the value of the following system property to `false`:
```
com.mulesoft.dw.buffered_char_sequence.enabled
```

## See Also
  *   * Supported DataWeave Formats
Add a TLS Context to Mule | MuleSoft Documentation
# Add a TLS Context to Mule
After you create a secret group, you can add a Transport Layer Security (TLS) context to encrypt inbound traffic to Mule 4 proxies. When you add the TLS context, you can select the ciphers to use with the TLS context.
You can use the TLS context you store in the secrets manager when you configure an HTTPS API proxy.
## Add TLS Context
Adding a TLS context to your secret group involves supplying a name, target, security information, version, keystore and, optionally, truststore.
  1. In the **Secret Groups** list view, select the secret group to which to add a TLS context.
  2. Select **TLS Context** in the menu on the left, and click **Add TLS Context**.
  3. In the Create TLS Context screen, add the required information:
     * **Name** Enter a name for your TLS context.
     * **Target** Select **Mule** to use the TLS context as the SSL validation for Mule 4-based API proxies. Uses the TLS context as the SSL validation for Mule 4-based API proxies.
     * **TLS Version** By default, TLS 1.2 is selected. You can select TLS 1.1 to support both versions.
     * **Keystore** From the drop-down list, select the keystore associated with the TLS context.
     * **Truststore** Optionally, select a truststore associated with the TLS context if you are using a truststore to store certificates trusted by the client. If the Target value for the TLS context is **Mule** , you can select **Insecure** if you don’t want certificate validation enforced.
     * **Expiration Date** Optionally, select the expiration date for the TLS context. The information is considered as metadata of the TLS context. The expiry date of the certificates in the associated keystore or truststore doesn’t change.
  4. Optionally, select ciphers for the TLS context.
  5. Click **Save**.


## See Also
  * Create a Secret Group
Viewing Managed Flex Gateway Metrics | MuleSoft Documentation
# Viewing Managed Flex Gateway Metrics
## View a Managed Flex Gateway Metrics in Runtime Manager
The Managed Flex Gateway Dashboard in Runtime Manager presents a comprehensive view of the gateway, detailing its status, endpoints, private space, API capacity, request volume, data consumption, and average CPU and memory usage. In addition, it provides metrics on latency and error count for thorough monitoring.
To view information about a Managed Flex Gateway Instance:
  1. From Anypoint Platform, select **Runtime Manager**.
  2. Select **Flex Gateways** in the navigation menu.
  3. Select the name of the Managed Flex Gateway to view its status.
Google BigQuery Connector 1.0 | MuleSoft Documentation
# Google BigQuery Connector 1.0
Anypoint Connector for Google BigQuery (Google BigQuery Connector) syncs data and automates business processes between Google BigQuery and third-party applications, either on-premises or in the cloud.
For information about compatibility and fixed issues, refer to the Google BigQuery Connector Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The Google BigQuery 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 the Google BigQuery target resource
  * Anypoint Platform
  * Anypoint Studio version 7.3.5 or later


## Common Use Cases For the Connector
These are some common use cases for Google BigQuery Connector:
  * Use log and event data collection to analyze problems
  * Insert, update, and delete data in Google BigQuery
  * Execute a query in Google BigQuery


For examples of these use cases, refer to Google BigQuery Connector Examples.
## Connection Types
Google BigQuery connections use the following authentication types:
  * JWT Connection Uses a token for authentication
  * OAuth2 Connection Uses service account authentication


For information about configuring authentication types, refer to Configure a Global Element for the Connector.
## 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
  * Google BigQuery Connector Reference
  * MuleSoft Help Center
Configuring Backup and Restore for Anypoint Platform PCE | MuleSoft Documentation
# Configuring Backup and Restore for Anypoint Platform PCE
Anypoint Platform Private Cloud Edition (Anypoint Platform PCE) requires you to install, configure, and manage an NFS server, ensuring frequent backups are configured and performed.
To preserve your data:
  * Enable automatic backups to protect against system failures or operational issues.
  * Schedule backups at least daily, or more frequently based on your needs.
  * Store backups externally, outside the Anypoint Platform cluster.


The backup and restore process is controlled via Anypoint Platform PCE APIs.
## Create a Backup
To create a backup, run the following command:
`curl -k <platform-dns>/platform/backup-X POST -H 'Authorization: Bearer ${token}' -H 'Content-Type: application/json' -d '{"backup-file-name": "${backupFileName}.tar.gz", "nfs-server": "${fileSystemDns}", "nfs-path": "/"}'`
### Backup Content
Information | Included in Anypoint Platform PCE Backup  
---|---  
Configurations  
Object Store  
Disclaimer settings  
SMTP settings  
DNS settings  
Platform certificate  
NFS settings  
Anypoint Monitoring metrics  
*Anypoint Platform PCE has information only about runtimes, such as their names and status.
## Perform a System Restore
Consider the following before you perform a system restore:
  * Before running a restore, configure certain settings, such as NFS, certificates, and DNS because they are not included in the backup.
  * Backups cannot be transferred between different versions of Anypoint Platform PCE; therefore, your new installation must match the version of your backup.


To perform the restore, run the following command:
`curl -k <platform-dns>/platform/restore-X POST -H 'Authorization: Bearer ${token}' -H 'Content-Type: application/json' -d '{"backup-file-name": "${backupFileName}.tar.gz", "nfs-server": "${fileSystemDns}", "nfs-path": "/"}`
The backup file is stored on the NFS storage.
## See Also
  * Managing Anypoint Platform PCE
  * Installing Anypoint Platform Private Cloud
  * Upgrade Anypoint Platform Private Cloud
contains | MuleSoft Documentation
# contains
## contains<T>(@StreamCapable items: Array<T>, element: Any): Boolean
Returns `true` if an input contains a given value, `false` if not.
This version of `contains` accepts an array as input. Other versions accept a string and can use another string or regular expression to determine whether there is a match.
### Parameters
Name | Description  
---|---  
The input array.  
Element to find in the array. Can be any supported data type.  
### Example
This example finds that `2` is in the input array, so it returns `true`.
#### Source
```
%dw 2.0
output application/json
---
[ 1, 2, 3, 4 ] contains(2)
```

### Example
This example indicates whether the input array contains '"3"'.
#### Source
```
%dw 2.0
output application/json
---
ContainsRequestedItem: payload.root.*order.*items contains "3"
```

#### Input
```
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <order>
   <items>155</items>
  </order>
  <order>
   <items>30</items>
  </order>
  <order>
   <items>15</items>
  </order>
  <order>
   <items>5</items>
  </order>
  <order>
   <items>4</items>
   <items>7</items>
  </order>
  <order>
   <items>1</items>
   <items>3</items>
  </order>
  <order>
    null
  </order>
</root>
```

#### Output
```
{ "ContainsRequestedItem": true }
```

## contains(text: String, toSearch: String): Boolean
Indicates whether a string contains a given substring. Returns `true` or `false`.
### Parameters
Name | Description  
---|---  
An input string (a `String`).  
The substring (a `String`) to find in the input string.  
### Example
This example finds "mule" in the input string "mulesoft", so it returns `true`.
#### Source
```
%dw 2.0
output application/json
---
"mulesoft" contains("mule")
```

### Example
This example finds that the substring `"me"` is in `"some string"`, so it returns `true`.
#### Source
```
%dw 2.0
output application/json
---
{ ContainsString : payload.root.mystring contains("me") }
```

#### Input
```
<?xml version="1.0" encoding="UTF-8"?>
<root><mystring>some string</mystring></root>
```

#### Output
```
{ "ContainsString": true }
```

## contains(text: String, matcher: Regex): Boolean
Returns `true` if a string contains a match to a regular expression, `false` if not.
### Parameters
Name | Description  
---|---  
An input string.  
A Java regular expression for matching characters in the input `text`.  
### Example
This example checks for any of the letters `e` through `g` in the input `mulesoft`, so it returns `true`.
#### Source
```
%dw 2.0
output application/json
---
contains("mulesoft", /[e-g]/)
```

### Example
This example finds a match to `/s[t|p]rin/` within `"A very long string"`, so it returns `true`. The `[t|p]` in the regex means `t` or `p`.
#### Source
```
%dw 2.0
output application/json
---
ContainsString: payload.root.mystring contains /s[t|p]rin/
```

#### Input
```
<?xml version="1.0" encoding="UTF-8"?>
<root><mystring>A very long string</mystring></root>
```

#### Output
```
{ "ContainsString": true }
```

## contains(text: Null, matcher: Any): false
Helper function that enables `contains` to work with a `null` value.
_Introduced in DataWeave version 2.4.0._
AS2 Connector 6.9 | MuleSoft Documentation
# AS2 Connector 6.9
Mule runtime engine (Mule) supports the AS2 protocol through Anypoint Connector for AS2 (AS2 Connector).
AS2 Connector enables trading partners to transmit and receive AS2 messages with EDI-X12, EDIFACT, XML, or binary payloads, for example:
  * Send messages, signed or unsigned, over HTTP or HTTPS, using the AS2 protocol
  * Receive messages over HTTP or HTTPS, using the AS2 protocol
  * Receive asynchronous MDN for sent messages


For compatibility information and fixed issues, see the AS2 Connector Release Notes.
For a major or minor release, see Upgrading and Migrating.
## Before You Begin
To use this connector, you must be familiar with:
  * The AS2 target resource
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * How to create a Mule app using Anypoint Studio (Studio)


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


## Common Use Cases for the Connector
Common use cases for AS2 Connector include the following:
  * Send with sync MDN


Sends a message through HTTP or HTTPS using the AS2 protocol requesting the partner for a synchronous MDN (receipt)
  * Send with async MDN


Sends a message through HTTP or HTTPS using the AS2 protocol requesting the partner for an asynchronous MDN (receipt)
  * Listener


Source that receives messages via HTTP or HTTPS using the AS2 protocol
  * MDN Listener


Source that receives asynchronous MDN receipts via HTTP or HTTPS using the AS2 protocol
  * Non repudiation Listener


Source that receives a signed copy of a receipt or a message for persistent non-repudiation storage
## Non-Repudiation Storage of AS2 Messages and MDNs
If needed, you can configure non-repudiation storage for your AS2 operations to support regulatory or compliance requirements.
Only signed messages and MDNs are eligible for non-repudiation.
The following AS2 Connector sources and operations support the non-repudiation feature:
  * AS2 Send Sync operation
  * AS2 Send Async operation
  * AS2 Listener source
  * AS2 MDN Listener source


### Before You Begin for Non-Repudiation Storage
To enable non-repudiation of a message in AS2 Connector, you must implement and configure a separate Mule flow that acts as a non-repudiation flow:
  * The non-repudiation flow must have access to the signed MIME message that is passed to it, along with appropriate non-repudiation specific attributes.
  * This non-repudiation-specific Mule flow is responsible for receiving, storing, and acting upon the messages and attributes it receives.
  * The name of this non-repudiation flow must be configured on an appropriate listener or operation that has non-repudiation storage enabled.


## 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
  * MuleSoft Help Center
Tutorial: Build an API from Start to Finish | MuleSoft Documentation
# Tutorial: Build an API from Start to Finish
API-led connectivity enables delightful experiences on a variety of devices for your customers. Different software applications communicate and share information across different systems. An Application Programming Interface (API) acts as a digital messenger and translator between those applications and systems, ensuring you can adapt to changes, reuse solutions efficiently, and build security into the digital touchpoints of your business.
Take your first end-to-end, API-led journey in MuleSoft:
  1.   2. Design an API Specification
  3.   4. Add Validation and Error Handling
  5. Deploy to CloudHub
  6. 

After you’ve experienced the end-to-end journey with a single-resource API that you create, use the model to plan your own connectivity projects.
## See Also
  * What is API-led Connectivity