BassemE/mulesoft-documentation-embeddings huggingface dataset:
Reporting Policy Violations | MuleSoft Documentation
# Reporting Policy Violations
For an example of reporting policy violations, see Stream Payload Policy.   
---  
PDK provides functions to report a policy violation. Reported policy violations appear in Anypoint Monitoring.
Only one policy violation can be active for a request at a time. When a new violation occurs, it overides any existing violation. If multiple policies generate violations for a single request, only one violation appears in Anypoint Monitoring.
Reporting a policy violation doesn’t reject the request. To reject requests, see Stopping Request Execution.
To view the current policy violation or generate a new policy violation, use these PDK functions:
```
/// Returns the existing policy violation of the current request. Returns None if no violation exists.
pub fn policy_violation(&self) -> Option<PolicyViolation>;
/// Generates a new policy violation for the current request. If a violation was previously generated, the previous violation is overridden.
pub fn generate_policy_violation(&self);
/// Generates a new policy violation with the client application details for the current request. This overwrites any previous policy violations.
pub fn generate_policy_violation_for_client_app<T: Into<String>, K: Into<String>>(
  &self,
  client_name: T,
  client_id: K,
);
```

To retrieve information about the current policy violation, use these PDK functions:
```
  /// The name of the policy that generated the violation
  pub fn get_policy_name(&self) -> &str;
  /// Client name associated with the violation, only available if a previous policy reported the client ID
  pub fn get_client_name(&self) -> Option<&str>;
  /// Client ID associated with the violation, only available if a previous policy reported the client ID
  pub fn get_client_id(&self) -> Option<&str>;
```

## See Also
  *
SAP S/4HANA SOAP Connector 2.1 - Get Started | MuleSoft Documentation
# SAP S/4HANA SOAP Connector 2.1 - Get Started
Anypoint Connector (SAP S/4HANA SOAP Connector) provides full support for the SOAP APIs exposed by SAP S/4HANA Cloud ERP, and starting with version 2.1, also provides support for SAP S/4HANA on-premise ERP. This connector enables you to automatically discover SOAP services enabled on your SAP S/4HANA instance and to invoke the SOAP service and associated operations.
For software requirements and compatibility information, see the SAP S/4HANA SOAP Connector Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The SAP S/4HANA SOAP API
  * Anypoint Connectors
  * Mule runtime (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have:
  * Credentials to access the SAP S/4HANA SOAP target resource
  * Anypoint Platform
  * Anypoint Studio 7.3 or later
  * Have a developer account or other valid SAP S4HANA instance


## Audience
  * New user — To create your Mule app, see Studio Configuration. The Examples topic provides one or more use cases for using the connector.
  * Advanced user - Read the XML and Maven Support, and Examples topics.


## Common Use Cases For the Connector
Send an XML request to SAP S/4HANA’s SOAP API and print a response.
## Using Exchange Templates and Examples
Anypoint Exchange provides templates you can use as a starting point for your app, as well as examples that illustrate a complete solution.
## Next Step
After you complete the prerequisites and experiment with templates and examples, you are ready to create an app with Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * SAP S/4HANA SOAP Connector Release Notes
  * SAP S/4HANA SOAP Connector on Exchange
  * MuleSoft Help Center
Dynamically Map Based on a Definition | MuleSoft Documentation
# Dynamically Map Based on a Definition
You can create a transformation that can dynamically change what it does depending on a definition input. This DataWeave example receives both a payload input, and a variable named `mappings` that specifies how to rename each field and what default value to use in each.
The example uses the following:
  * A `map` function to go through all of the elements in the input array. Also a second `map` function to go through each field in each element.
  * A custom function that applies the changes specified in the `mappings` variable.
  * `default` to set a default value, that comes from the `mappings` variable.


DataWeave Script:
```
%dw 2.0
output application/json
var applyMapping = (in, mappingsDef) -> (
  mappingsDef map (def) -> {
  (def.target) : in[def.source] default def."default"
 }
)
---
payload.sfdc_users.*sfdc_user map (user) -> (
    applyMapping(user, vars.mappings)
)
```

Input XML Payload:
```
<sfdc_users>
  <sfdc_user>
   <sfdc_name>Mariano</sfdc_name>
   <sfdc_last_name>Achaval</sfdc_last_name>
   <sfdc_employee>true</sfdc_employee>
  </sfdc_user>
  <sfdc_user>
   <sfdc_name>Julian</sfdc_name>
   <sfdc_last_name>Esevich</sfdc_last_name>
   <sfdc_employee>true</sfdc_employee>
  </sfdc_user>
  <sfdc_user>
   <sfdc_name>Leandro</sfdc_name>
   <sfdc_last_name>Shokida</sfdc_last_name>
  </sfdc_user>
</sfdc_users>
```

Input JSON Mule Event Variable (`vars.mappings`):
```
[
 {
  "source": "sfdc_name",
  "target": "name",
  "default": "---"
 },
 {
  "source": "sfdc_last_name",
  "target": "lastName",
  "default": "---"
 },
 {
  "source": "sfdc_employee",
  "target": "user",
  "default": true
 }
]
```

Output JSON:
```
[
 [
  {"name": "Mariano"},
  {"lastName": "Achaval"},
  {"user": "true"}
 ],
 [
  {"name": "Julian"},
  {"lastName": "Esevich"},
  {"user": "true"}
 ],
 [
  {"name": "Leandro"},
  {"lastName": "Shokida"},
  {"user": true}
 ]
]
```

## Related Examples
  *   * Exclude Fields from the Output
  * Output a Field When Present


## See Also
  * DataWeave Selectors
  *
Configuring Mule Properties to Access Hyperforce | MuleSoft Documentation
# Configuring Mule Properties to Access Hyperforce
To deploy Mule apps to a Salesforce Hyperforce (Hyperforce) instance, you must configure Mule runtime engine (Mule) to access a Hyperforce instance. To do this, you must:
  * Redefine the configuration properties that enable Mule to point to a Hyperforce instance.
  * Provide the client ID and client secret of the environment belonging to your organization.


By default, Mule is configured to point to the US control plane. If you do not override these properties, the API gateway capability of Mule is disabled in the Hyperforce instance.
You can configure Mule properties using a `wrapper.conf file`, the command line, or CloudHub 2.0. To configure Mule properties through Maven, refer to Publish assets using Maven.
## Configure Mule Properties in the Wrapper.conf File
To configure Mule in the `wrapper.conf` file, modify the following properties, replacing with an integer value that is unique within `wrapper.conf`. Ensure that you use the supported region endpoint domains:
  * `ca1.platform.mulesoft.com`
  * `jp1.platform.mulesoft.com`


The following example shows the `wrapper.conf` file configuration for Canada Cloud (`ca1.platform.mulesoft.com`):
```
wrapper.java.additional.<n>=-Danypoint.platform.client_id=<environment client ID>
wrapper.java.additional.<n>=-Danypoint.platform.client_secret=<environment client secret>
wrapper.java.additional.<n>=-Danypoint.platform.base_uri=https://ca1.platform.mulesoft.com
wrapper.java.additional.<n>=-Danypoint.platform.analytics_base_uri=https://analytics-ingest.ca1.platform.mulesoft.com
```

## Configure Mule Properties via the Command Line
To configure Mule properties via the command line, use the following options when starting Mule. Note that `./` applies only to Unix environments. Ensure that you use the supported region endpoint domains:
  * `ca1.platform.mulesoft.com`
  * `jp1.platform.mulesoft.com`


The following example shows the properties configuration for Canada Cloud `ca1.platform.mulesoft.com` via the command like:
```
./mule -M-Danypoint.platform.client_id=<environment client ID> -M-
Danypoint.platform.client_secret=<environment client secret> -M-Danypoint.platform.base_uri=ca1.platform.mulesoft.com
-M-Danypoint.platform.analytics_base_uri=https://analytics-ingest.ca1.platform.mulesoft.com
```

## Configure Mule Properties for CloudHub 2.0
When deploying to CloudHub 2.0, in the **Properties** tab of Anypoint Runtime Manager, include the following properties. Ensure that you also use the supported region endpoint domains:
  * `ca1.platform.mulesoft.com`
  * `jp1.platform.mulesoft.com`


The following example shows the properties configuration for Canada Cloud `ca1.platform.mulesoft.com` :
```
anypoint.platform.client_id=<environment client ID>
anypoint.platform.client_secret=<environment client secret>
anypoint.platform.base_uri=https://ca1.platform.mulesoft.com
anypoint.platform.analytics_base_uri=https://analytics-ingest.ca1.platform.mulesoft.com
```

## See Also
  * Deploying Mule Apps to Hyperforce
About the JMS Connector | MuleSoft Documentation
# About the JMS Connector
Anypoint Connector for JMS (Java Message Service) (JMS Connector) is a widely-used API for message oriented middleware. It allows communication between different components of a distributed application to be loosely coupled, reliable, and asynchronous.
JMS supports two models for messaging:
  * Point-to-point queues
  * Publish and subscribe topics


JMS Connector enables sending and receiving messages to queues and topics for any message service that implements the JMS specification.
For reference information about specific versions of JMS Connector, see:
  * JMS Connector v1.7.x Reference
  * JMS Connector v1.6.x Reference
  * JMS Connector v1.5.x Reference
  * JMS Connector v1.4.x Reference
  * JMS Connector v1.3.x Reference
  * JMS Connector v1.2.x Reference
  * JMS Connector v1.1.x Reference
  * JMS Connector v1.0.x Reference
  * JMS Connector Release Notes


## Point-to-Point Queues
In the point-to-point or queuing model, a sender posts messages to a particular queue and a receiver reads messages from the queue. Here, the sender knows the destination of the message and posts the message directly to the receiver’s queue.
The point-to-point queuing model is characterized by the following:
  * Only one consumer receives the message.
  * The sender does not need to be running at the time the consumer consumes the message, nor does the consumer need to be running at the time the message is sent.
  * Every message that is successfully processed is acknowledged by the consumer.


## Publish and Subscribe Topics
The publish-subscribe model supports publishing messages to a particular message topic. Subscribers can register to receive messages on a particular message topic. In this model, neither the publisher nor the subscriber are aware of each other. An anonymous bulletin board is a good analogy for this concept.
The publish-subscribe model is characterized by the following:
  * Multiple consumers (or none) receive the message.
  * The publisher must create a message topic to which clients can subscribe.
  * The subscriber must remain continuously active to receive messages, unless it has established a durable subscription, in which case, messages published while the subscriber is not connected are redistributed when the subscriber reconnects.


## See Also
  * Introduction to Anypoint Connectors
  * JMS XML Reference
  * MuleSoft Help Center
Google Sheets Connector 1.0 | MuleSoft Documentation
# Google Sheets Connector 1.0
Anypoint Connector for Google Sheets (Google Sheets Connector) synchronizes data and automates business processes between Google Sheets and third-party applications, either on-premises or in the cloud.
Google Sheets is a real-time spreadsheet tool with powerful functions to help teams efficiently perform multiple functions such as helping sales teams collaborate on leads and opportunities, and helping HR teams collaborate on candidates for interviewing and hiring.
For compatibility information and fixed issues, see the Google Sheets Connector release notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The Google Sheets API and the Google Drive API (if planning to use the List Drive Files operation)
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have access to:
  * The Google Sheets API target resource
  * Anypoint Studio version 4.2.1 or later


## Common Use Case for the Connector
Common use cases for the connector include the following:
  * Improve sales operations
Automate a workflow in which a Google Sheets spreadsheet is auto-populated every time a new lead is created in Salesforce. This sales team can then use the spreadsheet to collaborate on further research.
  * Enhance customer service
Catalog all incoming issues in a spreadsheet and set up automatic rules to alert the team when an issue starts approaching SLA deadlines.
  * Optimize HR processes
When a new candidate reaches out via an applicant tracking system such as Workday or Greenhouse, capture the candidate details in a spreadsheet so that other stakeholders can review and contact the appropriate candidates.


## 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
Transform Message Component | MuleSoft Documentation
# Transform Message Component
The Transform (or Transform Message) component converts input data to a new output structure or format. You can use the component’s visual mapper to build your transformation implicitly by dragging and dropping elements of the incoming data structure, or you can explicitly write a transformation script in DataWeave expression language.
  * Graphical View (Drag-and-Drop editor): Two tree views show the expected metadata structures of the input and output. Mappings between these two trees are represented by lines that connect input to output fields. The lines can be created by dragging and dropping an element from the input to another element to the output.
Figure 1. Drag-and-Drop Editor in the Transform Component
  * Script View: The visual mapping can be represented as DataWeave code. Advanced transformations such as aggregation, normalization, grouping, joining, partitioning, pivoting and filtering can be coded here.
Figure 2. DataWeave Script in the Transform Component


Note that changes in one view are reflected in real time with the other.
## Preview
A preview of your output is built on sample data (such as a JSON snippet) and is updated in real time as you make changes to your transformation.
Figure 3. Transform Component in Anypoint Studio
## Metadata
The Transform component accepts input and output metadata for the message payload, a variable or an attribute. You can provide format-specific resources and settings for supported mime types (formats):
  * CSV example or RAML definition
  * Copybook file or schema
  * Excel column name and type definitions (including String, Number, Boolean, Date, and DateTime) for one more sheets
  * Fixed Width column name, type (String, Integer, Decimal, Boolean, Date, and DateTime), width, and format settings
  * Flat File schema
  * JSON example or schema
  * Object class or RAML definition
  * Simple Type (String, Number, Integer, Boolean, Date, or DateTime)
  * XML example or schema


## See Also
Workflow: Create a Mapping
Tips: Transform Message UI
DataWeave Language
Exporting App Data to a CSV File | MuleSoft Documentation
# Exporting App Data to a CSV File
In built-in and custom dashboards, you can export app data to a CSV file, which you can then use in other applications. The data export works on an individual chart level, so only data in the specified chart is exported. When you apply a filter to a dashboard, the exported data includes only the data included in the filter you set. For example, if you apply a time period filter, only the data for that time period is exported.
  1. Log in to Anypoint Platform with a user account that has permission to access Anypoint Monitoring content.
  2. Navigate to **Anypoint Monitoring**.
  3. From the Anypoint Monitoring sidebar, click **Built-in dashboards** or **Custom dashboards**.
  4. Select the application for which to download the data.
  5. Specify the time range for the data to download.
  6. In the chart that contains the data to download, click the (**More menu**), and select **Export CSV**.
  7. In the **Export CSV** dialog, specify the way to format the data.
     * In **Mode** , select the format for the data:
       * **Series as rows** formats the data in rows in the CSV file.
       * **Series as columns** formats the data as columns in the CSV file.
     * In **Date Time Format** , enter the values to specify the date format, for example: `YYYY-MM-DDTHH:mm:ssZ`
  8. Click **Export**.
The CSV file downloads automatically in the browser.
A2A Connector 0.1.0-BETA XML and Maven Support | MuleSoft Documentation
# A2A Connector 0.1.0-BETA XML and Maven Support
Although you can manually code a Mule app in XML, it is more efficient to use Anypoint Code Builder or Studio:
  * If you manually code a Mule runtime engine (Mule) app in XML, either from the Anypoint Code Builder or Studio XML editor, or from a text editor, you can access the connector from your app by adding reference statements to both your XML Mule flow and the Apache Maven `pom.xml` file.
  * If you add the connector in Anypoint Code Builder or Studio, the XML is automatically populated the code with the connector’s namespace and schema location and it also adds a dependency to the `pom.xml` file.


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

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


## Next Step
After completing your namespace and pom.xml file, you can try the Examples.
## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Scaling API Calls in Anypoint DataGraph | MuleSoft Documentation
# Scaling API Calls in Anypoint DataGraph
Anypoint DataGraph provides you the option to configure the number of API calls permitted for a unified schema. Increasing or decreasing API calls enables you to process higher workloads and optimize your consumption when needed.
## How API Call Scaling Works in DataGraph
By default, DataGraph supports a maximum of 1 million annual API calls and 150 concurrent or ongoing calls per unified schema per environment. You can update the maximum number of annual and concurrent calls after you add the first API to the unified schema.
However, your plan must allocate the correct number of vCores for your business group or organization before scaling. You can’t scale API calls in an environment beyond the free capacity remaining in the number of vCores allocated for that environment. Production and Sandbox environments each have their own scaling options per unified schema.
The **API Call Scaling** page displays available scaling options:
Each option includes **Annual API Calls** , which are the total number of API requests you can make to the unified schema on a yearly basis. When you select an annual option, you also select:
  * **Concurrent Calls** : The number of active API requests the unified schema can process in parallel
  * **# of Workers** : The number of dedicated Mule instances that can actively process requests to the unified schema


The **Insufficient Capacity** label indicates that your business group hasn’t allocated enough capacity to select that option. Your business group administrator can increase capacity either by reducing usage in other environments or by purchasing additional capacity for your business group.
## Available Scaling Options
The following table provides details about the available scaling options:
Annual API Calls | Concurrent Calls | # of Workers  
---|---|---  
## Configure API Call Scaling
Use API call scaling to increase or decrease the number of API calls that can be made to the unified schema for the current environment.
You can’t make any adjustments until you add at least one API to the unified schema.
You must have the DataGraph admin or operator permission.
  1. From Anypoint Platform > Anypoint DataGraph, click **Settings**.
  2. In the **API Call Scaling** tab, choose an available option.
  3. Click **Save Changes**.


## Related Resources
  * Add an API to the Unified Schema
  * View Usage Metrics for DataGraph
  * DataGraph API Support
isObjectType | MuleSoft Documentation
# isObjectType
## isObjectType(path: Path): Boolean
Returns `true` if the provided `Path` value is an `OBJECT_TYPE` expression.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
The `Path` value to validate.  
### Example
This example shows how `isObjectType` behaves with different inputs.
#### Source
```
%dw 2.0
import * from dw::util::Tree
output application/json
---
{
 a: isObjectType([{kind: OBJECT_TYPE, selector: "user", namespace: null},
          {kind: ATTRIBUTE_TYPE, selector: "name", namespace: null}]),
 b: isObjectType([{kind: OBJECT_TYPE, selector: "user", namespace: null},
          {kind: OBJECT_TYPE, selector: "name", namespace: null}]),
 c: isObjectType([{kind: OBJECT_TYPE, selector: "user", namespace: null}])
}
```

#### Output
```
{
 "a": false,
 "b": true,
 "c": true
}
```
Introduction to Mule 4 for Mule 3 Users | MuleSoft Documentation
# Introduction to Mule 4 for Mule 3 Users
If you are a user that already knows Mule 3 and recently migrated to Mule 4, review the following introduction to learn the main changes in Mule 4.
If you are an experienced Mule 4 user, go directly to our Mule Runtime documentation instead.
Mule 4 simplifies the expression language and reduces management complexity so that you can speed up the on-ramping process and deliver applications faster than in Mule 3.
Conceptually, you can think of Mule 4 as an evolution of Mule 3. Many of the core concepts are the same: applications, flows, connectors, DataWeave, and so on. However, because it is simpler, there is less to learn and less for you to manage.
This overview takes you through the high-level changes in Mule 4 so that you can quickly learn the basics. It covers these topics:
  * Mule Message The Mule Message structure has evolved to make it easier to work with properties and to provide more consistency across connectors.
  * Expression language The Mule Expression Language has been replaced with the DataWeave language so that you work with data and learn Mule more easily.
  * Connectors The approach to connectivity was unified in Mule 4. Mule 3 transports were replaced with new operation-oriented connectors that are easier to use, have better out-of-the-box defaults, and provide new advanced capabilities.
  * Error Handling Easier and more powerful error handling with a new Try scope.
  * DataWeave DataWeave includes minor changes to simplify the syntax and make it easier to learn.
  * Studio 7 Features a simplified palette, improved Maven integration, and many other usability improvements.
  * Runtime engine The internal execution engine has been updated with a new self-tuning and non-blocking reactive engine. This allows for better performance and scalability out-of-the-box.
Anypoint Security Release Notes | MuleSoft Documentation
# Anypoint Security Release Notes
Anypoint Security provides a layered approach to secure your application network. These layers work together to protect both the application network and its individual nodes by controlling access to APIs, enforcing policies, and proxying all inbound or outbound traffic to mitigate external threats.
These capabilities are optimized for security, providing you with a dedicated endpoint to detect attacks and validate traffic without taxing your implementations.
The following release notes are provided for Anypoint Security:
  * Tokenization Service Release Notes
  * Anypoint Security Edge Release Notes
  * Anypoint Security Edge Policies Release Notes
  *
Create Server Groups | MuleSoft Documentation
# Create Server Groups
Private Cloud Edition 
To deploy applications to a server group, you can either add the servers to Runtime Manager first and then create the server group, or you can create the group and add servers to it later.
To create a server group:
  1. From Anypoint Platform, select **Runtime Manager**.
  2. Select **Servers** in the left menu.
  3. Click the **Create Group** button.
  4. In the **Create Server Group** page, enter the name for the server group.
Group names can contain between 3-40 alphanumeric characters (a-z, A-Z, 0-9) and hyphens (-). They cannot start or end with a hyphen and cannot contain spaces or other characters.
  5. Select the servers to include in your new server group.
  6. Click the **Create Group** button.


The new server group appears in the **Servers** list. The servers no longer appear in the **Servers** list. To see the list of servers in the group, click the server group name.
## See Also
  * Add Servers to Runtime Manager
  * Add Servers to a Server Group
Microsoft Teams Connector 1.1 XML and Maven Support | MuleSoft Documentation
# Microsoft Teams Connector 1.1 XML and Maven Support
Although you can manually code a Mule app in XML, it is more efficient to use Anypoint Studio:
  * If you manually code a Mule runtime engine (Mule) app in XML either from the Anypoint Studio XML editor or from a text editor, you can access the connector from your app by adding reference statements to both your XML Mule flow and the Apache Maven `pom.xml` file.
  * If you add the connector in Studio, Studio automatically populates the XML code with the connector’s namespace and schema location and it also adds a dependency to the `pom.xml` file.


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

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

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

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


## See Also
  * Introduction to Anypoint Connectors
  * MuleSoft Help Center
Sandboxes | MuleSoft Documentation
# Sandboxes
Upgrades are applied automatically to Anypoint API Community Manager versions 2.0 and later.
Upgrades with new features are applied to sandbox environments four weeks before they are applied to production environments. Upgrades with only bug fixes are applied to sandbox environments two weeks before they are applied to production environments.
## Sandboxes for Upgrading from Version 1.x
After you install an Anypoint API Community Manager upgrade, it is not possible to undo the installation and revert to a previous version. Therefore, be sure to create safe sandbox environments in which you test each upgrade before installing it in your production environment.
### New Sandboxes
To create a new sandbox:
  1. In **Setup** , search for **Sandboxes** using the **Quick Find** box and click **New Sandbox**.
  2. Enter a name and description and create a new developer sandbox.
After several minutes to a few hours, sandbox creation completes and sends you a notification email.
  3. In **Setup** , search for **Sandboxes** using the **Quick Find** box and log in to your new sandbox with your administrator password.
Note that the user name has the sandbox name as a suffix.


To validate your new sandbox:
  1. Open the application launcher.
  2. Open the **API Community Manager** application.
  3. Publish a few APIs.
  4. Open the builder.
  5. Publish your community.
  6. Open your community’s live site.
  7. Validate the site is operational.


After validating your new sandbox, begin the upgrade.
### Upgrade Workflow
To test and install each upgrade:
  1. Keep a long-term staging environment sandbox with either a partial copy or a full copy of the data in the production environment.
  2. Create a short-term developer sandbox.
  3. Install the upgrade in the developer sandbox and test it.
  4. Discard the developer sandbox.
  5. Install the upgrade in the staging sandbox and test it.
  6. Install the upgrade in your production environment.


## See Also
  * Upgrade API Community Manager
  * Creating Community Sandboxes
Salesforce Data Cloud Connector 1.3 | MuleSoft Documentation
# Salesforce Data Cloud Connector 1.3
Anypoint Connector for Salesforce Data Cloud (Salesforce Data Cloud Connector) provides a quick and easy way to integrate with Salesforce Data Cloud API endpoints. You can automate data ingestion from third parties, query the Data Cloud Data Lake, search and query customer profile information and calculated insights, and consume data action events to enrich the 360-degree view of the customers in your Data Cloud instance.
Each API call uses a request/response pattern over an HTTPS connection. All required request headers, error handling, and HTTPS connection configurations are built into the connector.
For information about compatibility and fixed issues, refer to the Salesforce Data Cloud Connector release notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The Salesforce Data Cloud Ingestion API
  *   * 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:
  * Set up the Ingestion API
  * Credentials to access the Salesforce Data Cloud target resource
  * Anypoint Platform
  * Anypoint Studio version 7.11.x or later


## Set Up the Ingestion API
To use Salesforce Data Cloud Connector, you must first set up the Ingestion API. For more information, refer to Connect MuleSoft with Data Cloud.
After setting up the Ingestion API, refer to Next Step to configure your connector.
## Common Use Cases For the Connector
These are some common use cases for Salesforce Data Cloud Connector:
  * Stream data via insert and delete object endpoints of the Ingestion API Connector
  * Create a bulk job, upload job data, close or abort a job, get a job status, retrieve all bulk jobs, and delete a job as part of the Bulk Ingestion interaction pattern of the Ingestion API Connector
  * Query Data Cloud objects
  * Query Salesforce Data Cloud data lake across data model, lake, unified, and linked objects
  * Query calculated insights with selected dimensions, selected measures, and optional filters
  * Look up and search customer profile information
  * Create webhooks as data action targets for data actions in Data Cloud


For examples, see Salesforce Data Cloud Connector Examples use cases.
## Connection Types
Salesforce Data Cloud connections use the following authentication types:
  * OAuth Client Credentials
Uses OAuth 2.0 with a token endpoint for authentication
  * OAuth JWT
Uses OAuth 2.0 with a JSON Web token (JWT) request for authentication
  * OAuth Username Password
Uses OAuth 2.0 with a username and password for authentication


For information about configuring authentication types, see Using Anypoint Studio to Configure Salesforce Data Cloud Connector.
## Next Step
After you complete the prerequisites, you are ready to create an app and configure the connector using Anypoint Studio.
## See Also
  *   * Use Exchange to Discover Connectors, Templates, and Examples
  * Salesforce Daa Cloud Connector Reference
  * MuleSoft Help Center
Configuring an External Identity Provider in Anypoint Platform PCE | MuleSoft Documentation
# Configuring an External Identity Provider in Anypoint Platform PCE
Anypoint Platform Private Cloud Edition (Anypoint Platform PCE) requires an external identity provider. All users must be registered via external identity except the admin you register in the installation wizard. The following external identity providers are supported:
  * Configuring LDAP in Anypoint Platform PCE
  * Configuring Ping Federate
  *   * Configuring OpenID Connect


For troubleshooting information, see Anypoint Platform Single Sign-On (SSO) using OpenID Connect (OIDC) Troubleshooting Guide.
## See Also
  * Configuring Anypoint Platform PCE
Opening the Output Panel | MuleSoft Documentation
# Opening the Output Panel
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.
Configuring the output panel to display logs for the Anypoint Code Builder extensions enables you to view the status of activity in the IDE.
## Before You Begin
  * You must have an Anypoint Platform account with the required permissions.
  * Your Anypoint organization administrator must accept Anypoint Code Builder beta terms and conditions.


For guidance, see Getting Started with Anypoint Code Builder.
## Configure the Default Output Panel
You must configure your output panel to display information from the Anypoint Code Builder extensions:
  1. Open the output panel:
     * Use the keyboard shortcuts:
       * Mac: Cmd+Shift+u
       * Windows: Ctrl+Shift+u
     * In the desktop IDE, select **View** > **Output**.
     * In the cloud IDE, click the (menu) icon, and select **View** > **Output** :
  2. In the output panel, select **Mule DX Server** from the dropdown list:


Anypoint Code Builder now displays information related to logs produced by the extensions. To see scaffolding errors only, select **Mule DX Server: Scaffolding** from the list.
Edit in Multiple Tabs in the Text Editor | MuleSoft Documentation
# Edit in Multiple Tabs in the Text Editor
You can have multiple files open simultaneously in API Designer’s text editor. Each file can be open in its own tab.
## Opening Files in New Tabs
There are four ways that you can open a file in a new tab:
  * Open the context menu for a file in the file tree by clicking the three dots to its right, and then select **Open in new tab**.
  * Press the Command key (MacOS) or the Control key (Windows) and click the name of the file in the file tree. +[NOTE]


Clicking a filename in the file tree without first pressing either of these keys replaces the file that is open in the current tab.
  * Place your cursor in the name of a file in a file reference such as an `include` tag in RAML or a `$ref` keyword in OAS.
Then, press the Command key (MacOS) or the Control key (Windows) and click the filename.
  * Click a filename in the **Location** column in the errors view at the bottom of the screen.


## Navigating to Different Tabs
The tab bar appears at the top of the editor only when at least two files are open.
To switch to the tab to the left of the one currently open, follow either of these steps: * Press Option + Shift + Tab (MacOS) or Alt + Shift + Tab (Windows). * Open the menu on the tab bar by clicking the ellipsis and select **Previous Tab**.
To switch to the tab to the right of the one currently open, follow either of these steps: * Press Option + Tab (MacOS) or Alt + Tab (Windows). * Open the menu on the tab bar by clicking the ellipsis and select **Next Tab**.
## Closing Tabs
To close a single tab, click the X icon that appears on it.
To close all tabs but the currently open one, click the ellipsis on the right side of the tab bar and select **Close All Other Tabs**.
Write Clipboard | MuleSoft Documentation
# Write Clipboard
Use _Write Clipboard_ to copy a piece of text to the clipboard. This will replace the content s of the clipboard with the text. This is similar to the copy function, `<Ctrl>`+, used in a text editor to copy a selected piece of text, but in this case a value from the _Workflow_ is used for the clipboard instead of selected text. You can either enter the text used by _Write Clipboard_ yourself, or use the value of a variable.
## Properties
_Write Clipboard_ has no special properties.
Other Properties that are the same in all action steps are described in the section on **Common Properties**.
## Inbound Variables
**Clipboard Text** Enter the text that should be copied to the clipboard when this action step is executed. You can also transfer the content of a _Workflow_ variable to the clipboard. To do so, click on the pin and select one of the available variables.
## Outbound Variables
**Write Clipboard** The _Write Clipboard.ClipboardText_ variable provides the text to be written to the clipboard.
## Example
_Write Clipboard_ can be useful in transactions and robotic applications when it is necessary to enter text quickly. This might be necessary, for example, when an article description or a password has to be entered automatically into a field. Another use for this function might be to transfer data (text) from application 'A' to GUI 'B'.
Secrets Manager Permissions | MuleSoft Documentation
# Secrets Manager Permissions
An administrator for your organization can grant these permissions to any user from Access Management.
## User Permissions
A user needs to have a set of predefined permissions to operate with Secrets Manager:
Name | Description  
---|---  
Write secrets |  Provides the ability to upload, create, and modify secrets in a specific environment.  
Read secrets metadata |  Provides the ability to browse and read metadata of secrets in a specific environment.  
Grant access to secrets |  Provides the ability to browse, read metadata, and grant access to secrets in a specific environment.  
Manage secret groups |  Provides the ability to create, modify and delete secret groups in a specific environment.  
## See Also
  *   *
APIkit for OData V2 | MuleSoft Documentation
# APIkit for OData V2
APIkit for OData v2 is a framework that simplifies the development of RESTful APIs that adhere to the OData v2 specification. OData, also called the Open Data Protocol, enables the creation and consumption of RESTful APIs. It allows data querying and manipulation through standard HTTP requests.
APIkit for OData v2 is an extension of APIkit for REST. It builds upon the foundation of APIkit for REST and uses RAML APIs. This integration between APIkit for OData v2 and APIkit for REST combines their functionalities and benefits.
However, APIkit for OData v2 provides fewer capabilities than newer versions of OData and other frameworks. Consider these limitations when deciding whether APIkit for OData v2 is the appropriate choice for your specific use case.
While OData v2 is still widely used, OData v4 is the latest major version. It introduces several enhancements, including improved query capabilities and better alignment with other web standards.
## See Also
  * APIkit for OData V4
  * Installing OData V2 Tooling
MuleSoft AI Chain - Additional Configuration Information | MuleSoft Documentation
# MuleSoft AI Chain - Additional Configuration Information
MuleSoft AI Chain Connector supports 15 operations, categorized into:
  *
MuleSoft Accelerator for Salesforce OMS | MuleSoft Documentation
# MuleSoft Accelerator for Salesforce OMS
The MuleSoft Accelerator for Salesforce OMS enables you to integrate your Order Management System (OMS) with external business partners and application ecosystems by leveraging the application and Business-to-Business (B2B) integration capabilities of Anypoint Platform. The solution accelerates the implementation of Electronic Data Interchange (EDI) messaging and other integrations into Salesforce OMS.
## Use Cases
### B2B EDI Order Lifecycle Automation
The B2B EDI Order Lifecycle Automation use case lets you add EDI as a direct order intake channel to manage and service EDI orders across the full order management lifecycle.
### Salesforce OMS to ERP Integration
Manage orders received via omnichannel sources within Salesforce Order Management System (OMS) with the Salesforce OMS to ERP Integration use case.
## See Also
  *   *   *   * MuleSoft Accelerator for Salesforce OMS on Exchange
Apache Cassandra Connector | MuleSoft Documentation
# Apache Cassandra Connector
Cassandra Connector v3.1
Anypoint Connector for Apache Cassandra (Cassandra Connector) creates connectivity between Cassandra databases and third-party applications, systems, services such as SAP, PeopleSoft, or Workday, as well as other databases across the enterprise. Apache Cassandra is an open source distributed NoSQL database intended to manage large amounts of product, customer, and employee data, which implements the DataStax Java Driver for Apache Cassandra 3.1.
Release Notes: Cassandra Connector Release Notes Exchange: Cassandra Connector
## Before You Begin
Before starting, ensure you have access to the connector, Anypoint Platform, or Anypoint Studio. You should have the Mule Enterprise Edition and entitlements necessary to use this software. You should be familiar with the use of Anypoint Platform, Anypoint Studio, and Mule applications.
Requirements for using the connector:
Cassandra Login credentials to test your connection to your target resource.
## Audience
  * Starting user - Use this Get Started to see where you can create a Mule application in Anypoint Studio.
  * The Configuration Topics help you extend your understanding of Cassandra actions.
  * Power user - Read the XML and Maven Support, Configuration Topics, and Example documents.


## Next
Now that you’ve started, try using Anypoint Studio to configure the Cassandra connector.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * MuleSoft Help Center
AS2 Connector 6.2 | MuleSoft Documentation
# AS2 Connector 6.2
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