BassemE/mulesoft-documentation-embeddings huggingface dataset:
APIkit for SOAP Error Handling Reference | MuleSoft Documentation
# APIkit for SOAP Error Handling Reference
When something goes wrong with a part of your flow, you get a message with an error type.
## APIkit for SOAP Error Types
APIkit for SOAP defines two error types:
Error Type | Description  
---|---  
APIKIT-SOAP:ROUTER | Routing exception  
APIKIT-SOAP:FAULT | Fault exception  
## APIkit for SOAP Error Handling
APIkit for SOAP scaffolder generates no error-handling code.
## See Also
  *
APIkit for OData v4 Error Handling Reference | MuleSoft Documentation
# APIkit for OData v4 Error Handling Reference
## Error Types
APIkit for OData v4 defines the following error types:
Error Type | Description  
---|---  
APIKIT-ODATA:NOT_IMPLEMENTED | Requested service, feature, or operation not implemented  
APIKIT-ODATA:MALFORMED_URI | Invalid request URI  
APIKIT-ODATA:MALFORMED_SEARCH | Invalid request `$search` expression in URI  
APIKIT-ODATA:SERIALIZATION | Generic error for serialization issues  
APIKIT-ODATA:DESERIALIZATION | Generic error for deserialization issues  
APIKIT-ODATA:TRANSFORMATION | Generic error for issues related to URI to SQL transformations  
APIKIT-ODATA:INTERNAL_SERVER_ERROR | Generic error for internal server issues  
APIKIT-ODATA:NOT_FOUND | Generic error for not found  
APIKIT-ODATA:EXPANSION | Generic error for issues during expansion  
## Error Handling
APIkit for OData v4 scaffolder generates an error handler with a single `On Error Propagate` catch that serves as a generalized error formatter.
```
...
  <error-handler name="Error_Handler">
   <on-error-propagate name="On_Error_Propagate" enableNotifications="true" logException="true" type="ANY">
    <ee:transform>
     <ee:message>
      <ee:set-payload><![CDATA[%dw 2.0
output application/json
---
{
	error: {
		code: error.errorMessage.payload.code default "UNKNOWN",
		message: error.errorMessage.payload.message default error.description,
		target: error.errorMessage.payload.target,
		details: error.errorMessage.payload.details default [{code: "UNKNOWN", message: error.detailedDescription, target: null}],
		innererror: error.errorMessage.payload.innerError default error.childErrors
	}
}]]></ee:set-payload>
     </ee:message>
     <ee:variables>
      <ee:set-variable variableName="statusCode"><![CDATA[error.errorMessage.payload.statusCode default 500]]></ee:set-variable>
     </ee:variables>
    </ee:transform>
   </on-error-propagate>
  </error-handler>
...
```

## See Also
  *
Zuora AQuA Connector | MuleSoft Documentation
# Zuora AQuA Connector
Zuora AQuA Connector v1.0.0
Anypoint Connector for Zuora AQuA (Zuora AQuA Connector) is a smart connector that is generated using REST Connect 2.0. Zuora AQuA Connector enables you to connect to the Zuora platform and use all the operations provided by the Zuora AQuA API, including:
  * Creating a batch query
  * Deleting batch query jobs by ID
  * Retrieving an aggregate query using the job ID
  * Retrieving batch query jobs partner project by partner project ID
  * Retrieving a file by the file ID


For information about the Zuora AQuA API methods and parameters, see the Zuora AQuA API Documentation.
## About Connectors
Anypoint connectors are Mule runtime engine (Mule) extensions that enable you to connect to APIs and resources on external systems, such as Salesforce, Zuora AQuA, ServiceNow, and Twitter.
## Before You Begin
To use the Zuora AQuA connector, you must be familiar with Zuora AQuA, Mule, Anypoint Connectors, Anypoint Studio, Mule concepts, elements in a Mule flow, and Global Elements.
Before creating an app, you must have access to the Zuora AQuA target resource and Anypoint Platform. You must also understand how to create a Mule app using Anypoint Studio.
### Compatibility
Application/Service | Version  
---|---  
4.1.1 and later  
Anypoint Studio | 7.1.2 and later  
## Next Step
After you have read this topic, you are ready to create an app with Anypoint Studio.
## See Also
  * Zuora AQuA connector in Anypoint Exchange
  * Zuora AQuA Release Notes
  * MuleSoft Help Center
  * REST Connect Connector Generator
You cannot deploy this message flow because the payload storage is not properly configured | MuleSoft Documentation
# You cannot deploy this message flow because the payload storage is not properly configured
## Cause
You have not configured the Payload Storage.
## Solutions
If your payload storage is configured, verify that it is active:
  1. From within Anypoint Partner Manager, select your `hostname` profile.
  2. Scroll down to Payload storage and click **Edit**.
  3. Review your payload storage configuration and status.
  4. If your payload storage is not configured, configure it as described in Configuring a Payload Storage API.
Object Store v2 Release Notes | MuleSoft Documentation
# Object Store v2 Release Notes
The following release notes are provided for Object Store:
  * Object Store v2 Release Notes
  * Object Store Connector Release Notes (for Mule 4)


## See Also
  * CloudHub Runtime and Operating System Patch Update Release Notes
pow | MuleSoft Documentation
# pow
## pow(base: Number, power: Number): Number
Raises the value of a `base` number to the specified `power`.
### Parameters
Name | Description  
---|---  
A number (`Number` type) that serves as the base.  
A number (`Number` type) that serves as the power.  
### Example
This example raises the value a `base` number to the specified `power`. Note that you can also use the `pow(base,power)` notation (for example, `pow(2,3)` to return `8`).
#### Source
```
%dw 2.0
output application/json
---
[ (2 pow 3), (3 pow 2), (7 pow 3) ]
```

#### Output
```
[ 8, 9, 343 ]
```
Importing Types From Other Modules | MuleSoft Documentation
# Importing Types From Other Modules
Every module can declare a set of types that are part of the module’s API. This set of types can then be imported by other modules, while keeping the original module’s namespace definition.
Importing another module’s types is useful in many cases, including:
  * Reusing the logic bundled inside the type, such as a specific authentication method.
  * Exposing the user to the same API for configuring the same properties. For example, if you want to configure the same parameters in the same order, with the same descriptions, you can enforce that by using the same types in different modules.


You can reuse a module’s type in three steps:
  1. Add the dependency in your `pom.xml` to the `mule-plugin` whose API you want to use:
```
  <dependency>
    <groupId>org.mule.connectors</groupId>
    <artifactId>mule-sockets-connector</artifactId> **(1)**
    <version>${muleSocketsConnectorVersion}</version>
    <classifier>mule-plugin</classifier> **(2)**
  </dependency>
```

The module where the Type is declared  
---  
Remember to add the `mule-plugin` classifier in the dependency  
  2. Declare an `@Import` in the Extension class referencing the type you want to import:
```
@Extension(name = "HTTP")
@Import(type = TcpClientSocketProperties.class)
@Import(type = TcpServerSocketProperties.class)
public class HttpConnector {
}
```

  3. Use the types in your parameters declaration:
```
@Alias("request")
public class HttpRequesterProvider implements CachedConnectionProvider<HttpExtensionClient> {
 @Parameter
 private TcpClientSocketProperties clientSocketProperties;
}
```



Notice how this changes the DSL declaration, since now your extension (in this case `http`) can receive parameters declared in another namespace (in this example, `sockets`):
```
<http:request-connection>
 <http:client-socket-properties>
   <sockets:tcp-client-socket-properties connectionTimeout="1000" keepAlive="true" receiveBufferSize="1024"/>
 </http:client-socket-properties>
</http:request-connection>
```
Enabling FIPS 140-2 on Mule Applications | MuleSoft Documentation
# Enabling FIPS 140-2 on Mule Applications
You can configure Mule application containers to run in FIPS 140-2 compliance mode.
These instructions assume that you are familiar with FIPS 140-2, the US government security standard that requires that compliant parties use only cryptographic algorithms and techniques that have been certified by NIST.
## Enable FIPS 140-2 Compliance Mode
  1. Using `kubectl`, patch the `custom-properties` secret in the `rtf` namespace by setting the `FIPS_ENABLED` key to `true`:
```
# kubectl patch secret custom-properties -n rtf -p='{"stringData":{"FIPS_ENABLED": "true"}}'
```

After making this change, when you deploy new applications or restart existing applications, their containers run in FIPS 140-2 compliance mode.
  2. To verify an application is running in FIPS 140-2 compliance mode, review the application’s startup log:
```
# kubectl logs <app-pod-name> -n <env-id> -c app -f| grep -i fips
Running in FIPS mode
* Security model: fips140-2                     *
* - mule.security.model = fips140-2
```
DataFormat Types (dw::extension::DataFormat) | MuleSoft Documentation
# DataFormat Types (dw::extension::DataFormat)
Type | Definition | Description  
---|---|---  
DataFormat |  `type DataFormat = { binaryFormat?: Boolean, defaultCharset?: String, fileExtensions?: Array<String>, acceptedMimeTypes: Array<MimeType>, reader: (content: Binary, charset: String, settings: ReaderSettings) -> Any, writer: (value: Any, settings: WriterSettings) -> Binary }` |  Represents the `DataFormat` definition and contains the following fields:
  * `binaryFormat`: True if this is data format is represented as binary representation instead of text. False if not present.
  * `defaultCharset`: Default character set of this format, if any.
  * `fileExtensions`: Returns the list of file extensions with the `.` (for example, `.json`, `.xml`) to assign to this data format.
  * `acceptedMimeTypes`: The list of MIME types to accept.
  * `reader`: Function that reads raw content and transforms it into the canonical DataWeave model.
  * `writer`: Function that writes the canonical DataWeave model into binary content.

_Introduced in DataWeave version 2.2.0._  
EmptySettings |  `type EmptySettings = Object` |  Represents a configuration with no settings. _Introduced in DataWeave version 2.2.0._  
EncodingSettings |  `type EncodingSettings = { encoding?: String {defaultValue: "UTF-8"} }` |  Represents encoding settings and contains the following field:
  * `encoding`: Encoding that the writer uses for output. Defaults to "UTF-8".

_Introduced in DataWeave version 2.2.0._  
MimeType |  `type MimeType = String` |  Represents a MIME type, such as `application/json`. _Introduced in DataWeave version 2.2.0._  
Settings |  `type Settings = Object` |  Reader or writer configuration settings. _Introduced in DataWeave version 2.2.0._
entriesOf | MuleSoft Documentation
# entriesOf
## entriesOf<T <: Object>(obj: T): Array<{| key: Key, value: Any, attributes: Object |}>
Returns an array of key-value pairs that describe the key, value, and any attributes in the input object.
_Introduced in DataWeave version 2.3.0._
### Parameters
Name | Description  
---|---  
The object to describe.  
### Example
This example returns the key, value, and attributes from the object specified in the variable `myVar`. The object is the XML input to the `read` function.
#### Source
```
%dw 2.0
var myVar = read('<xml attr="x"><a>true</a><b>1</b></xml>', 'application/xml')
output application/json
---
{ "entriesOf" : entriesOf(myVar) }
```

#### Output
```
{
 "entriesOf": [
  {
    "key": "xml",
    "value": {
     "a": "true",
     "b": "1"
    },
    "attributes": {
     "attr": "x"
    }
  }
 ]
}
```

## entriesOf(obj: Null): Null
Helper function that enables `entriesOf` to work with a `null` value.
_Introduced in DataWeave version 2.4.0._
toNumberOrNull | MuleSoft Documentation
# toNumberOrNull
## toNumberOrNull(str: String, formatters: Array<Formatter>): Number | Null
Transforms a `String` value into a `Number` value using the first `Formatter` that matches with the given value to transform.
If none of the `Formatter` matches with the given value, the function returns a `null` value.
_Introduced in DataWeave version 2.5.0._
### Parameters
Name | Type | Description  
---|---|---  
The `String` value to transform into a `Number` value.  
`formatters` | Array<Formatter> | The `array` of formatting to use on the `Number` value.  
### Example
This example shows how `toNumberOrNull` behaves with different inputs. It produces output in the `application/dw` format.
#### Source
```
%dw 2.0
import * from dw::util::Coercions
output application/dw
---
{
 a: toNumberOrNull("0.005", [{format: "seconds"}, {format: ".00"}]),
 b: toNumberOrNull("0.005", [{format: "seconds"}])
}
```

#### Output
```
{
 a: 0.005 as Number {format: ".00"},
 b: null
}
```
Configure Server Properties | MuleSoft Documentation
# Configure Server Properties
Private Cloud Edition 
Runtime Manager enables you to view and configure properties in your Mule environments. Runtime Manager displays both custom and discovered properties.
## Custom Properties
Custom properties enable you to define properties used by the JVM container of a Mule instance. Custom properties are defined as key-value pairs.
## Discovered Properties
Discovered properties are properties defined by the remote environment of the Mule instance. These properties include:
  * JVM arguments
  * Environment properties
  * System properties


Runtime Manager retrieves the values of these properties from Runtime Manager agent which queries the `System` Java class on the remote server.
By default, auto-discovery of remote server properties is disabled. To use this feature, click **Enable Auto-Discovery**. After enabling this feature, Runtime Manager stores an encrypted version of these properties in its internal database.
You can fully disable this feature to prevent Runtime Manager from storing discovered properties. Contact your MuleSoft customer success representative.
## View Server Properties
To view custom and discovered properties:
  1. From Anypoint Platform, select **Runtime Manager**.
  2. Click the **Servers** tab.
  3. Click the **Type** column to display the details pane.
  4. Click **Manage Server** , **Manage Group** , or **Manage Cluster**.
  5. On the **Settings** page, click the **Properties** tab.
  6. Click either **Custom Properties** or **Discovered Properties**.
To view discovered properties, select **Discovered Properties** and then click **Enable Auto-Discovery** :
Figure 1. The screen shows the **Discovered Properties** and **Enable Auto-Discovery** buttons on the **Properties** tab.
The server state must be Running to auto-discover server properties.
From the **Properties** tab, you can:
     * Search for properties.
     * Create new properties.
     * Edit existing properties.


## See Also
  * Access Server Settings
  * Create Custom Server Properties
OAuth Module | MuleSoft Documentation
# OAuth Module
OAuth Module v1.1
OAuth Module is an extension to hook OAuth2 to HTTP extension connectors.
## Before You Begin
To use this module, 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)


## Using 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.
  * OAuth Module in Anypoint Exchange


## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * MuleSoft Help Center
Box Connector 5.1 | MuleSoft Documentation
# Box Connector 5.1
Box is an online file sharing and content management service for businesses. Anypoint Connector for Box (Box Connector) is a RAML-based connector that provides synchronization of data and automation of processes between Box and third party CRMs, CMS, mobile, and social applications. Because this is a RAML-based connector, it only uses REST calls to interact with the Box 2.0 API and supports only a subset of available API services.
## Before You Begin
Before creating an app, you must have access to the Box target resource and Anypoint Platform. You must also understand how to create a Mule app using Anypoint Studio.
You should be familiar with the use of the Box 2.0 API, Mule, Anypoint Connectors, Anypoint Studio, Mule concepts, elements in a Mule flow, and global elements.
To use this connector you need the following:
  * A developer account or other valid Box instance.
  * MuleSoft Enterprise License and necessary entitlements.


## Connection Types
Box Connector uses the following authentication types:
  * JWT Server-side authentication using a keypair. For more information about configuring Box Connector with JWT, refer to JWT Authentication.
  * Oauth2security Access tokens provided by the authorization server.


## Next Step
After you complete the prerequisites, you are ready to create an app with Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * Box Connector on Exchange
  * MuleSoft Help Center
Object Store Connector XML and Maven Support | MuleSoft Documentation
# Object Store 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/os
http://www.mulesoft.org/schema/mule/os/current/mule-os.xsd
```

This example shows how the namespace statements are placed in the `<mule>` XML block:
```
<mule xmlns:os="http://www.mulesoft.org/schema/mule/os"
	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/os
	http://www.mulesoft.org/schema/mule/os/current/mule-os.xsd">
```

## Add a POM File Dependency
The Apache Maven `pom.xml` file generated by Anypoint Studio contains dependencies for a Mule app. If you code a Mule app manually, include this XML snippet in your `pom.xml` file to enable access to this connector:
```
<dependency>
 <groupId>org.mule.connectors</groupId>
 <artifactId>mule-objectstore-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 `object store`.
  4. Select the connector.
  5. Click **Dependency Snippets** near the upper right of the screen.


## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Click App Element | MuleSoft Documentation
# Click App Element
The _Click App Element_ action step lets you perform a number of click and/or invoke actions for an App Element. _Invoke_ means the Microsoft API is addressed directly to execute the element function, which means no mouse action is needed.
## Properties
  * **Click App Element Settings**
    * **Initial Delay (ms)**
Defines how long to wait before initially executing the configured action.
    * **(Additional) Modifier**
An additional key or key combination that is active when the configured mouse action executes.
The following choices are available: `None`, `Ctrl`, `Alt`, `Ctrl + Alt`, `Shift`, `Ctrl + Shift`, `Alt + Shift`, `Ctrl + Alt + Shift`.
    * **Mouse Action:**
Only available in _Mouse Action_ operation mode. Defines which mouse action to execute.
The following choices are available:
      * **None**
Moves the mouse to the selected element and executes no action. This is equivalent to a _hover_.
      * **Left Click**
Executes a single left-click.
      * **Middle Click**
Executes a single click of the middle mouse button (usually the mouse wheel).
      * **Right Click**
Executes a single right-click.
      * **Double Left Click**
Executes a double left-click.
      * **Double Right Click**
Executes a double right-click.
      * **Wheel up**
Executes a _mouse wheel up_ action, corresponding to scrolling up one row.
      * **Wheel down**
Executes a _mouse wheel down_ action, corresponding to scrolling down one row.
  * **Operation mode**
You can select here between _Invoke Element_ and _Mouse Action_.
    * **Invoke element**
Communicates directly with the Microsoft API to execute the functions of the element; the mouse is not moved in this process.
    * **Mouse Action**
Simulates the configured mouse action and moves the mouse to the target element.
  * **Trigger count**
Defines how often the configured action executes.


## Inbound Variables
  * **Trigger Count**
  * **Initial Delay**
  * **XPath to Element**
  * **Window Title**


## Outbound Variables
The Click App Element action step does not have any outbound variables.
## Wizard
In the **Mouse action** , Operation Mode you determine the type of the action (such as Double Left Click), while **Trigger Count** defines the number of times this action is performed. The action step ensures that the clicks are grouped correctly. In other words, a configured double-click is executed directly, while a normal Left Click with two repetitions is executed with a time delay, to ensure that Windows does not register a double-click.
Parse Dates with DataWeave | MuleSoft Documentation
# Parse Dates with DataWeave
These DataWeave examples define a function (`fun`) in the DataWeave header to normalize date separators (`/`, `.`, and `-`) within different date formats so that all of them use the same separator (`-`).
The examples use these functions:
  * `replace` so that all dates match a single pattern.
  * `mapObject` to run through the `date` elements. The script applies the normalizing function to each `date`.
  * `as` (in the second DataWeave script) to change the data type of the values to a Date type with a specific date format.


## Example: Returns Dates as String Types
DataWeave Script:
```
%dw 2.0
output application/xml
fun normalize(date) = (date) replace "/" with "-" replace "." with "-"
---
dates: (payload.dates mapObject {
  normalized_as_string: normalize($)
})
```

Input XML Payload:
```
<dates>
 <date>26-JUL-16</date>
 <date>27/JUL/16</date>
 <date>28.JUL.16</date>
</dates>
```

Output XML:
```
<?xml version='1.0' encoding='US-ASCII'?>
<dates>
 <normalized_as_string>26-JUL-16</normalized_as_string>
 <normalized_as_string>27-JUL-16</normalized_as_string>
 <normalized_as_string>28-JUL-16</normalized_as_string>
</dates>
```

## Example: Returns Dates as Date Types
DataWeave Script:
```
%dw 2.0
output application/xml
fun normalize(date) = (date) replace "/" with "-" replace "." with "-"
---
// Outputs date values as Date types in the specified format
dates: (payload.dates mapObject {
  normalized_as_date: (normalize($) as Date {format: "d-MMM-yy"})
})
```

Input XML Payload:
```
<dates>
 <date>26-JUL-16</date>
 <date>27/JUL/16</date>
 <date>28.JUL.16</date>
</dates>
```

Output XML:
```
<?xml version='1.0' encoding='UTF-8'?>
<dates>
 <normalized_as_date>2016-07-26</normalized_as_date>
 <normalized_as_date>2016-07-27</normalized_as_date>
 <normalized_as_date>2016-07-28</normalized_as_date>
</dates>
```

## Related Examples
  * Add and Subtract Dates
  * Reference Multiple Inputs


## See Also
  *   * DataWeave Selectors
  *
SSO Prerequisites and Limitations | MuleSoft Documentation
# SSO Prerequisites and Limitations
When using SSO within Anypoint Platform, there are some prerequisites and limitations to be aware of.
## Before You Begin
Before using SSO, ensure that you have performed the following:
  * Configure your identity provider to send the username and email in your assertion.
  * Configure Anypoint Platform to map the username and email to the expected attribute name. If you don’t configure this setting, signin fails with a 403 unauthorized error message.
  * Configure the SAML assertion of the identity provider as signed and optionally encrypted using
    * either **AES128** or **AES256** block encryption algorithm,
    * **RSA-OAEP (including MGF1 with SHA1)** key transport algorithm, and
    * **Anypoint Platform Signing Certificate** which can be downloaded from the **SAML 2.0** SSO page.
After you configure the SAML assertion for the identity provider, the identity provider issues the SAML assertion as an XML file, which is sent through HTTP as a POST request.


## Client Considerations
Be aware of the following considerations related to client behavior:
  * User accounts created before configuring your federated organization remain within the organization. However, users can only sign in through the Anypoint Platform signin page. They can’t sign in from the redirected signin page of the identity provider.
  * Existing non-federated users can continue to work normally with the following exceptions:
    * If a user session times out, the user is redirected to the federated identity signin page instead of the generic one. Links and bookmarks that identify the organization redirect the user to the federated signin page, which fails for non-federated users.
    * If you configure your identity provider to handle user-information assertion, users must sign in to Anypoint Platform using the URL:
```
https://anypoint.mulesoft.com/accounts/login/{your_org_domain}
```



## Limitations
  * OpenID Connect does not support single signout.
  * If a SAML user belongs to certain groups, Anypoint Platform doesn’t automatically grant equivalent permissions in the organization.
  * Anypoint Platform doesn’t generate the SAML assertion for single sign on. Your IdP generates the sign-on URL that you configure.
  * External identity configuration is available only at the organization level. You can’t configure an external identity provider for a business group.
  * If you delete a user from your identity provider, you must also manually delete the user from your Anypoint Platform organization.
  * If you delete a SAML identity provider and recreate one with the same configuration, it’s considered a new identity provider. Users signing in to Anypoint Platform using this configuration are associated with the new identity provider. If existing user accounts are still associated with the deleted IdP, duplicate users appear because they are associated with a different IdP.
Anypoint VPN Configuration | MuleSoft Documentation
# Anypoint VPN Configuration
Use Anypoint VPN to create a secure connection between your MuleSoft Government Cloud deployment environment inside a Virtual Private Cloud (VPC) and your on-premises network. You can create multiple site-to-site VPNs if required.
## Government Cloud IPsec Settings
Anypoint VPN supports the following IPsec settings in the Government Cloud environment:
  * IKE version 1
  * IKE version 2 for route-based VPNs only
  * AES 128 or 256-bit encryption operating in the CBC and GCM
  * SHA-2 (256, 384, 512) hashing
  * Diffie-Hellman Phase 1 groups 14-21
  * Diffie-Hellman Phase 2 groups 14-21
  * Timeouts for IKEv1
    * IKE (Phase 1) Lifetime: 28800 seconds (8 hours)
    * IPsec (Phase 2) Lifetime: 3600 seconds (1 hour)
  * Timeouts for IKEv2
    * IKE (Phase 1) Lifetime: 28000 seconds (7 hours and 50 minutes)
    * IPsec (Phase 2) Lifetime: 3000 seconds (50 minutes)


## See Also
Create a Load Balancer with the CloudHub API | MuleSoft Documentation
# Create a Load Balancer with the CloudHub API
You can create a dedicated load balancer (DLB) using the CloudHub API.
## Prerequisites
To create a load balancer using the CloudHub API, ensure that you perform the following:
  * Ensure that you are an administrator in the organization where you are creating the load balancer.
  * Create an Anypoint Virtual Private Cloud (Anypoint VPC) in the organization where you want to create a load balancer.
  * Create at least one certificate and private key for your certificate.


## Create a Load Balancer
To create a load balancer using the CloudHub API, use the following endpoints:
  * `anypoint.mulesoft.com/cloudhub/api/organizations/_orgid_/loadbalancers`
  * `anypoint.mulesoft.com/cloudhub/api/organizations/_orgid_/vpcs`


You cannot change the name of a DLB after you create it. To change the name, delete and re-create it using the new name.   
---  
The CloudHub DLB name cannot start with `internal-`. Starting the DLB name with `internal-` results in error message: `LB name=internal-dlb-name cannot start with -internal`.
## Enable TLS 1.0 on a DLB Using the CloudHub API
Although TLS 1.0 is not recommended due to security vulnerabilities, you can enable support if required for communication with legacy clients.
You can enable TLS 1.0 support only on the default SSL endpoint of the DLB. Enabling TLS 1.0 support applies to the entire DLB, not a single SSL endpoint.
For security reasons, do not leave TLS 1.0 enabled. After you no longer need TLS 1.0, replace the default cipher suite, for example, with `NewDefault`.   
---  
To enable TLS 1.0 support on a DLB using the CloudHub API:
  1. Run the following command:
```
curl -X PATCH \
 https://anypoint.mulesoft.com/cloudhub/api/organizations/myOrgID/vpcs/myVpcID/loadbalancers/myDlbID \
 -H 'authorization: Bearer myAccessToken' \
 -H 'content-type: application/json' \
 -d '[
 {
  "op": "replace",
  "path": "/sslEndpoints/0/tlsv1",
  "value": "true"
 }
]'
```

In the command:
     * `_myOrgID_`is the organization ID.
     * `_myVpcID_`is the ID for the VPC.
     * `_myDlbID_`is the ID for the DLB.
     * `_myAccessToken_`is the access token you generated.
The response includes the following:
`"tlsv1": true,`
  2. Change the default cipher suite to `OldDefault`.
See Change the Default Cipher Suite to Support TLS 1.0.


## See Also
  * CloudHub API Create New Load Balancer
  *   * Add Certificates to a Dedicated Load Balancer
  * Certificate Validation in Dedicated Load Balancers
SAP SuccessFactors Connector 5.0 | MuleSoft Documentation
# SAP SuccessFactors Connector 5.0
Anypoint Connector for SAP SuccessFactors (SuccessFactors Connector) provides full support to query, create, update, and delete entities using the OData API exposed by SuccessFactors.
This connector enables you to:
  * Create, update, and delete entities
  * Retrieve a single entity by ID or query multiple entities


For compatibility information and fixed issues, see the SAP SuccessFactors Connector Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * SAP SuccessFactors OData API
  * Mule runtime engine (Mule)
  * Anypoint Connectors
  * Anypoint Studio essentials


Before creating an app, you must have:
  * Credentials to access a SuccessFactors developer account
  * A valid SAP SuccessFactors instance
  * A MuleSoft Enterprise license
  * Access to Anypoint Studio 7.17 or later


## Common Use Cases for the Connector
Some common use cases for SuccessFactors Connector include:
  * Creating and deleting entities in SuccessFactors
  * Retrieving an entity by ID
  * Performing queries over entities of a specified type


For examples, see Examples.
## Audience
  * New users, read:
    * Using Anypoint Studio to Configure the Connector to create your Mule app
    * Additional Configuration Information to help extend your understanding of the connector
    * Examples, which provide one or more use cases for the connector
  * Advanced users, read:
    * XML and Maven Support
    * Additional Configuration Information to help extend your understanding of the connector
    * Examples, which provides one or more use cases for the connector


For upgrade information, see Upgrading and Migrating SAP SuccessFactors Connector.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * SAP SuccessFactors Connector Reference
  * SuccessFactors HCM Suite Help
  * MuleSoft Help Center
Custom Policies | MuleSoft Documentation
# Custom Policies
**New Feature Available** : This product feature is outdated and is only provided for existing custom policies. To create new custom policies, use the Flex Gateway Policy Development Kit (PDK).
Policies enforce regulations to help manage security, control traffic, and improve API adoption. For example, a policy can control authentication, access, and service level agreements (SLAs). You can create custom policies based on your specific business requirements and apply them to APIs to extend existing functionality or define new ones.
The workflow for creating custom policies for Anypoint Flex Gateway is done in Exchange. The policy is then available to be applied to an API in Anypoint API Manager.
For more information, refer to the following:
  * Implement a Flex Gateway Custom Policy in Rust
  * Publish a Flex Gateway Custom Policy
  * Apply a Flex Gateway Custom Policy in Local Mode
field | MuleSoft Documentation
# field
## field(namespace: Namespace | Null = null, name: String): PathElement
This function creates a `PathElement` data type to use for selecting an _object field_ and populates the type’s `selector` field with the given string.
Some versions of the `update` and `mask` functions accept a `PathElement` as an argument.
_Introduced in DataWeave version 2.2.2._
### Parameters
Name | Description  
---|---  
`namespace` | The namespace of the field to select. If not specified, a null value is set.  
A string that names the attribute to select.  
### Example
This example creates an object field selector for a specified namespace (`ns0`) and sets the selector’s value to `"myFieldName"`. In the output, also note that the value of the `"kind"` key is `"Object"`.
#### Source
```
%dw 2.0
output application/json
import * from dw::util::Values
ns ns0 http://acme.com/foo
---
field(ns0 , "myFieldName")
```

#### Output
```
{
  "kind": "Object",
  "namespace": "http://acme.com/foo",
  "selector": "myFieldName"
 }
```
Troubleshooting Docker Command Issues | MuleSoft Documentation
# Troubleshooting Docker Command Issues
Troubleshoot errors returned by a `docker` command:
  * Docker Is Not Started
  * Reg Facade Error (400 Bad Request)


## Docker Is Not Started
If Docker is not started, a `docker` command returns an error message similar to the following ones:
  * ```
Error response from daemon: Bad response from Docker engine
```

  * ```
ERROR: Cannot connect to the Docker daemon at unix:///var/run/docker.sock.
    Is the docker daemon running?
```



If you get this error, start Docker.
## Reg Facade Error (400 Bad Request)
The following error can occur when you use `docker run` to register your gateway:
```
[flexctl][error] reg facade call returned error response:
HTTP/1.1 400 Bad Request
```

The reason for this error is available within the error message. Common causes include:
  * `an active target with the same name already exists in this organization and environment`
To avoid this issue, provide a _unique name_ for your gateway when running the registration command. Note that you _cannot reuse the same name_ even if a previous registration with that name was successful. When this error occurs, the command generates an _empty_ `registration.yaml`, which prevents re-registration _and_ produces an error when you try to use the file when deploying the gateway to your cluster.
  * `no valid registration token was found`
To avoid this issue, generate a new token for the command by refreshing the **Add a Flex Gateway** page for Kubernetes and rerun the registration command.


## See Also
  * Troubleshooting Request Connection
  * Troubleshooting with the CLI
  * Setting Up Self-Managed Flex Gateway
metadataOf | MuleSoft Documentation
# metadataOf
## metadataOf(t: Type): Object
Returns metadata that is attached to the given type.
_Introduced in DataWeave version 2.3.0._
### Parameters
Name | Description  
---|---  
The type to check.  
### Example
This example shows how `metadataOf` behaves with different inputs.
#### Source
```
%dw 2.0
import * from dw::core::Types
type AType = String {format: "YYYY-MM-dd"}
output application/json
---
{
  a: metadataOf(AType)
}
```

#### Output
```
{
 "a": {"format": "YYYY-MM-dd"}
}
```
Configure Credentials Hashing for Mule 4 | MuleSoft Documentation
# Configure Credentials Hashing for Mule 4
Enable hashing of your client credentials to add another layer of security for your APIs by hiding the client secrets from the Mule runtime engine (Mule) server. When you enable client hashing, Mule Gateway stores the client credentials in memory, with only the client secret hashed.
Additionally, if you enabled both encryption and hashing in Mule Gateway, the contract information in memory is hashed, but not encrypted. When client hashing (disabled by default) is enabled, it uses the SHA-256 hashing algorithm.
If you modify the configuration to enable or disable hashing in Mule Gateway and then restart your Mule server to apply the updated configuration, your incoming requests are not affected and they continue to be processed normally.
## How Client Credential Hashing Works
With client credential hashing enabled, when a request is received, Mule Gateway obtains the client secret from the client credentials of that request and hashes it. Mule Gateway then compares and verifies the client ID and the hashed client secret from the request with the credentials stored in memory before passing the request to Mule.
## Configure Client Credential Hashing
To enable client hashing, start the Mule server with the `anypoint.platform.hash_clients` property enabled. You can enable the property by either running the `start` command or by configuring the property in the `wrapper.conf` file in the `conf` directory:
  * `start` command:
`$MULE_HOME/bin/mule start -M-Danypoint.platform.hash_clients=true`
  * `wrapper.conf` property:
`wrapper.java.additional.<n>=-Danypoint.platform.hash_clients=true`


If you add the `wrapper.java.additional.n` entries to the configuration file, ensure that each instance of is a consecutive number. Otherwise, Java does not parse the properties correctly. For example:
  * Incorrect usage


`wrapper.java.additional.300=-Danypoint.platform.hash_clients=true`
`wrapper.java.additional.300=-Dsome.other.property`
  * Correct usage:


`wrapper.java.additional.300=-Danypoint.platform.hash_clients=true`
`wrapper.java.additional.301=-Dsome.other.property`
## Verify Client Credential Hashing
To verify that Mule Gateway started with client hashing enabled, add the following entry in the Log4j logger configuration:
`<AsyncLogger name="com.mulesoft.mule.runtime.gw.deployment" level="DEBUG" />`
The log4j file is present in `$MULE_HOME/conf/log4j2.xml`.
If hashing is enabled, the Mule environment displays the following message when deploying the first API:
`API Gateway initializing with Client Hashing algorithm: SHA-256`
API Community Manager Release Notes | MuleSoft Documentation
# API Community Manager Release Notes
Use Anypoint API Community Manager to build and operate communities around your APIs for developers and partners, both inside and outside of your organization, who write applications that use your APIs.
The following release notes are provided for API Community Manager:
  * Anypoint API Community Manager Release Notes


## See Also
  * API Community Manager
Hardening Mule Apps Deployed to Runtime Fabric | MuleSoft Documentation
# Hardening Mule Apps Deployed to Runtime Fabric
To enhance the security of Mule apps deployed to Anypoint Runtime Fabric and reduce vulnerabilities, review the following topics:
  * Protecting Mule App Property Values Using Rutime Manager Use Anypoint Runtime Manager to protect Mule app property values by displaying the property name but not its value.
  * Protecting Mule App Property Values Using RTFCTL Use the `rtfctl` command line tool to protect Mule app property values.


## See Also
  * Deploying Mule Apps to Runtime Fabric
  * Managing Mule Apps Deployed to Runtime Fabric
Types (dw::core::Types) | MuleSoft Documentation
# Types (dw::core::Types)
This module enables you to perform type introspection.
To use this module, you must import it to your DataWeave code, for example, by adding the line `import * from dw::core::Types` to the header of your DataWeave script.
_Introduced in DataWeave version 2.3.0._
## Functions
Name | Description  
---|---  
Returns the type of the given array. This function fails if the input is not an Array type.  
Returns an the base type of the given type.  
| Returns the list of parameters from the given function type. This function fails if the provided type is not a Function type.  
| Returns the type of a function’s return type. This function fails if the input type is not a Function type.  
| Returns an array of all the types that define a given Intersection type. This function fails if the input is not an Intersection type.  
Returns `true` if the input is the Any type.  
Returns `true` if the input type is the Array type.  
| Returns `true` if the input is the Binary type.  
| Returns `true` if the input is the Boolean type.  
| Returns `true` if the input is the DateTime type.  
Returns `true` if the input is the Date type.  
| Returns `true` if the input is the Function type.  
| Returns `true` if the input type is the Intersection type.  
Returns `true` if the input is the Key type.  
| Returns `true` if the input is the Literal type.  
| Returns `true` if the input is the LocalDateTime type.  
| Returns `true` if the input is the LocalTime type.  
| Returns `true` if the input is the Namespace type.  
| Returns `true` if the input is the Nothing type.  
Returns `true` if the input is the Null type.  
| Returns `true` if the input is the Number type.  
| Returns `true` if the input is the Object type.  
| Returns `true` if the input is the Period type.  
Returns `true` if the input is the Range type.  
| Returns `true` if the input type is a Reference type.  
Returns `true` if the input is the Regex type.  
| Returns `true` if the input is the String type.  
Returns `true` if the input is the Time type.  
| Returns `true` if the input is the TimeZone type.  
Returns `true` if the input is the Type type.  
Returns `true` if the input type is the Union type.  
Returns `true` if the input is the Uri type.  
| Returns the value of an input belongs to the Literal type.  
Returns metadata that is attached to the given type.  
Returns the name of the input type.  
| Returns the array of fields from the given Object type. This function fails if the type is not an Object type.  
Returns an array of all the types that define a given Union type. This function fails if the input is not a Union type.  
## Types
SFTP Connector 2.5 | MuleSoft Documentation
# SFTP Connector 2.5
Anypoint Connector for SFTP (SFTP Connector) provides access to files and folders on an SFTP server. SFTP connector operations manage file transfers over the SFTP (Secure File Transfer Protocol) protocol. The connector’s main features include:
  * The ability to read files or list directory contents on demand
  * Support for common SFTP operations such as creating directories, copying, moving, renaming, and deleting files
  * Support for locking files
  * File matching functionality
  * A design that is consistent with that of File Connector and FTP Connector
The same set of operations is available on these 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_.
The Mule message contains the concepts of encoding and MIME type. These describe the format in which a payload is represented. The file attributes describe 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.
## Next Step
After you complete the prerequisites, 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
X12 EDI Connector 2.11 | MuleSoft Documentation
# X12 EDI Connector 2.11
Support Category: Premium
Anypoint Connector for X12 EDI (X12 EDI Connector) enables you to convert X12 messages to and from DataWeave-compatible representations by using lists and maps. All of the schema definitions you need for supported X12 standard transaction sets are included. For complete information about schemas, see X12 EDI Schema Language Reference.
Many Health Insurance Portability and Accountability Act (HIPAA) document versions are also supported, as listed separately in the Supported HIPAA Versions. For more information about HIPAA usage, refer to Connector HIPAA Standards.
## Prerequisites
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:
  * Purchased a MuleSoft license for X12 EDI Connector.
Contact your Account Representative about purchasing a license.
  * Anypoint Studio 7.0 or later


X12 EDI Connector supports files of up to 15 MB in size, and the memory requirement is approximately 40 to 1. For example, a 1 MB file requires up to 40 MB of memory to process, so it’s important to consider this memory requirement in conjunction with your Transactions Per Second (TPS) needs for large X12 files. This is not an exact figure; the value varies according to the complexity of the mapping instructions.   
---  
## 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.
### X12 EDI Connector Templates in Exchange
X12 EDI Connector templates provide starting points that help you:
  * Map application messages to outbound X12 transactions 
  * Map inbound X12 transactions to the application message format
  * Set up your Partner Manager content storage


### X12 EDI Connector Examples in Exchange
X12 EDI Connector examples in Exchange enable you to:
  * Customize an X12 EDI schema for B2B integrations
  * Transform outbound purchase order XML messages to X12 850 transactions
  * Transform inbound X12 850 transactions to JSON purchase orders
  * Transform outbound XML messages into X12 purchase orders, inbound X12 purchase orders into JSON, and generate a functional acknowledgement
  * Implement an end-to-end order to cash workflow from the perspective of a seller
  * Implement an end-to-end B2B procure to pay workflow from the perspective of a buyer


## Next Step
After you complete the prerequisites, 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