**TITLE**: sap.fe.test.api.TableActions

**INTRODUCTION**: Constructs a new TableActions instance. Extends sap.fe.test.api.TableAPI.

**TAGS**: sap.fe.test, OPA5, testing, tableactions, actions, sap.fe.test.api

**STEP**: iPressCell([mRowValues], vColumn)

**DESCRIPTION**: Presses the control in the table cell.

Parameters:
- `mRowValues` `{object}` *(optional)* — Specifies the target row by column-value map, e.g.

{
    0: "Max",
    "Last Name": "Mustermann"
}

- `vColumn` `{string|number}` — The column name, label or index

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iClickLink([mRowValues], vColumn)

**DESCRIPTION**: Clicks a link in a table cell.

Parameters:
- `mRowValues` `{object|number}` *(optional)* — Specifies the target row by column-value map or 0-based index
- `vColumn` `{string|number}` — The column name, label, or index

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iClickContactLink(linkContent)

**DESCRIPTION**: Clicks a Contact Card link within the table using its link text.

Parameters:
- `linkContent` `{string}` — The text of the contact link to click

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSelectRows([vRowValues], [mState])

**DESCRIPTION**: Selects the specified rows.

Parameters:
- `vRowValues` `{object|number}` *(optional)* — Defines the row values of the target row. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

Alternatively, the 0-based row index can be used.
- `mState` `{object}` *(optional)* — Defines the expected state of the row

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSelectAllRows()

**DESCRIPTION**: Selects all rows in a table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iPressRow([vRowValues])

**DESCRIPTION**: Clicks the specified row.

Parameters:
- `vRowValues` `{object|number}` *(optional)* — Defines the row values of the target row. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

Alternatively, the 0-based row index can be used.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExpandGroupRow(iLevel, sTitle)

**DESCRIPTION**: Expands a row corresponding to a visual group.

Parameters:
- `iLevel` `{number}` — The level of the group row to be expanded (1-based)
- `sTitle` `{string}` — The title of the group row to be expanded

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCollapseGroupRow(iLevel, sTitle)

**DESCRIPTION**: Collapses a row corresponding to a visual group.

Parameters:
- `iLevel` `{number}` — The level of the group row to be collapsed (1-based)
- `sTitle` `{string}` — The title of the group row to be collapsed

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iChangeRow([vRowValues], mTargetValues, bInputNotFinalized)

**DESCRIPTION**: Changes the specified row. The given value map must match exactly one row.

If only one parameter is provided, it must be the mTargetValues and mRowValues is considered undefined.
If vRowValues are not defined, then the targetValues are inserted in the creationRow.

Parameters:
- `vRowValues` `{object|number}` *(optional)* — Defines the row values of the target row. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

Alternatively, the 0-based row index can be used.
- `mTargetValues` `{object}` — A map of columns (either name or index) to its new value. The columns do not need to match the ones defined in vRowValues.
- `bInputNotFinalized` `{boolean}` — If true, we keep the focus on the modified cell and don't press enter to validate the input

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteAction([vActionIdentifier])

**DESCRIPTION**: Executes an action on the table.

Parameters:
- `vActionIdentifier` `{string|sap.fe.test.api.ActionIdentifier}` *(optional)* — The identifier of the action, or its label

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteMenuAction(vAction)

**DESCRIPTION**: Executes an action form the drop-down menu that is currently open.

Parameters:
- `vAction` `{string|object}` — The label of the action or its state

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteShowHideDetails([bShowDetails])

**DESCRIPTION**: Executes the Show/Hide details action on the table.

Parameters:
- `bShowDetails` `{boolean}` *(optional)* — Optional parameter to enforce a certain state (showing details yes/no corresponds to true/false); if not set, state is toggled

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteDelete()

**DESCRIPTION**: Executes the Delete action on the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSelectQuickFilterItem([vItemIdentifier])

**DESCRIPTION**: Selects a quick-filter item on the table.

Parameters:
- `vItemIdentifier` `{object|string}` *(optional)* — If passed as an object, the following pattern will be considered:

	{
		<annotationPath>: <name of the key>
 }

If using a plain string as the identifier, it is considered the item label

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteCreate()

**DESCRIPTION**: Executes the Create action on the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteFullScreen()

**DESCRIPTION**: Executes the Fullscreen action on the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteInlineCreate()

**DESCRIPTION**: Executes the action to create a row in the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteInlineAction([vRowValues], vColumn)

**DESCRIPTION**: Executes an action that is available in a certain column within a table row.

Parameters:
- `vRowValues` `{object|number}` *(optional)* — Defines the row values of the target row. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

Alternatively, the 0-based row index can be used.
- `vColumn` `{string|number}` — The column name, label or index

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iExecuteKeyboardShortcut(sShortcut, [vRowValues], vColumn)

**DESCRIPTION**: Executes a keyboard shortcut on the table or a cell control.
If only sShortcut is defined, the shortcut is executed on the table directly.
If additionally vRowValues and vColumn are defined, the shortcut is executed on table cell level.

Parameters:
- `sShortcut` `{string}` — The shortcut pattern
- `vRowValues` `{object|number}` *(optional)* — Defines the row values of the target row. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

Alternatively, the 0-based row index can be used.
- `vColumn` `{string|number}` — The column name, label or index

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSaveVariant([sVariantName])

**DESCRIPTION**: Saves a variant under the given name, or overwrites the current one.

Parameters:
- `sVariantName` `{string}` *(optional)* — The name of the new variant. If omitted, the current variant will be overwritten

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iRemoveVariant(sVariantName)

**DESCRIPTION**: Removes the variant of the given name.

Parameters:
- `sVariantName` `{string}` — The name of the variant to be removed

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSelectVariant(sVariantName)

**DESCRIPTION**: Selects the chosen variant.

Parameters:
- `sVariantName` `{string}` — The name of the variant to be selected

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSetDefaultVariant(sVariantName)

**DESCRIPTION**: Sets the variant as the default.

Parameters:
- `sVariantName` `{string}` — The name of the variant to be set as the default variant. If omitted, the Standard variant is set as the default

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iAddAdaptationColumn(vColumnIdentifier)

**DESCRIPTION**: Adds a field as a column to the table.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier}` — The identifier of the column field, or its label

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iRemoveAdaptationColumn(vColumnIdentifier)

**DESCRIPTION**: Removes a field as a column from the table.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier}` — The identifier of the column field, or its label

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iChangeSortOrder(vColumnIdentifier, [sSortOrder])

**DESCRIPTION**: Adds a field to the sorting of the table via the sort dialog.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier}` — The identifier of the column field, or its label
- `sSortOrder` `{sap.ui.core.SortOrder}` *(optional)* — The sort order, default is {@link sap.ui.core.SortOrder.Ascending}

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSortByColumn(vColumnIdentifier, [sFieldLabel], [bDescending])

**DESCRIPTION**: Sorts the table entries by the specified column.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier|number}` — The identifier of the column field, its label or index
- `sFieldLabel` `{string}` *(optional)* — The target field for sorting in case the field label differs from the column label or in case of a complex property
- `bDescending` `{boolean}` *(optional)* — Sorting (true=descending, false=ascending (default))

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iGroupByColumn(vColumnIdentifier, [sFieldLabel])

**DESCRIPTION**: Groups the table entries by the specified column.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier|number}` — The identifier of the column field, its label or index
- `sFieldLabel` `{string}` *(optional)* — The target field for grouping. If undefined, parameter vColumnIdentifier is used as label to identify the toggle button.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iAggregateByColumn(vColumnIdentifier, [sFieldLabel])

**DESCRIPTION**: Aggregates the table entries by the specified column.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier|number}` — The identifier of the column field, its label or index
- `sFieldLabel` `{string}` *(optional)* — The target field to group on. If undefined, parameter vColumnIdentifier is used as label to identify the toggle button.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iChangeSearchField([sSearchText])

**DESCRIPTION**: Changes the search field.

Parameters:
- `sSearchText` `{string}` *(optional)* — The new search text

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iResetSearchField()

**DESCRIPTION**: Resets the search field.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iChangeFilterField(vColumnIdentifier, vValue, [bClearFirst])

**DESCRIPTION**: Adds a filter condition to the filter field.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier}` — The identifier of the column
- `vValue` `{string|object}` — Defines the value of the filter field condition
- `bClearFirst` `{boolean}` *(optional)* — Set to true to clear previously set filters, otherwise all previously set values will be kept

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iPasteData(aData)

**DESCRIPTION**: Pastes data into the table.

Parameters:
- `aData` `{Array.<Array.<string>>}` — The data to be pasted

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iClickOnMessageStripFilter()

**DESCRIPTION**: Presses the messageStrip filter in case of issues, warnings or error message on the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenColumnAdaptation()

**DESCRIPTION**: Opens the column adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnAdaptation()

**DESCRIPTION**: Confirms and closes the adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenColumnSorting()

**DESCRIPTION**: Opens the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnSorting()

**DESCRIPTION**: Confirms and closes the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenFilterDialog()

**DESCRIPTION**: Opens the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmFilterDialog()

**DESCRIPTION**: Confirms and closes the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

sap.fe.test.api.TableActions


**TITLE**: sap.fe.test.api.TableAPI

**INTRODUCTION**: Constructs a new KPICardAPI instance.

**TAGS**: sap.fe.test, OPA5, testing, tableapi, api, sap.fe.test.api

**STEP**: iOpenColumnAdaptation()

**DESCRIPTION**: Opens the column adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnAdaptation()

**DESCRIPTION**: Confirms and closes the adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenColumnSorting()

**DESCRIPTION**: Opens the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnSorting()

**DESCRIPTION**: Confirms and closes the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenFilterDialog()

**DESCRIPTION**: Opens the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmFilterDialog()

**DESCRIPTION**: Confirms and closes the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

sap.fe.test.api.TableAPI


**TITLE**: sap.fe.test.api.TableAPI

**INTRODUCTION**: Constructs a new TableAPI instance.

**TAGS**: sap.fe.test, OPA5, testing, tableapi, api, sap.fe.test.api

**STEP**: iOpenColumnAdaptation()

**DESCRIPTION**: Opens the column adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnAdaptation()

**DESCRIPTION**: Confirms and closes the adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenColumnSorting()

**DESCRIPTION**: Opens the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnSorting()

**DESCRIPTION**: Confirms and closes the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenFilterDialog()

**DESCRIPTION**: Opens the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmFilterDialog()

**DESCRIPTION**: Confirms and closes the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

sap.fe.test.api.TableAPI


**TITLE**: sap.fe.test.api.TableAssertions

**INTRODUCTION**: Constructs a new TableAssertions instance. Extends sap.fe.test.api.TableAPI.

**TAGS**: sap.fe.test, OPA5, testing, tableassertions, assertions, sap.fe.test.api

**STEP**: iCheckState([mState])

**DESCRIPTION**: Checks the state of the table.

Parameters:
- `mState` `{object}` *(optional)* — Defines the expected state of the table

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckRows([mRowValues], [iExpectedNumberOfRows], [mState], [vHiddenCells])

**DESCRIPTION**: Checks the rows of a table.
If mRowValues is provided, only rows with the corresponding values are considered.
If iNumberOfRows is provided, the number of rows are checked with respect to the provided mRowValues (if set) or in total.
If iNumberOfRows is omitted, it checks for at least one matching row.
If mState is provided, the row must be in the given state.

Parameters:
- `mRowValues` `{object}` *(optional)* — Defines the row values of the target row. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

- `iExpectedNumberOfRows` `{number}` *(optional)* — The expected number of rows considering mRowValues and mRowState
- `mState` `{object}` *(optional)* — Defines the expected state of the target row
- `vHiddenCells` `{Array}` *(optional)* — Defines the cells of the identified rows which are expected to the hidden (visible=false). You can also use test function iCheckCells to
explicitly check a specific cell of a row.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckCreationRow([mRowValues], [mState])

**DESCRIPTION**: Checks the state of the CreationRow button in the table.

Parameters:
- `mRowValues` `{object}` *(optional)* — Defines the expected row values. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

- `mState` `{object}` *(optional)* — Defines the expected state of the target row

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckQuickFilterItems(iExpectedNumberOfItems)

**DESCRIPTION**: Checks the number of items in the quick-filter menu.

Parameters:
- `iExpectedNumberOfItems` `{number}` — The expected number of quick-filter items

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckColumns([iExpectedNumberOfColumns], [mColumnStateMap])

**DESCRIPTION**: Checks the state of the columns of the table.

Parameters:
- `iExpectedNumberOfColumns` `{number}` *(optional)* — The expected number of columns
- `mColumnStateMap` `{object}` *(optional)* — A map of columns and their expected state. The map looks like

	{
		<columnName | columnLabel | columnIndex>: {
			header: "My header"
		}
	}

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckCells([vRowValues], mColumnStateMap)

**DESCRIPTION**: Checks the state of the cells of a table.
This function can only be used for simple content within a table cell. Checking complex content like combined fields within a cell is not supported.

Parameters:
- `vRowValues` `{object|number}` *(optional)* — Defines the row values of the target row. The pattern is:

	{
		<column-name-or-index>: <expected-value>
 }

Alternatively, the 0-based row index can be used.
- `mColumnStateMap` `{object}` — A map of columns and their state. The map looks like

	{
		<column-name-or-index>: {
			header: "My header"
		}
	}

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckAction(vActionIdentifier, [mState])

**DESCRIPTION**: Checks the state of a table action.

Parameters:
- `vActionIdentifier` `{string|sap.fe.test.api.ActionIdentifier}` — The identifier of the action, or its label
- `mState` `{object}` *(optional)* — Defines the expected state of the button

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckMenuAction(vAction)

**DESCRIPTION**: Checks an action in the drop-down menu that is currently open.

Parameters:
- `vAction` `{object|string}` — The label of the action, or its state

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckDelete([mState])

**DESCRIPTION**: Checks the Delete action of the table.

Parameters:
- `mState` `{object}` *(optional)* — Defines the expected state of the button

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckSearchField([sSearchText], [mState])

**DESCRIPTION**: Checks the search field in the table toolbar. If the sSearchText parameter is undefined, the search text is not validated.

Parameters:
- `sSearchText` `{string}` *(optional)* — The expected text in the search field
- `mState` `{object}` *(optional)* — Defines the expected state of the search field

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function that can be used for chaining statements

**STEP**: iCheckCreate([mState])

**DESCRIPTION**: Checks the Create action of the table.

Parameters:
- `mState` `{object}` *(optional)* — Defines the expected state of the button

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckPaste()

**DESCRIPTION**: Checks whether the paste button is available for the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckFullScreen([mState])

**DESCRIPTION**: Checks the Fullscreen action of the table.

Parameters:
- `mState` `{object}` *(optional)* — Defines the expected state of the button

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckColumnAdaptation()

**DESCRIPTION**: Checks whether the adaptation button is available for the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckColumnSorting()

**DESCRIPTION**: Checks whether the sort button is available for the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckColumnFiltering()

**DESCRIPTION**: Checks whether the filter button is available for the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckExport()

**DESCRIPTION**: Checks whether the export button is available for the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckQuickFilter([mState])

**DESCRIPTION**: Checks the quick filter action of the table.

Parameters:
- `mState` `{object}` *(optional)* — Defines the expected state of the control

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckColumnAdaptationDialog()

**DESCRIPTION**: Checks whether the column adaptation dialog is open.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckAdaptationColumn(vColumnIdentifier, [mState])

**DESCRIPTION**: Checks a field in the adaptation dialog.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier}` — The identifier of the column, or its label
- `mState` `{object}` *(optional)* — Defines the expected state of the field control in the adaptation dialog

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckSortOrder(vColumnIdentifier, [sSortOrder], [bCheckPersonalization])

**DESCRIPTION**: Checks a field in the sorting dialog.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier}` — The identifier of the column, or its label
- `sSortOrder` `{sap.ui.core.SortOrder}` *(optional)* — The sort order of the column, default is {@link sap.ui.core.SortOrder.Ascending}
- `bCheckPersonalization` `{boolean}` *(optional)* — Defines if the order is checked via sorting dialog, or via the column itself

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckFilterField(vColumnIdentifier, [mState])

**DESCRIPTION**: Checks, if a filter field is available in the filter dialog.

Parameters:
- `vColumnIdentifier` `{string|sap.fe.test.api.ColumnIdentifier}` — The identifier of the field, or its label
- `mState` `{object}` *(optional)* — Defines the expected state of the field control in the filter dialog

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iCheckMessageStrip([mProperty])

**DESCRIPTION**: Checks a messageStrip on a table.

Parameters:
- `mProperty` `{object}` *(optional)* — Defines the expected properties of the messageStrip in the table

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSeeFocusOnHeader()

**DESCRIPTION**: Checks if the focus is on a table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iSeeFocusOnRow(iRowIndex)

**DESCRIPTION**: Checks if the focus is on a table row.

Parameters:
- `iRowIndex` `{number}` — The expected focused row

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenColumnAdaptation()

**DESCRIPTION**: Opens the column adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnAdaptation()

**DESCRIPTION**: Confirms and closes the adaptation dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenColumnSorting()

**DESCRIPTION**: Opens the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmColumnSorting()

**DESCRIPTION**: Confirms and closes the sorting dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iOpenFilterDialog()

**DESCRIPTION**: Opens the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

**STEP**: iConfirmFilterDialog()

**DESCRIPTION**: Confirms and closes the filtering dialog of the table.

Returns: `{object}` The result of the {@link sap.ui.test.Opa5#waitFor} function, to be used for chained statements

sap.fe.test.api.TableAssertions


**TITLE**: sap.fe.test.api Type Definitions

**INTRODUCTION**: TypeScript/JSDoc type definitions used as identifiers and parameters across the sap.fe.test OPA5 API.

**TAGS**: sap.fe.test, OPA5, testing, types, identifiers, typescript

**STEP**: TableIdentifier (sap.fe.test.api.TableIdentifier)

**DESCRIPTION**: A table identifier

Properties:
- `property` `{string}` — The name of the navigation property used for the table
- `qualifier` `{string}` *(optional)* — The name of a qualifier for the table

**STEP**: DialogIdentifier (sap.fe.test.api.DialogIdentifier)

**DESCRIPTION**: A dialog identifier

Properties:
- `type` `{sap.fe.test.api.DialogType}` — The type of the dialog

**STEP**: ActionIdentifier (sap.fe.test.api.ActionIdentifier)

**DESCRIPTION**: An action identifier

Properties:
- `service` `{string}` — The name of the service
- `action` `{string}` — The name of the action
- `unbound` `{boolean}` *(optional)* — Defines whether the action is a bound action (default: false)

**STEP**: FieldIdentifier (sap.fe.test.api.FieldIdentifier)

**DESCRIPTION**: A field identifier

Properties:
- `fieldGroup` `{string}` *(optional)* — The name of the field group containing the field. Required when identifying a field inside a header facet form.
- `property` `{string}` — The name of the field
- `targetAnnotation` `{string}` *(optional)* — The name of the target annotation, such as a Chart or MicroChart annotation term.
  When set, a DataFieldForAnnotation is identified instead of a DataField, and the resolved control ID changes accordingly.
- `connectedFields` `{string}` *(optional)* — The name of the connected field containing the field

**STEP**: SectionIdentifier (sap.fe.test.api.SectionIdentifier)

**DESCRIPTION**: A section identifier

Properties:
- `section` `{string}` — The name of the section facet
- `subSection` `{string}` *(optional)* — The name of the sub-section facet

**STEP**: ActionDialogFieldIdentifier (sap.fe.test.api.ActionDialogFieldIdentifier)

**DESCRIPTION**: An action parameter dialog field identifier

Properties:
- `property` `{string}` — The name of the field

**STEP**: DialogFieldIdentifier (sap.fe.test.api.DialogFieldIdentifier)

**DESCRIPTION**: An dialog field identifier

Properties:
- `property` `{string}` — The name of the field
In case of an action parameter dialog, this is the fieldname only

{
    property: <fieldname>
}

In case of a create dialog, the concatenation of the entity and fieldname has to be provided

{
    property: <entity>::<fieldname>
}

**STEP**: ViewIdentifier (sap.fe.test.api.ViewIdentifier)

**DESCRIPTION**: A view identifier

Properties:
- `key` `{string}` — The name of the view as defined in the manifest file

**STEP**: FilterFieldIdentifier (sap.fe.test.api.FilterFieldIdentifier)

**DESCRIPTION**: A filter field identifier

Properties:
- `property` `{string}` — The name of the property

**STEP**: FormIdentifier (sap.fe.test.api.FormIdentifier)

**DESCRIPTION**: A form identifier

Properties:
- `section` `{string}` — The facet ID
- `fieldGroup` `{string}` *(optional)* — The fieldgroup ID
- `isHeaderFacet` `{boolean}` *(optional)* — Is it about the editable header facet

**STEP**: HeaderFacetIdentifier (sap.fe.test.api.HeaderFacetIdentifier)

**DESCRIPTION**: An identifier for the header facet

Properties:
- `facetId` `{string}` — The identifier of the facet
- `collection` `{boolean}` *(optional)* — Defines whether the facet is a collection facet (default: false)
- `custom` `{boolean}` *(optional)* — Defines whether the facet is a custom header facet (default: false)

**STEP**: HeaderFieldGroupIdentifier (sap.fe.test.api.HeaderFieldGroupIdentifier)

**DESCRIPTION**: An identifier for a field within a field group in the Object Page header.
Used by {@link sap.fe.test.api.HeaderAssertions#iCheckFieldInFieldGroup},
{@link sap.fe.test.api.HeaderAssertions#iCheckLink}, and
{@link sap.fe.test.api.HeaderActions#iClickLink}.

Properties:
- `fieldGroup` `{string}` — The name of the field group containing the field
- `field` `{string}` — The name of the field within the field group
- `targetAnnotation` `{string}` *(optional)* — The target annotation path for DataFieldForAnnotation lookups.
  When present, a DataFieldForAnnotation is identified instead of a DataField.

**STEP**: ColumnIdentifier (sap.fe.test.api.ColumnIdentifier)

**DESCRIPTION**: A column identifier

Properties:
- `name` `{string}` — The technical name of the column

sap.fe.test.api Type Definitions

sap.fe.test OPA5 testing types identifiers typescript


**TITLE**: sap.fe.test.api Enumerations

**INTRODUCTION**: Enumeration types used in the sap.fe.test OPA5 API, such as dialog types and edit states.

**TAGS**: sap.fe.test, OPA5, testing, enum, constants

**STEP**: DialogType (sap.fe.test.api.DialogType)

**DESCRIPTION**: Enum for supported dialog types.

Values:
- `Confirmation` — A simple dialog supporting base checks and actions such as 'Confirm' and 'Cancel'
- `ValueHelp` — A ValueHelp dialog that has a condition definition panel or a filterable selection table
- `Message` — A message dialog for showing back-end messages
- `Error` — A dialog used for showing an error message
- `Action` — A default dialog for action parameters
- `Create` — A dialog used for creating a new object

**STEP**: EditState (sap.fe.test.api.EditState)

**DESCRIPTION**: Enum for supported editing states.

Values:
- `All` — All
- `Unchanged` — Unchanged
- `AllHidingDrafts` — All (Hiding Drafts)
- `OwnDraft` — Own Draft
- `Locked` — Locked by Another User
- `UnsavedChanges` — Unsaved Changes by Another User

sap.fe.test.api Enumerations


**TITLE**: Actions — Code Patterns and Annotation/Manifest Examples for SAP Fiori Elements

**INTRODUCTION**: This reference collects actionable, copy-ready code examples and concise guidance for implementing actions in SAP Fiori elements apps (OData V2/V4, ABAP CDS, CAP). Use these snippets to configure navigation and OData actions, control enablement/visibility, group actions/menus, prefill parameters, and override annotation behavior via manifest or extensions.

**TAGS**: SAP Fiori, annotations, manifest.json, DataFieldForAction, DataFieldForIntentBasedNavigation, DefaultValuesFunction, OperationAvailable, CAP, ABAP CDS, OData V2, OData V4, action parameters, menus, priority, overflowGroup

STEP: Context-Independent External Navigation (UI.DataFieldForIntentBasedNavigation, RequiresContext=false)

DESCRIPTION: Use these annotations to create an external navigation button that does NOT require a selected context (RequiresContext=false). Use either XML annotation, ABAP CDS, or CAP CDS formats.

LANGUAGE: XML

CODE:
```xml
<Record Type="UI.DataFieldForIntentBasedNavigation" >
            <PropertyValue Property="Label" String="Navigation Tester with RequiresContext"/>
            <PropertyValue Property="SemanticObject" String="Object"/>
            <PropertyValue Property="Action" String="Action"/>
            <PropertyValue Property="RequiresContext" Bool="false"/>
       </Record>
```

LANGUAGE: ABAP CDS

CODE:
```
{
    label: 'Navigation Tester with RequiresContext',
    semanticObject: 'Object',
    semanticObjectAction: 'Action',
    requiresContext: false,
    type: #FOR_INTENT_BASED_NAVIGATION
}
```

LANGUAGE: CAP CDS

CODE:
```
{
    $Type : 'UI.DataFieldForIntentBasedNavigation',
    Label : 'Navigation Tester with RequiresContext',
    SemanticObject : 'Object',
    Action : 'Action',
    RequiresContext : false
}
```

STEP: Context-Dependent External Navigation (UI.DataFieldForIntentBasedNavigation, RequiresContext=true)

DESCRIPTION: Use these annotations to require a selected context for navigation (RequiresContext=true).

LANGUAGE: XML

CODE:
```xml
<Record Type="UI.DataFieldForIntentBasedNavigation" >
            <PropertyValue Property="Label" String="Navigation Tester with RequiresContext"/>
            <PropertyValue Property="SemanticObject" String="Object"/>
            <PropertyValue Property="Action" String="Action"/>
            <PropertyValue Property="RequiresContext" Bool="true"/>
</Record>
```

LANGUAGE: ABAP CDS

CODE:
```
{
    label: 'Navigation Tester with RequiresContext',
    semanticObject: 'Object',
    semanticObjectAction: 'Action',
    requiresContext: true,
    type: #FOR_INTENT_BASED_NAVIGATION
}
```

LANGUAGE: CAP CDS

CODE:
```
{
    $Type : 'UI.DataFieldForIntentBasedNavigation',
    Label : 'Navigation Tester with RequiresContext',
    SemanticObject : 'Object',
    Action : 'Action',
    RequiresContext : true
}
```

STEP: UI.DataFieldForAction — InvocationGrouping (grouping multiple invocations for multi-select)

DESCRIPTION: Control how multiple invocations of the same action (selected multiple rows) are grouped using InvocationGrouping. Use Isolated for separate changesets or ChangeSet for all-or-nothing.

LANGUAGE: XML

CODE:
```xml
<Record Type="UI.DataFieldForAction">
  <PropertyValue Property="Label" String="My Action"/>
  <PropertyValue Property="Action" String="STTA_SALES_ORDER_WD_20_SRV.STTA_SALES_ORDER_WD_20_SRV_Entities/C_STTA_SalesOrder_WD_20My_FunctionImport"/>
  <PropertyValue Property="InvocationGrouping" EnumMember="UI.OperationGroupingType/Isolated"/>
</Record>
```

LANGUAGE: ABAP CDS

CODE:
```
 {
    label: 'My Action',
    dataAction: 'PUSHDOWN:C_STTA_SalesOrder_WD_20My_FunctionImport',
    invocationGrouping: #ISOLATED,
    type: #FOR_ACTION,
    position: 1
  }
```

LANGUAGE: CAP CDS

CODE:
```
{
    $Type : 'UI.DataFieldForAction',
    Label : 'My Action',
    Action : 'STTA_SALES_ORDER_WD_20_SRV.STTA_SALES_ORDER_WD_20_SRV_Entities/C_STTA_SalesOrder_WD_20My_FunctionImport',
    InvocationGrouping : #Isolated
},
```

STEP: Prefill Action Parameters Using DefaultValuesFunction — FunctionImport + Annotations

DESCRIPTION: Define a function import to return default values for an action's parameter dialog and annotate the action/entity with Common.DefaultValuesFunction. This triggers backend calculation of defaults when the dialog opens.

LANGUAGE: XML (FunctionImport + Annotations)

CODE:
```xml
<FunctionImport
    Name="GetDefaultsForSetText"
    ReturnType="cds_zrc_dv_defaultvalues.ZRC_DV_A_SetText"
    m:HttpMethod="GET"
    sap:action-for="cds_zrc_dv_defaultvalues.RootType">
    <Parameter
        Name="UUID"
        Type="Edm.Guid"
        Mode="In"/>
</FunctionImport>

<Annotations
    xmlns="http://docs.oasis-open.org/odata/ns/edm"
    Target="cds_zrc_dv_defaultvalues.cds_zrc_dv_defaultvalues_Entities/SetText">

    <Annotation
        Term="com.sap.vocabularies.Common.v1.SideEffects"
        Qualifier="Action">
        <Record>
            <PropertyValue Property="TargetProperties">
                <Collection>
                    <PropertyPath>Text</PropertyPath>
                </Collection>
            </PropertyValue>
        </Record>
    </Annotation>

    <Annotation
        Term="com.sap.vocabularies.Common.v1.DefaultValuesFunction"
        String="GetDefaultsForSetText"/>
</Annotations>
```

STEP: Prefill Action Parameters — CAP: declare return complex type + service function

DESCRIPTION: CAP-based service: define the complex type for defaults and implement a handler that returns default values for action parameters.

LANGUAGE: CAP CDS (type declaration)

CODE:
```
service myService {
  type defaultParamsForSalesOrderCreate {
     SalesOrderType: db.SalesOrderManage : SalesOrderType;
     IncotermsLocation1: db.SalesOrderManage:IncotermsLocation1;
      CustomerPaymentTerms: db.SalesOrderManage: CustomerPaymentTerms;
      OverallSDProcessStatus: db.SalesOrderManage: OverallSDProcessStatus;
      DescriptionFieldForOPACleanup: db.SalesOrderManage: DescriptionFieldForOPACleanup
  };
}
```

LANGUAGE: JavaScript (srv.on handler in CAP service)

CODE:
```
srv.on("GetDefaultParamsForCustomAction", "SalesOrderManage", async req => {
        const tx = cds.transaction(req);
        const salesOrderItem = await tx.run(SELECT.one.from(SalesOrderManage).where(req.query.SELECT.from.ref[0].where));
        if (!salesOrderItem) throw new Error("Not found");
        const overallSDProcessStatus = salesOrderItem.OverallSDProcessStatus;
        var currentDateTime = getCurrentDateTime();

        return {
            OverallSDProcessStatus: overallSDProcessStatus,
            SalesOrderType: "SE",
            LastChangedDateTime: currentDateTime
        };
});
```

STEP: Bound / Unbound Action Definitions and References

DESCRIPTION: Action metadata: use IsBound to mark bound (requires context) vs unbound (context-independent) actions. Reference bound actions as <SchemaNamespace>.<ActionName>, and unbound actions as <SchemaNamespace>.<EntityContainer>/<ActionImportName>. Examples below show XML declarations and annotation references.

LANGUAGE: XML (Action declarations)

CODE:
```xml
<Action Name="REUNION" IsBound="true">
   <Parameter Name="_it" Type="com.sap.gateway.srvd.sadl_gw_appmusicro_definition.v0001.ArtistsType" Nullable="false" />
   <ReturnType Type="com.sap.gateway.srvd.sadl_gw_appmusicro_definition.v0001.ArtistsType" Nullable="false" />
</Action>
<Action Name="UnboundAction" IsBound="false">
   <ReturnType Type="com.sap.gateway.srvd.sadl_gw_appmusicro_definition.v0001.ArtistsType" Nullable="false" />
</Action>
```

LANGUAGE: XML (DataFieldForAction referencing a bound action)

CODE:
```xml
<Record Type="UI.DataFieldForAction">
        <PropertyValue Property="Label" String="Reunion" />
        <PropertyValue Property="Action" String="com.sap.gateway.srvd.sadl_gw_appmusicro_definition.v0001.REUNION" />
               <!-- The bound action (REUNION) is referred above in <SchemaNamespace>.<ActionName> -->
</Record>
```

LANGUAGE: XML (DataFieldForAction referencing an unbound action)

CODE:
```xml
<Record Type="UI.DataFieldForAction">
        <PropertyValue Property="Label" String="Break Up" />
        <PropertyValue Property="Action" String="com.sap.gateway.srvd.sadl_gw_appmusicro_definition.v0001.MyContainer/BREAK_ACTION" />
               <!-- The unbound action (BREAK_ACTION) is referred above in <SchemaNamespace>.<EntityContainerName>/<ActionImportName> -->
</Record>
```

LANGUAGE: CAP CDS (define bound/unbound actions)

CODE:
```
entity entityName as projection on db.baseEntity {
   actions {
      action REUNION(
         _it: $self
      ) returns Artists;
   }
}

action UnboundAction() returns Artists;
```

STEP: Static Action (bound to collection header context)

DESCRIPTION: Define a static action by using a parameter `_it` typed as a Collection — IsBound=true but it operates on the collection header context instead of per-row context. Example: XML, CAP, and reference in UI.DataFieldForAction.

LANGUAGE: XML (Action declaration)

CODE:
```xml
<Action Name="createActiveTravel" EntitySetPath="_it" IsBound="true">
            <Parameter Name="_it" Type="Collection(com.sap.gateway.srvd.dmo.ui_travel_processor_uuid.v0001.TravelType)"/>
            <ReturnType Type="com.sap.gateway.srvd.dmo.ui_travel_processor_uuid.v0001.TravelType" Nullable="false"/>
</Action>
```

LANGUAGE: CAP CDS (entity projection with static action)

CODE:
```
entity Travel as projection on db.Travel actions {
  action createActiveTravel (
    _it: many $self
  ) returns Travel;
}
```

LANGUAGE: XML (DataFieldForAction referencing static action)

CODE:
```xml
<Record Type="UI.DataFieldForAction">
        <PropertyValue Property="Label" String="Static Action"/>
        <PropertyValue Property="Action" String="com.c_salesordermanage_sd.myCreateAction(com.c_salesordermanage_sd.SalesOrderManage)"/>
</Record>
```

STEP: Action Parameters — Declaration (single values and collections)

DESCRIPTION: Define action parameters on the backend action metadata. Bound actions include the binding parameter `_it`. Examples show mandatory parameters, collections, and CAP definitions.

LANGUAGE: XML (CreateWithSalesOrderType with parameters)

CODE:
```xml
<Action Name="CreateWithSalesOrderType" EntitySetPath="_it" IsBound="true">
    <Parameter Name="_it" Type="Collection(com.sap.gateway.srvd.c_salesordermanage_sd.v0001.SalesOrderManageType)" Nullable="false"/> <!-- This one is ignored -->
    <Parameter Name="SalesOrderType" Type="Edm.String" Nullable="false" MaxLength="4"/>
    <Parameter Name="SalesOrganization" Type="Edm.String" Nullable="false" MaxLength="4"/>
    <Parameter Name="DistributionChannel" Type="Edm.String" Nullable="false" MaxLength="2"/>
    <Parameter Name="OrganizationDivision" Type="Edm.String" Nullable="false" MaxLength="2"/>
    <ReturnType Type="com.sap.gateway.srvd.c_salesordermanage_sd.v0001.SalesOrderManageType" Nullable="false"/>
</Action>
```

LANGUAGE: CAP CDS (projection action with typed params)

CODE:
```
entity SalesOrderManage as projection on db.baseEntity actions {
  action CreateWithSalesOrderType(
    _it: $self,
    SalesOrderType        : sd.param.SalesOrderType        not null,
    SalesOrganization     : sd.param.SalesOrganization     not null,
    OrganizationDivision  : sd.param.OrganizationDivision  not null,
    DistributionChannel   : sd.param.DistributionChannel   not null
  ) returns SalesOrderManage;
}
```

LANGUAGE: XML (collection parameter example)

CODE:
```
<Action Name="CreateFromSalesOrder" IsBound="true" EntitySetPath="_it">
     <Parameter Name="_it" Type="Collection(com.c_salesordermanage_sd.SalesOrderManage)"/>
     <Parameter Name="SalesOrderId" Type="Edm.String" MaxLength="10" Nullable="false"/>
     <Parameter Name="SalesOrderItemId" Type="Collection(Edm.Int32)" Nullable="false"/>
     <ReturnType Type="com.c_salesordermanage_sd.SalesOrderManage"/>
</Action>
```

STEP: Grouping Action Parameters in Dialog (UI.OperationParameterFacets + UI.FieldGroup)

DESCRIPTION: Use UI.OperationParameterFacets to group parameters into labeled sections in the action parameter dialog. The dialog layout is ColumnLayout via sap.ui.layout.form.SimpleForm.

LANGUAGE: XML

CODE:
```xml
<Annotations Target="com.c_salesordermanage_sd.CreateWithSalesOrderType(com.c_salesordermanage_sd.SalesOrderManage)">
    <Annotation Term="UI.OperationParameterFacets">
        <Collection>
            <Record Type="UI.ReferenceFacet">
                <PropertyValue Property="Label" String="First Parameter Group"/>
                <PropertyValue Property="Target" AnnotationPath="@UI.FieldGroup#FirstGroup"/>
            </Record>
            <Record Type="UI.ReferenceFacet">
                <PropertyValue Property="Label" String="Second Parameter Group"/>
                <PropertyValue Property="Target" AnnotationPath="@UI.FieldGroup#SecondGroup"/>
            </Record>
        </Collection>
    </Annotation>

    <Annotation Term="UI.FieldGroup" Qualifier="FirstGroup">
        <Record Type="UI.FieldGroupType">
            <PropertyValue Property="Data">
                <Collection>
                    <Record Type="UI.DataField">
                        <PropertyValue Property="Value" Path="SalesOrderType"/>
                    </Record>
                    <Record Type="UI.DataField">
                        <PropertyValue Property="Value" Path="SalesOrganization"/>
                    </Record>
                </Collection>
            </PropertyValue>
        </Record>
    </Annotation>

    <Annotation Term="UI.FieldGroup" Qualifier="SecondGroup">
        <Record Type="UI.FieldGroupType">
            <PropertyValue Property="Data">
                <Collection>
                    <Record Type="UI.DataField">
                        <PropertyValue Property="Value" Path="OrganizationDivision"/>
                    </Record>
                    <Record Type="UI.DataField">
                        <PropertyValue Property="Value" Path="DistributionChannel"/>
                    </Record>
                </Collection>
            </PropertyValue>
        </Record>
    </Annotation>
</Annotations>
```

LANGUAGE: CAP CDS

CODE:
```
@UI
 : {
        OperationParameterFacets: [
          {
            $Type : 'UI.ReferenceFacet',
            Label : 'First Parameter Group',
            Target: '@UI.FieldGroup#FirstGroup'
          },
          {
            $Type : 'UI.ReferenceFacet',
            Label : 'Second Parameter Group',
            Target: '@UI.FieldGroup#SecondGroup'
          }
        ],
        FieldGroup #FirstGroup  : {
          $Type: 'UI.FieldGroupType',
          Data : [
            {
              $Type: 'UI.DataField',
              Value: SalesOrderType
            },
            {
              $Type: 'UI.DataField',
              Value: SalesOrganization
            }
          ],
        },
        FieldGroup #SecondGroup : {
          $Type: 'UI.FieldGroupType',
          Data : [
            {
              $Type: 'UI.DataField',
              Value: OrganizationDivision
            },
            {
              $Type: 'UI.DataField',
              Value: DistributionChannel
            }
          ],
        }
      }
action CreateWithSalesOrderType(
     SalesOrderType : sd.param.SalesOrderType not null,
 	SalesOrganization : sd.param.SalesOrganization not null,
 	OrganizationDivision : sd.param.OrganizationDivision not null,
 	DistributionChannel : sd.param.DistributionChannel not null
) returns SalesOrderManage;
```

STEP: Default Parameter Values — ParameterDefaultValue (annotation and CAP examples)

DESCRIPTION: Use UI.ParameterDefaultValue to prefill action parameters from a path or fixed string. The path must reference data already loaded into the table or use PresentationVariant/RequestAtLeast to load it.

LANGUAGE: XML

CODE:
```xml
<Annotations Target="SalesOrder.CreateWithSalesOrderType/SalesOrderType">
   <Annotation Term="UI.ParameterDefaultValue" Path="_it/SalesOrderType"/>
</Annotations>
<Annotations Target="SalesOrder.CreateWithSalesOrderType/SalesOrganization">
   <Annotation Term="UI.ParameterDefaultValue" String="0001"/>
</Annotations>
```

LANGUAGE: CAP CDS

CODE:
```
annotate SalesOrder.CreateWithSalesOrderType with {
    UI.ParameterDefaultValue : _it.SalesOrderType
    SalesOrderType
};
annotate SalesOrder.CreateWithSalesOrderType with {
    UI.ParameterDefaultValue : '0001'
    SalesOrganization
};
```

LANGUAGE: ABAP (annotation snippet)

CODE:
```
annotate sd.param.SalesOrderType with @(UI.ParameterDefaultValue: _it.SalesOrderType);
annotate sd.param.SalesOrganization with @(UI.ParameterDefaultValue: '0001');
```

STEP: Default Values from Backend (Common.DefaultValuesFunction annotation on actions/entities)

DESCRIPTION: Annotate actions (or entities for create) with Common.DefaultValuesFunction to call a backend function that returns parameter defaults. The returned structure field names/types must match action parameters.

LANGUAGE: XML (annotate action)

CODE:
```
<Annotations Target="myService.CustomAction(myService.SalesOrderManage)">
         <Annotation Term="Common.DefaultValuesFunction" String=" myService.GetDefaultParamsForCustomAction " />
</Annotations>
```

LANGUAGE: XML (annotate entity for standard create)

CODE:
```
<Annotations Target=" myService.EntityContainer/SalesOrderManage">
         <Annotation Term="Common.DefaultValuesFunction" String="GetDefaultParamsForSalesOrderCreate" />
</Annotations>
```

STEP: Frontend Default Values via extension.defaultValuesFunction (manifest + JS)

DESCRIPTION: Override or compute defaults on the frontend by wiring a JavaScript function in manifest.json controlConfiguration.defaultValuesFunction. The function receives the current context and selected contexts and must return an object with parameterName:value entries.

LANGUAGE: JSON (manifest.json fragment)

CODE:
```json
"sap.ui5": {
    "routing": {
        "targets": {
            "SalesOrderManageList": {
                "options": {
                    "settings": {
                        "controlConfiguration": {
                            "@com.sap.vocabularies.UI.v1.LineItem": {
                                "actions": {
                                    "DataFieldForAction::com.c_salesordermanage_sd.CreateWithSalesOrderType": {
                                        "defaultValuesFunction": "SalesOrder.ext.CustomActions.getDefaultValues"
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```

LANGUAGE: JavaScript (extension function)

CODE:
```
getDefaultValues: function(oContext, aSelectedContexts) {
            var oDefaultParams;
            if (aSelectedContexts.length > 1) {
                oDefaultParams = {
                    "SalesOrderType": "SO03",
                    "SalesOrganization": "1111"
                };
            } else {
                oDefaultParams = {
                    "SalesOrderType": "SE",
                    "SalesOrganization": "",
                    "DistributionChannel": "03"
                };
            }
            return oDefaultParams;
        },
```

STEP: Hide Action Parameters (UI.Hidden examples, static/dynamic)

DESCRIPTION: Use UI.Hidden on action parameters to hide them. Supports Bool, Path, or dynamic expressions. If all parameters hidden and mandatory ones have ParameterDefaultValue, action runs without a dialog.

LANGUAGE: XML

CODE:
```xml
<Action Name="actionWithHiddenParameters" IsBound="true">
     <Parameter Name="_it" Type="sap.fe.manageitems.TechnicalTestingService.LineItems"/>
     <Parameter Name="myParameterHiddenFalse" Type="Edm.String"/>
     <Parameter Name="myParameterHiddenTrue" Type="Edm.String"/>
     <Parameter Name="myParameterHiddenDynamicPath" Type="Edm.String"/>
     <Parameter Name="myParameterHiddenDynamicExp" Type="Edm.String"/>
</Action>

<Annotations Target="sap.fe.manageitems.TechnicalTestingService.actionWithHiddenParameters(sap.fe.manageitems.TechnicalTestingService.LineItems)/myParameterHiddenFalse">
     <Annotation Term="UI.Hidden" Bool="false"/>
     <Annotation Term="Common.Label" String="Testparameter (Hidden=false)"/>
</Annotations>

<Annotations Target="sap.fe.manageitems.TechnicalTestingService.actionWithHiddenParameters(sap.fe.manageitems.TechnicalTestingService.LineItems)/myParameterHiddenTrue">
     <Annotation Term="UI.Hidden" Bool="true"/>
     <Annotation Term="Common.Label" String="Testparameter (Hidden=true)"/>
</Annotations>

<Annotations Target="sap.fe.manageitems.TechnicalTestingService.actionWithHiddenParameters(sap.fe.manageitems.TechnicalTestingService.LineItems)/myParameterHiddenDynamicPath">
     <Annotation Term="UI.Hidden" Path="_it/preferredItem"/>
     <Annotation Term="Common.Label" String="Testparameter (Hidden=Dynamic via path)"/>
</Annotations>

<Annotations Target="sap.fe.manageitems.TechnicalTestingService.actionWithHiddenParameters(sap.fe.manageitems.TechnicalTestingService.LineItems)/myParameterHiddenDynamicExp">
     <Annotation Term="UI.Hidden">
          <If>
               <Eq>
                    <Path>myParameterHiddenFalse</Path>
                    <String>Show myParameterHiddenDynamicExp parameter</String>
               </Eq>
               <Bool>false</Bool>
               <Bool>true</Bool>
          </If>
     </Annotation>
     <Annotation Term="Common.Label" String="Testparameter (Hidden=Dynamic via path)"/>
</Annotations>
```

LANGUAGE: CAP CDS

CODE:
```
       @cds.odata.bindingparameter.name : '_it'
       action actionWithHiddenParameters(

                @title                           : 'Testparameter (Hidden=false)'
                @UI.Hidden                       : false
                myParameterHiddenFalse           : String,

                @title                           : 'Testparameter (Hidden=true)'
                @UI.Hidden                       : true
                myParameterHiddenTrue            : String,

                @title                           : 'Testparameter (Hidden=Dynamic via path)'
                @UI.Hidden                       : _it.preferredItem
                myParameterHiddenDynamicPath     : String,

                @title                           : 'Testparameter (Hidden=Dynamic via path)'
                @UI.Hidden                       : {$edmJson: {$If: [{$Eq: [{$Path: 'myParameterHiddenFalse'}, 'Show myParameterHiddenDynamicExp parameter']}, false, true]}}
                myParameterHiddenDynamicExp      : String
            );
```

STEP: Grouping Actions as Menu Buttons — Annotation-Based Action Group

DESCRIPTION: Create an annotation-based action group using UI.DataFieldForActionGroup with ID and Actions collection. Use DataFieldForAction items inside the Actions collection. CAP and XML examples provided.

LANGUAGE: XML

CODE:
```xml
<edmx:Reference Uri="https://sap.github.io/odata-vocabularies/vocabularies/UI.xml">
    <edmx:Include Namespace="com.sap.vocabularies.UI.v1" Alias="UI"/>
</edmx:Reference>

<Record Type="UI.DataFieldForActionGroup">
              <PropertyValue Property="Label" String="Action Group" />
              <PropertyValue Property="ID" String="groupedActions" />
              <PropertyValue Property="Actions">
                <Collection>
                  <Record Type="UI.DataFieldForAction">
                    <PropertyValue Property="Label" String="Action 1 inside Action Group" />
                    <PropertyValue
                      Property="Action"
                      String="com.c_salesordermanage_sd.SalesOrderManage.Action1"
                />
                  </Record>
                  <Record Type="UI.DataFieldForAction">
                    <PropertyValue Property="Label" String="Action 2 inside Action Group" />
                    <PropertyValue
                      Property="Action"
                      String="com.c_salesordermanage_sd.SalesOrderManage.Action2"
                    />
                  </Record>
                  <Record Type="UI.DataFieldForAction">
                    <PropertyValue Property="Label" String="Action 3 inside Action Group" />
                    <PropertyValue
                      Property="Action"
                      String="com.c_salesordermanage_sd.SalesOrderManage.Action3"
                    />
                  </Record>
                </Collection>
              </PropertyValue>
</Record>
```

LANGUAGE: CAP CDS

CODE:
```
{
       $Type  : 'UI.DataFieldForActionGroup',
       Label  : 'Action Group',
       ID     : 'groupedActions',
       Actions: [
           {
               $Type  : 'UI.DataFieldForAction',
               Label  : 'Action 1 inside Action Group',
               Action : 'com.c_salesordermanage_sd.SalesOrderManage.Action1'
           },
           {
               $Type  : 'UI.DataFieldForAction',
               Label  : 'Action 2 inside Action Group',
               Action : 'com.c_salesordermanage_sd.SalesOrderManage.Action2'
           },
            {
               $Type  : 'UI.DataFieldForAction',
               Label  : 'Action 3 inside Action Group',
               Action : 'com.c_salesordermanage_sd.SalesOrderManage.Action3'
           }
       ]
   }
```

STEP: Grouping Actions as Menu Buttons — Manifest-Based Examples (Header, Form, Table)

DESCRIPTION: Use manifest.json control/route settings to define menu items and to group manifest-defined actions and annotation-based actions under a menu button. Keys must match action keys (DataFieldForAction::..., DataFieldForIntentBasedNavigation::SemanticObject::Action).

LANGUAGE: JSON (Grouping Header Actions)

CODE:
```json
"SalesOrderManageObjectPage": {
    "type": "Component",
    "id": "SalesOrderManageObjectPage",
    "name": "sap.fe.templates.ObjectPage",
    "options": {
        "settings": {
           "content": {
              "header": {
                "actions": {
                    "myFirstAction": {
                        "press": "SalesOrder.ext.CustomActions.message",
                        "text": "My First Action"
                    },
                    "mySecondAction": {
                        "press": "SalesOrder.ext.CustomActions.message",
                        "text": "My Second Action"
                    },
                    "MenuActions": {
                        "text": "My Menu Button",
                        "menu": [
                            "myFirstAction",
                            "mySecondAction",
                            "DataFieldForAction::com.c_salesordermanage_sd.BoundActionWithParams"
                            ]
                        }
                    }
                }
            }
        }
    }
}
```

LANGUAGE: JSON (Grouping Form Actions)

CODE:
```json
"options": {
    "settings": {
        "contextPath": "/SalesOrderManage",
        "controlConfiguration": {
            "@com.sap.vocabularies.UI.v1.FieldGroup#OrderData": {
                "actions": {
                    "myFirstAction": {
                        "press": "SalesOrder.ext.CustomActions.getCustomerName",
                        "visible": true,
                        "enabled": true,
                        "text": "My First Action"
                    },
                    "mySecondAction": {
                        "press": "SalesOrder.ext.CustomActions.message",
                        "text": "My Second Action"
                    },
                    "MenuActions": {
                        "text": "My Menu Button",
                        "menu": [
                           "myFirstAction",
                           "mySecondAction",
                           "DataFieldForAction::com.c_salesordermanage_sd.BoundActionWithParams"
                        ]
                    }
                }
            }
        }
    }
}
```

LANGUAGE: JSON (Grouping Table Toolbar Actions)

CODE:
```json
"options": {
    "settings": {
        "contextPath": "/SalesOrderManage",
        "controlConfiguration": {
            "@com.sap.vocabularies.UI.v1.LineItem": {
                "actions": {
                    "myFirstAction": {
                        "press": "SalesOrder.ext.CustomActions.getCustomerName",
                        "visible": true,
                        "enabled": true,
                        "text": "My First Action"
                    },
                    "mySecondAction": {
                        "press": "SalesOrder.ext.CustomActions.message",
                        "text": "My Second Action"
                    },
                    "MenuActions": {
                        "text": "My Menu Button",
                        "menu": [
                           "myFirstAction",
                           "mySecondAction",
                           "DataFieldForAction::com.c_salesordermanage_sd.BoundActionWithParams"
                        ]
                    }
                }
            }
        }
    }
}
```

STEP: Pushing Intent-Based Nav Buttons into Menu (manifest key format)

DESCRIPTION: Use the full key format DataFieldForIntentBasedNavigation::<Semantic Object>::<Action> when adding intent-based navigation items into manifest menu arrays.

LANGUAGE: JSON

CODE:
```json
"MenuActions": {
     "text": "My Menu Button",
     "menu": [
          "myFirstAction",
          "DataFieldForIntentBasedNavigation::<Semantic Object>::<Action>"
     ]
}
```

STEP: Defining a Default Action for a Menu Button (manifest.json)

DESCRIPTION: Set defaultAction to make clicking the menu button execute an action directly. Use existing menu entries or explicit keys.

LANGUAGE: JSON

CODE:
```json
"MenuActionsCreateFromTemplate": {
     "text": "Usage Example of a defaultAction",
     "defaultAction": "DataFieldForIntentBasedNavigation::SalesOrder::defaultActionToBeCalled",
     "menu": [
          "DataFieldForAction::com.c_salesordermanage_sd.CreateFromCustomer",
          "DataFieldForAction::com.c_salesordermanage_sd.CreateFromSalesOrder",
          "DataFieldForIntentBasedNavigation::SalesOrder::manageInline"
     ]
}
```

STEP: Setting Action Priority (manifest.json)

DESCRIPTION: Use the priority property on actions to influence toolbar overflow behavior. Values: Low, High, AlwaysOverflow, NeverOverflow. Can be set for custom and standard actions (except Share cannot be overridden).

LANGUAGE: JSON

CODE:
```json
"PurchaseOrder": {
    "type": "Component",
    "name": "sap.fe.templates.ObjectPage",
    ...,
    "options": {
        "settings": {
            "content": {
                "header": {
                    "actions": {
                        "MyCustomAction": {
                            "text": "CustomActionText",
                            "press": ...
                            ...
                            "priority": "AlwaysOverflow"
                        }
                    }
                }
                ...
            },
            "controlConfiguration": {
                "@com.sap.vocabularies.UI.v1.FieldGroup#GeneralInformation": {
                    "actions": {
                        "MyFormAction": {
                            ...
                            "priority": "Low"
                        }
                    }
                },
                "_Elements/@com.sap.vocabularies.UI.v1.LineItem": {
                    "actions": {
                        "DataFieldForAction::sap.fe.core.ActionAllAreas.CopyAction::sap.fe.core.ActionAllAreas.SubElement": {
                            "priority": "{priorityValue}" // dynamic value from the "priorityValue" property
                        },
                        "TableCustomAction": {
                            ...
                            "priority": "NeverOverflow"
                        }
                    }
                }
            }
        }
    }
}
```

LANGUAGE: JSON (priority for standard actions)

CODE:
```json
"OrdersList": {
    "type": "Component",
    ...
    "options": {
        "settings": {
            "content": {
                "header": {
                    "actions": {
                        "EditAction": {
                            "priority": "{Priority}"
                        },
                        "DeleteAction": {
                            "priority": "AlwaysOverflow"
                        }
                    }
                }
            },
            "controlConfiguration": {
                "_Elements/@com.sap.vocabularies.UI.v1.LineItem": {
                    "actions": {
                        "StandardAction::Create": {
                           "priority": "AlwaysOverflow"
                        },
                        "StandardAction::Delete": {
                           "priority": "AlwaysOverflow"
                        }
                    }
                }
            }
        }
    }
}
```

STEP: Grouping Actions into Overflow Groups and Separators (manifest.json)

DESCRIPTION: Use overflowGroup to move actions together to overflow and overflowGroups to show separators before groups. overflowGroup must be an integer and all actions in a group must have same priority.

LANGUAGE: JSON

CODE:
```json
"actions": {
    "MyCustomAction1": {
        "text": "Approve",
        "priority": "Medium",
        "overflowGroup": 1
    },
    "MyCustomAction2": {
        "text": "Reject",
        "overflowGroup": 1
    },
    "MyCustomAction3": {
        "text": "Export",
        "overflowGroup": 2
    }
},
"overflowGroups": {
    "1": {
        "showSeparator": true
    },
    "2": {
        "showSeparator": true
    }
}
```

STEP: Overriding Annotation-Based Actions Using manifest.json and CustomActions.js

DESCRIPTION: Override annotation-based enabled/visible behavior in the manifest using keys like DataFieldForAction::... and wire handler functions in CustomActions.js to provide dynamic enablement/visibility.

LANGUAGE: JSON (manifest override example)

CODE:
```json
"controlConfiguration": {
    "@com.sap.vocabularies.UI.v1.LineItem": {
        "actions": {
            "DataFieldForAction::com.c_salesordermanage_sd.CreateWithSalesOrderType": {
                "enabled": "SalesOrder.ext.CustomActions.enabledIfTwoSelected"
                "visible": "SalesOrder.ext.CustomActions.visibleIfAConditionIsTrue"
            }
        }
    }
}
```

LANGUAGE: JavaScript (CustomActions.js)

CODE:
```
enabledIfTwoSelected: function (oBindingContext, aSelectedContexts) {
  return aSelectedContexts.length === 2;
},
visibleIfAConditionIsTrue: function (oBindingContext, aSelectedContexts) {
  // Condition returning a Boolean value
}
```

STEP: Overriding Annotation-Based Action Groups Using manifest.json (menu modification)

DESCRIPTION: Identify action group key as DataFieldForActionGroup::<ID>. Use DataFieldForAction::... and DataFieldForIntentBasedNavigation::SemanticObject::Action keys inside the manifest menu array to add/remove/override menu items.

LANGUAGE: XML (example of DataFieldForActionGroup and actions)

CODE:
```xml
<edmx:Reference Uri="https://sap.github.io/odata-vocabularies/vocabularies/UI.xml">
    <edmx:Include Namespace="com.sap.vocabularies.UI.v1" Alias="UI"/>
</edmx:Reference>

<Record Type="UI.DataFieldForActionGroup">
    <PropertyValue Property="Label" String="Action Group" />
    <PropertyValue Property="ID" String="groupedActions" />
    <PropertyValue Property="Actions">
        <Collection>
            <Record Type="UI.DataFieldForAction">
                <PropertyValue Property="Label" String="Action 1 inside Action Group" />
                <PropertyValue
                    Property="Action"
					String="com.c_salesordermanage_sd.SalesOrderManage.Action1"
                />
            </Record>
            <Record Type="UI.DataFieldForAction">
                <PropertyValue Property="Label" String="Action 2 inside Action Group" />
                <PropertyValue
                    Property="Action"
                    String="com.c_salesordermanage_sd.SalesOrderManage.Action2"
                />
            </Record>
            <Record Type="UI.DataFieldForAction">
                <PropertyValue Property="Label" String="Action 3 inside Action Group" />
                <PropertyValue
                    Property="Action"
                    String="com.c_salesordermanage_sd.SalesOrderManage.Action3"
                />
            </Record>
        </Collection>
    </PropertyValue>
</Record>
<Record Type="UI.DataFieldForAction">
    <PropertyValue Property="Label" String="Annotation Action outside action group" />
    <PropertyValue
        Property="Action"
        String="com.c_salesordermanage_sd.SalesOrderManage.AnnotationAction"
    />
</Record>
```

LANGUAGE: JSON (manifest sample: add new action to group)

CODE:
```json
"options": {
  "settings": {
   "contextPath": "/SalesOrderManage",
   "controlConfiguration": {
     "@com.sap.vocabularies.UI.v1.FieldGroup#OrderData": {
       "actions": {
         "myFirstAction": {
           "press": "SalesOrder.ext.CustomActions.getCustomerName",
           "visible": true,
           "enabled": true,
           "text": "My First Action"
         },
         "DataFieldForActionGroup::groupedActions": {
           "menu": [
             "DataFieldForAction::com.c_salesordermanage_sd.SalesOrderManage.Action1",
             "DataFieldForAction::com.c_salesordermanage_sd.SalesOrderManage.Action2",
             "DataFieldForAction::com.c_salesordermanage_sd.SalesOrderManage.Action3",
             "myFirstAction",
              "DataFieldForAction::com.c_salesordermanage_sd.SalesOrderManage.AnnotationAction"
            ]
         }
       }
     }
   }
  }
}
```

LANGUAGE: JSON (manifest sample: override menu items' enabled/visible)

CODE:
```json
"options": {
  "settings": {
   "contextPath": "/SalesOrderManage",
   "controlConfiguration": {
     "@com.sap.vocabularies.UI.v1.FieldGroup#OrderData": {
       "actions": {
         "DataFieldForAction::com.c_salesordermanage_sd.SalesOrderManage.Action1": {
           "enabled": false
         },
         "DataFieldForAction::com.c_salesordermanage_sd.SalesOrderManage.Action2": {
           "visible": false
         }
       }
     }
   }
  }
}
```

Step: Notes and Best Practices (short actionable bullets)

DESCRIPTION: Keep these practical rules for code generation and implementation:
- Use RequiresContext appropriately: set false for context-independent navigation and true when a specific row is required.
- For OData V4 actions, context is passed only if IsBound=true.
- Use InvocationGrouping to control batch changeset behavior (Isolated vs ChangeSet).
- Default values: ParameterDefaultValue > FLP user defaults > backend DefaultValuesFunction; frontend defaultValuesFunction overrides annotation/backend defaults.
- When overriding annotation-based enable/visible in manifest, annotation logic (like bound-enablement) is ignored — implement equivalent logic in your JS handlers if needed.
- For menu keys, use exact key formats: DataFieldForAction::..., DataFieldForIntentBasedNavigation::<SemanticObject>::<Action>, DataFieldForActionGroup::<ID>.

LANGUAGE: plain

CODE:
```
(No code — this is a best-practices summary for implementers.)
```

SAP Fiori
annotations
manifest.json
DataFieldForAction
DataFieldForIntentBasedNavigation
DefaultValuesFunction
OperationAvailable
CAP
ABAP CDS
OData V2
OData V4
action parameters
menus
priority
overflowGroup


**TITLE**: Actions in the List Report (Fiori Elements)

**INTRODUCTION**: This reference explains how to define and control actions in a Fiori Elements List Report. It covers global actions, table toolbar actions, generic vs. app-specific actions, standard actions (Create, Delete, Copy), and OData V2/V4 specifics for enabling Create via function imports and draft annotations. Use these snippets directly in your manifest.json, XML annotations, or CAP CDS files when implementing actions.

**TAGS**: fiori-elements, list-report, actions, annotations, manifest.json, OData, CAP, CDS, XML, JSON

STEP: Global Actions and Table Toolbar Actions
DESCRIPTION: Define global actions in the manifest.json or use extension points as application enhancements. Table toolbar actions include buttons for actions affecting the entire report or selected rows. Preserve image resources for documentation or UI reference: images/Actions_in_the_Table_Toolbar_856c5a4.png and images/Copy_Action_in_the_List_Report_f337b65.png.
LANGUAGE: Text
CODE:
```text
- Global actions: define in manifest.json via extension points. See: adding-custom-actions-using-extension-points-7619517.md
- Table toolbar actions: used for list-wide or selected-item operations. See: adding-actions-to-tables-b623e0b.md
- Reference images:
  - images/Actions_in_the_Table_Toolbar_856c5a4.png
  - images/Copy_Action_in_the_List_Report_f337b65.png
```

STEP: Generic vs Application-Specific Actions (Behavior & Types)
DESCRIPTION: Use generic actions (Create/Delete) when supported by the entity set. Define app-specific actions for custom logic. App-specific actions can be:
- Confirmation required: opens a confirmation dialog.
- Additional input required: opens a dialog with fields (e.g., approval comment).
- Immediate actions: triggers without dialog.
- External navigation: triggers navigation to external apps.
LANGUAGE: Text
CODE:
```text
- Generic actions: Create (if entity set creatable), Delete (if deletable).
- App-specific action types and expected UI behavior:
  - Confirmation dialog (user must confirm)
  - Input dialog (collect data, then execute)
  - Direct execution (no dialog)
  - External navigation (launch external app)
```

STEP: Standard Actions — Delete and Create (Overview)
DESCRIPTION: Delete and Create are standard actions. Delete is available if the entity set supports deletion. Create is enabled if the entity set is creatable or a NewAction is present (OData V2/V4 differences covered later). Configure Create behavior via DraftRoot annotations and manifest settings for newAction usage.
LANGUAGE: Text
CODE:
```text
- Delete action: render a Delete button in table toolbar when entity set is deletable. (See adding-actions-to-tables-b623e0b.md)
- Create action: default POST behavior, or configured to call a function import (newAction) for draft apps.
```

STEP: Copy Action — XML Annotation
DESCRIPTION: Define a standard Copy action by annotating UI.LineItem with UI.DataFieldForAction and setting UI.IsCopyAction. The button is placed automatically after Create. If no Label provided, default label is "Copy".
LANGUAGE: XML
CODE:
```xml
<Annotation Term="UI.LineItem">
  <Collection>
      <Record Type="UI.DataFieldForAction">
          <PropertyValue Property="Label" String="Copy" />
          <PropertyValue Property="Action" String="STTA_PROD_MAN.STTA_PROD_MAN_Entities/STTA_C_MP_ProductCopy" />
          <Annotation Term="UI.IsCopyAction" Bool="true" />
     </Record>
```

STEP: Copy Action — CAP CDS Annotation
DESCRIPTION: CAP/CDS style annotation equivalent to the XML annotation above. Use this in your CDS model to expose the Copy action to the List Report.
LANGUAGE: CDS
CODE:
```
UI.LineItem : [
    {
        $Type : 'UI.DataFieldForAction',
        Label : 'Copy',
        Action : 'STTA_PROD_MAN.STTA_PROD_MAN_Entities/STTA_C_MP_ProductCopy',
        ![@UI.IsCopyAction] : true,
    },
],
```

STEP: OData V2 — Enable Create Using newAction (DraftRoot + manifest.json)
DESCRIPTION: For draft-enabled OData V2 apps, set Common.DraftRoot NewAction to a function import and enable useNewActionForCreate in manifest.json settings to trigger that function import for Create. When the function import has parameters, use Common.Label on the function import to define the dialog title. Modify i18n keys for button/dialog text if needed.
LANGUAGE: XML
CODE:
```xml
<Annotation Term="Common.DraftRoot">
<Record>
<PropertyValue Property="NewAction"
    String="cds_zrc_ce_localized_srv.cds_zrc_ce_localized_srv_Entities/Create"/>
</Record>
</Annotation>
```

LANGUAGE: json
CODE:
```json
"ListReport|Localized": {
	"entitySet": "Localized",
	"component": {
	"name": "sap.suite.ui.generic.template.ListReport",
	"list": true,
	"settings": {
	"useNewActionForCreate": true
	}
},
```

LANGUAGE: XML
CODE:
```xml
<Annotations Target="SAP.FCLM_BAM_ACCOUNTWD_SRV_Entities/FunctionImportName">
<Annotation Term="Common.Label" String="Create"/>
</Annotations>
```

STEP: OData V4 — Create via DraftRoot NewAction (Annotation sample)
DESCRIPTION: For OData V4 draft-based apps the presence of NewAction in Common.DraftRoot enables the Create button. InsertRestrictions on the entity set are ignored; visibility/availability is controlled via OperationAvailable with rules below.
LANGUAGE: XML
CODE:
```xml
<Annotation Term="Common.DraftRoot">
<Record Type="Common.DraftRootType">
<PropertyValue Property="ActivationAction" String="com.c_salesordermanage_sd.draftActivate"/>
<PropertyValue Property="EditAction" String="com.c_salesordermanage_sd.draftEdit"/>
<PropertyValue Property="PreparationAction" String="com.c_salesordermanage_sd.draftPrepare"/>
<PropertyValue Property="NewAction" String="com.c_salesordermanage_sd.ReturnInProcess"/>
</Record>
</Annotation>
```

STEP: OData V4 — Create Button Visibility Logic
DESCRIPTION: Use OperationAvailable to control Create button visibility when NewAction is present:
- OperationAvailable=false => Create button NOT displayed.
- OperationAvailable=true or not specified => Create button displayed.
- OperationAvailable=null => treated as not specified (ignored).
LANGUAGE: Text
CODE:
```text
OperationAvailable rules for Create button when NewAction present:
- false => button not displayed
- true OR not specified => button displayed
- null => ignored (equivalent to not specified)
```

STEP: Create Mode Options (List Report Behavior)
DESCRIPTION: Supported create modes and their behavior in the List Report:
- Create page (default): navigates to an object page for entering object data; immutable properties for the new object may be shown in a dialog.
- Create dialog: opens a dialog within the list page for entering values and creating the object.
- External: navigates to an external Fiori Launchpad app to handle creation.
Adjust i18n keys to override dialog titles and button labels:
- DIALOG_TITLE_NEW_ACTION_FOR_CREATE (dialog title)
- CREATE_OBJECT (toolbar button label)
- DIALOG_ACTION_BUTTON_NEW_ACTION_FOR_CREATE (dialog action button text)
LANGUAGE: Text
CODE:
```text
Create modes:
- "Create page" (default): navigate to object page; optional dialog for immutable props.
- "Create dialog": in-place dialog in list report.
- "External": launch external FLP app for creation.

i18n keys to override texts:
- DIALOG_TITLE_NEW_ACTION_FOR_CREATE
- CREATE_OBJECT
- DIALOG_ACTION_BUTTON_NEW_ACTION_FOR_CREATE
```

fiori-elements list-report actions annotations manifest.json OData CAP CDS XML JSON


**TITLE**: Add Filter Price Button to the List Report Table Toolbar (Adaptation Extension)

**INTRODUCTION**: This guide shows how to add a toolbar button to a SAP Fiori elements List Report (OData V2) that filters the table to show records with Price >= 1000. It uses an adaptation fragment for the button and a controller extension that injects the filter through the templateBaseExtension.addFilters hook and triggers rebind via the extension API.

**TAGS**: fiori-elements-framework, adaptation-extension, sapui5, ui5, list-report, fragment, controller-extension, odata-v2

**STEP**: Prerequisites
**DESCRIPTION**: Confirm applicability and preconditions.
- This topic is only applicable to SAP Fiori elements for OData V2.
- You must have performed the steps described in "Extending Delivered Apps Using Adaptation Extensions".
**LANGUAGE**: Plaintext
**CODE**:
```plaintext
Applicable to SAP Fiori elements for OData V2.
Ensure you have completed: Extending Delivered Apps Using Adaptation Extensions.
```

**STEP**: Add a Fragment to the Table Toolbar
**DESCRIPTION**: Use the UI adaptation editor to add a fragment to the table toolbar.
- Select the table toolbar and choose Add Fragment.
- Set Target Aggregation = content and choose an index or Create New to create the fragment.
- Use fragment name: FilterPriceButton (example).
- The fragment contains a Button whose press handler points to the controller extension function using the .extension.<project>.<controller>.<function> notation.
  - .extension: required by UI adaptation tool guidelines
  - ProdMan.AdaptProject: replace with your project ID / namespace
  - ListReportExtension: controller extension file name
  - handleFilterPricePress: function name in controller extension
**LANGUAGE**: XML
**CODE**:
```xml
<core:FragmentDefinition xmlns:core='sap.ui.core' xmlns='sap.m'>
<Button id="PriceBtnID" text="Filter Price" press=".extension.ProdMan.AdaptProject.ListReportExtension.handleFilterPricePress"></Button>
</core:FragmentDefinition>
```

**STEP**: Create Controller Extension File
**DESCRIPTION**: Create a controller extension for the List Report and implement the button handler and the templateBaseExtension.addFilters extension point.
- In the adaptation editor: select the table toolbar and choose Extend with Controller.
- Name the controller: ListReportExtension (example). The system generates ListReportExtension.js.
- Place the code below into the generated ListReportExtension.js file. Keep custom functions outside the override block; consume extensibility functions (addFilters) inside the override.templateBaseExtension object.
- handleFilterPricePress sets a price restriction and triggers table rebind via oExtensionAPI.rebindTable().
- addFilters is called by the template to add extra filters; it uses this.iPriceRestriction to add a GE filter on the "Price" property.
**LANGUAGE**: JavaScript
**CODE**:
```javascript
/**
*@controller Name: sap.suite.ui.generic.template.ListReport.view.ListReport,
*@viewId:STTA_MP::sap.suite.ui.generic.template.ListReport.view.ListReport::STTA_C_MP_Product
*/
sap.ui.define(["sap/ui/core/mvc/Controller", "sap/ui/core/mvc/ControllerExtension"], function (Controller, ControllerExtension) {
return ControllerExtension.extend("ProdMan.AdaptProject.ListReportExtension", {

handleFilterPricePress : function() {
     this.iPriceRestriction = "1000";
     var oExtensionAPI = this.base.templateBaseExtension.getExtensionAPI();
     oExtensionAPI.rebindTable();
},
//override an existing method of the Main.controller
override: {
//adding a life cycle method
/**
* Called when a controller is instantiated and its View controls (if available) are already created.
* Can be used to modify the View before it is displayed, to bind event handlers and do other one-time initialization.
* @memberOf src.client.uiadaptation
*/
onInit: function () {
},
/**
* Similar to onAfterRendering, but this hook is invoked before the controller's View is re-rendered
* (NOT before the first rendering! onInit() is used for that one!).
* @memberOf src.client.uiadaptation
*/
onBeforeRendering: function () {
},
/**
* Called when the View has been rendered (so its HTML is part of the document). Post-rendering manipulations of the HTML could be done here.
* This hook is the same one that SAPUI5 controls get after being rendered.
* @memberOf src.client.uiadaptation
*/
onAfterRendering: function () {
},
/**
* Called when the Controller is destroyed. Use this one to free resources and finalize activities.
* @memberOf src.client.uiadaptation
*/
onExit: function () {
},
"templateBaseExtension": {
addFilters : function(fnAddFilter, sControlId){
if(this.iPriceRestriction){
fnAddFilter(this, new sap.ui.model.Filter("Price", "GE", this.iPriceRestriction));
}
}
}
}
});
});
```

**STEP**: Preview and Test
**DESCRIPTION**: Use the adaptation editor preview to test behavior.
- In the adaptation editor choose the Preview tab and click Go.
- Inspect the Price column values for all records.
- Click Filter Price (the new button). The table will rebind and show only records where Price >= 1000. Verify results in the Price column.
**LANGUAGE**: Plaintext
**CODE**:
```plaintext
Preview: Adaptation editor → Preview → Go
Verify: Click "Filter Price" and confirm only rows with Price >= 1000 are shown.
```


**TITLE**: Adapting Logic Before Save Operation (beforeSaveExtension)

**INTRODUCTION**: Implement the beforeSaveExtension extension API to run custom logic immediately before a save operation in SAP Fiori Elements. Return a Promise to pause the save until you explicitly resolve (continue save) or reject (cancel save). If no value is returned, the save proceeds without waiting for the extension.

**TAGS**: fiori-elements-framework, beforeSaveExtension, extension-api, SAPUI5, SAP Fiori, OData V2, OData V4, draft

**STEP**: 1 - Implement beforeSaveExtension in Object Page Controller (OData V2)

**DESCRIPTION**: Add the beforeSaveExtension method in your Object Page controller framework extensions. Return a Promise; resolve() to continue the save operation or reject() to cancel it. The method is called just before starting save operations. Include UI or other asynchronous logic inside the promise and call resolve/reject from the user actions or async results.

**LANGUAGE**: JavaScript

**CODE**:
```javascript
beforeSaveExtension: function () {
			var fnResolve, fnReject;
			var oPromise = new Promise(function (resolve, reject){
				fnResolve = resolve;
				fnReject = reject;
			});
			this.oDialog = new sap.m.Dialog({
				title: "BeforeSaveExtension",
				content: new sap.m.Text({
					text: "This is an example to check the beforeSaveExtension"
				}),
				beginButton: new sap.m.Button({
					text: "Continue to Save",
					press: function () {
						fnResolve();
						this.oDialog.close();
					}.bind(this)
				}),
				endButton: new sap.m.Button({
					text: "Cancel Save",
					press: function () {
						fnReject();
						this.oDialog.close();
					}.bind(this)
				})
			});
			this.getView().addDependent(this.oDialog);
			this.oDialog.open();
			return oPromise;
		}
```

**STEP**: 2 - Promise Behavior and Default Behavior When Not Returning a Promise

**DESCRIPTION**:
- If your beforeSaveExtension returns a Promise, the framework waits for it:
  - Resolving the Promise continues the save.
  - Rejecting the Promise cancels the save.
- If the extension does not return a value (no Promise), the save operation starts immediately without waiting for the extension to complete.

**LANGUAGE**: Text

**CODE**:
```
- return a Promise to pause save until resolved/rejected
- resolve() => continue save
- reject() => cancel save
- no return => save proceeds immediately without waiting
```

**STEP**: 3 - Draft vs Non-Draft Behavior (OData V2)

**DESCRIPTION**:
- Draft applications: beforeSaveExtension is called only once while saving the root object page.
- Non-draft applications: beforeSaveExtension is called for save operations from any object page.

**LANGUAGE**: Text

**CODE**:
```
Draft apps: called once for root object page save
Non-draft apps: called for saves from any object page
```

**STEP**: 4 - Additional References and OData V4 Note

**DESCRIPTION**:
- Demo Kit reference for the OData V2 API: detailed API docs and examples.
- For OData V4 and additional guidance about running custom code before standard operations, see the referenced documentation.

**LANGUAGE**: Text

**CODE**:
```
- Demo Kit beforeSaveExtension (OData V2): https://ui5.sap.com/#/api/sap.suite.ui.generic.template.ObjectPage.controllerFrameworkExtensions/methods/sap.suite.ui.generic.template.ObjectPage.controllerFrameworkExtensions.beforeSaveExtension
- Using Custom Code Before Standard Operations (OData V4): using-custom-code-before-standard-operations-877e5ff.md
```

fiori-elements-framework
beforeSaveExtension
extension-api
SAPUI5
SAP Fiori
OData V2
OData V4
draft


**TITLE**: Adapting Confirmation Dialog Texts for Deleting Table Lines (SAP Fiori Elements)

**INTRODUCTION**: Instructions for overriding the default confirmation and result texts shown when deleting rows/items in table controls on object pages. Covers both SAP Fiori Elements for OData V2 (entity-set scoped i18n keys) and OData V4 (specific allowed keys and manifest configuration). Use these patterns to add custom texts in your application's resource bundle (i18n) and to register the custom bundle in the manifest.

**TAGS**: fiori-elements-framework, i18n, localization, OData V2, OData V4, manifest, enhanceI18n, delete, confirmation

STEP: OData V2 — Key pattern and usage

DESCRIPTION: Provide custom delete/confirmation texts in the application's i18n file. Keys must follow this pattern:
- Without qualifier: <i18n_Key>|<EntitySet>|<navigationProperty>|com.sap.vocabularies.UI.v1.LineItem
- With qualifier: <i18n_Key>|<EntitySet>|<navigationProperty>|com.sap.vocabularies.UI.v1.LineItem|<qualifier>

Use the constructed key as the i18n entry key and set the desired text as the value. Example and allowed keys listed below.

LANGUAGE: properties

CODE:
```properties
# Example with navigation property and LineItem annotation (no qualifier):
DELETE_SELECTED_ITEM|STTA_C_MP_Product|to_ProductText|com.sap.vocabularies.UI.v1.LineItem=Delete this row?
```

CODE:
```properties
# Allowed default keys you can override in the app i18n file (OData V2)
DELETE_SELECTED_ITEM=Delete the selected item?
DELETE_SELECTED_ITEMS=Delete the selected items?
DELETE_SUCCESS_PLURAL_WITH_COUNT={0} items have been deleted.
DELETE_SUCCESS_WITH_COUNT={0} item has been deleted.
DELETE_ERROR_PLURAL_WITH_COUNT={0} items cannot be deleted.
DELETE_ERROR_WITH_COUNT={0} item cannot be deleted.
DELETE_ERROR_PLURAL=The selected items cannot be deleted.
DELETE_ERROR=The selected item cannot be deleted.
DELETE_SUCCESS_PLURAL=The selected items have been deleted.
ITEM_DELETED=Item deleted
DELETE_UNDELETABLE_ITEMS={0} of {1} items cannot be deleted.
```

STEP: OData V2 — Notes and parameter handling

DESCRIPTION: Maintain placeholder syntax ({0}, {1}) when overriding messages that contain counts or multiple dynamic parts. If the annotation uses a qualifier, append the qualifier to the key after the LineItem part. Keys are entity-set and navigation-property scoped.

LANGUAGE: text

CODE:
```text
# Example (qualifier appended):
<yourKey>|<EntitySet>|<navigationProperty>|com.sap.vocabularies.UI.v1.LineItem|<qualifier>=Your custom text
```

STEP: OData V4 — Allowed override keys

DESCRIPTION: For OData V4, only a specific set of keys may be overridden in the custom i18n file. Provide the key entries in the custom resource bundle to change confirmation and related messages for deleting objects.

LANGUAGE: properties

CODE:
```properties
# Allowed OData V4 keys you may override:
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR=Delete this object?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_CHANGES=Another user edited this object without saving the changes:{0} Delete anyway?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_CHANGES_MULTIPLE_OBJECTS=Other users have edited the selected objects without saving the changes. Delete anyway?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_PLURAL=Delete the selected objects?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_NON_DELETABLE={0} of {1} objects cannot be deleted.
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_LOCKED={0} of {1} objects are currently locked.
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_AND_FEW_OBJECTS_LOCKED_SINGULAR=The remaining object has unsaved changes. Do you still want to delete it?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_UNSAVED_AND_FEW_OBJECTS_LOCKED_PLURAL=The remaining objects have unsaved changes. Do you still want to delete them?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_UNSAVED_SINGULAR=Also delete object with unsaved changes?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_UNSAVED_PLURAL=Also delete objects with unsaved changes?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTINFO_AND_FEW_OBJECTS_LOCKED_AND_NON_DELETABLE={0} out of {2} objects cannot be deleted. {1} of {2} objects are currently locked.
```

STEP: OData V4 — Register custom resource bundle in manifest

DESCRIPTION: Add enhanceI18n (path to your custom resource bundle) under the target's options.settings in the application manifest. This tells Fiori Elements to load your custom i18n file in addition to the framework bundle.

LANGUAGE: JSON

CODE:
```json
"targets":{
   "SalesOrderManageList":{
      "type": "Component",
      "id": "SalesOrderManageList",
      "name": "sap.fe.templates.ListReport",
      "options":{
         "settings":{
            "contextPath": "/SalesOrderManage",
            "enhanceI18n": "i18n/customSalesOrderLR.properties", // This is the line to be added - it provides Fiori Elements with the name of the custom resource bundle
            .
            .
            .
         }
      }
   }
}
```

STEP: OData V4 — Example default vs custom entries (manifest + custom bundle)

DESCRIPTION: Default keys live in the Fiori Elements framework bundle. To customize for a specific entity set, append the entitySet name to the key in your custom resource bundle. Example below shows default framework entries and corresponding custom entries in i18n/customSalesOrderLR.properties.

LANGUAGE: properties

CODE:
```properties
# Default (Fiori Elements framework bundle):
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_PLURAL=Delete the selected objects?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR=Delete this object?

# Custom resource bundle (i18n/customSalesOrderLR.properties) with entitySet appended:
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_PLURAL|SalesOrderManage=Do you want to delete the selected Sales Orders?
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR|SalesOrderManage=Do you want to delete this Sales Order?
```

STEP: Format of custom keys — shared vs entity-scoped vs action-scoped

DESCRIPTION: Rules for naming custom keys:
- Global/shared resource (no entity set appended): do not append anything. This overrides the framework text everywhere.
- Entity-specific resource: append the entitySet (prefixed by '|' or '|_EntitySet' depending on examples) to scope the text to that entity.
- Action-specific override: append entitySet and action name to override confirmation text for a specific action on a specific entity set. Entity set name is mandatory for action-scoped overrides.

LANGUAGE: properties

CODE:
```properties
# Shared resource override (applies globally if you want same text everywhere)
C_COMMON_DIALOG_OK=Okie?   # overrides framework global OK text

# Entity-scoped override (different text per entity)
C_TRANSACTION_HELPER_OBJECT_PAGE_CONFIRM_DELETE_WITH_OBJECTTITLE_SINGULAR|_Items=Do you want to delete this Sales Order Item?

# Action-scoped override (entity set + action name required)
C_OPERATIONS_ACTION_CONFIRM_MESSAGE|SalesOrderManage|ReturnInProcess=Can you please confirm if you really want to trigger the returns?

# Alternate example: action same name, different entity set
C_OPERATIONS_ACTION_CONFIRM_MESSAGE|_Items|ReturnInProcess=Can you please confirm if you really want to trigger the returns for the chosen items?
```

STEP: Practical notes and placeholders

DESCRIPTION: When overriding messages:
- Preserve placeholders exactly: {0}, {1}, etc.
- If you omit an entity-scoped key for an action, the framework fallback is used.
- For LineItem annotation overrides in OData V2, include navigationProperty and optional qualifier as shown in the key pattern.

LANGUAGE: text

CODE:
```text
# Examples of placeholder usage:
DELETE_SUCCESS_PLURAL_WITH_COUNT={0} items have been deleted.
DELETE_UNDELETABLE_ITEMS={0} of {1} items cannot be deleted.
```

fiori-elements-framework
i18n
localization
OData V2
OData V4
manifest
enhanceI18n
delete
confirmation