> For the complete documentation index, see [llms.txt](https://docs.middle.app/middle-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.middle.app/middle-docs/product/accounts/workflow-parameters/special.md).

# Special

Controls to delete, move, and duplicate parameters. These are editing commands, not parameter types. Their `special__...` keys identify choices in the editor; they do not appear as a parameter's `type` in copied workflow JSON. A copied workflow contains the resulting parameter tree.

A parent contains its children in `params`. Parameters in the same `params` list are siblings. Moving a parameter moves its children with it. Changing their order can change the result: child order controls formula inputs, comparison sides, and array operations.

The examples below show complete parameter trees before and after an edit. New parameters start unconfigured; the insertion examples show them after you choose a type and fill in a value.

## Move Child Back

Editor key: `special__moveBackward`.

Move a parameter and all its children up one position among its siblings. For example, selecting `"Pilates"` in this array and moving it back changes the array from `["Yoga", "Pilates"]` to `["Pilates", "Yoga"]`.

Before:

```json
{
  "type": "construct_array",
  "params": [
    {"type": "template", "expression": "Yoga"},
    {"type": "template", "expression": "Pilates"}
  ]
}
```

After:

```json
{
  "type": "construct_array",
  "params": [
    {"type": "template", "expression": "Pilates"},
    {"type": "template", "expression": "Yoga"}
  ]
}
```

## Move Child Forward

Editor key: `special__moveForward`.

Move a parameter and all its children down one position among its siblings. Using the first example above, selecting `"Yoga"` and moving it forward produces the same reordered JSON. Moving applies to child parameters; the root parameter has no siblings to move between.

## Insert Sibling Node Parameter Before

Editor key: `special__insertSiblingBefore`.

Insert a new parameter above the selected parameter, at the same level. Its parent stays the same. For example, inserting before `"Yoga"` and configuring the new parameter as Text with `"Cycling"` changes this:

```json
{
  "type": "construct_array",
  "params": [
    {"type": "template", "expression": "Yoga"}
  ]
}
```

To this:

```json
{
  "type": "construct_array",
  "params": [
    {"type": "template", "expression": "Cycling"},
    {"type": "template", "expression": "Yoga"}
  ]
}
```

## Insert Sibling Node Parameter After

Editor key: `special__insertSiblingAfter`.

Insert a new parameter below the selected parameter, at the same level. Using the same starting example, inserting after `"Yoga"` and setting the new text to `"Cycling"` produces this:

```json
{
  "type": "construct_array",
  "params": [
    {"type": "template", "expression": "Yoga"},
    {"type": "template", "expression": "Cycling"}
  ]
}
```

Sibling insertion needs a parent. It cannot add a sibling alongside the root parameter.

## Duplicate to Sibling Node Parameter Before

Editor key: `special__copyToSiblingBefore`.

Copy the selected parameter and all its children, placing the copy immediately before the original. The copy starts with the same type, expression, property selections, and children. Editing it afterward does not edit the original.

For example, duplicating the Text parameter below inserts another complete `"Class: {}"` parameter with its own `"Yoga"` child.

Before:

```json
{
  "type": "construct_array",
  "params": [
    {
      "type": "template",
      "expression": "Class: {}",
      "params": [{"type": "template", "expression": "Yoga"}]
    }
  ]
}
```

After:

```json
{
  "type": "construct_array",
  "params": [
    {
      "type": "template",
      "expression": "Class: {}",
      "params": [{"type": "template", "expression": "Yoga"}]
    },
    {
      "type": "template",
      "expression": "Class: {}",
      "params": [{"type": "template", "expression": "Yoga"}]
    }
  ]
}
```

## Duplicate to Sibling Node Parameter After

Editor key: `special__copyToSiblingAfter`.

Copy the selected parameter and all its children, placing the copy immediately after the original. The resulting JSON initially looks the same as the duplication example above because the two subtrees are identical. Both duplication commands need a parent; they do not duplicate the root parameter.

## Insert Parent Node Parameter Above

Editor key: `special__insertAbove`.

Insert a new parent around the selected parameter. The selected parameter becomes the new parent's first child and keeps its own children. This is useful when you want to apply a transformation to an existing value.

For example, insert a parent above this text, then choose Uppercase for the new parent:

```json
{"type": "template", "expression": "Yoga"}
```

The result is:

```json
{
  "type": "upper",
  "params": [{"type": "template", "expression": "Yoga"}]
}
```

This parameter returns `"YOGA"`.

## Delete

Editor key: `special__delete`.

Delete the selected parameter while keeping its children. The children move into the deleted parameter's position in its parent's `params` list. For example, deleting the Uppercase parameter above leaves its Text child:

```json
{"type": "template", "expression": "Yoga"}
```

There are a few limits to keeping children. A root parameter can be replaced by one child, but Middle cannot promote several children into that single root position. Within Construct Object, only the first child is kept and it takes the deleted field's `key`; other children are removed. Within an If comparison, deleting the left operand also removes the right operand. Check the remaining parameter after deletion, since its required inputs or their order may have changed.

## Delete this and all its children

Editor key: `special__deleteFull`.

Delete the selected parameter and the entire subtree below it. For example, deleting the Uppercase child from this array also deletes its nested Text child:

```json
{
  "type": "construct_array",
  "params": [
    {
      "type": "upper",
      "params": [{"type": "template", "expression": "Yoga"}]
    },
    {"type": "template", "expression": "Pilates"}
  ]
}
```

The remaining tree is:

```json
{
  "type": "construct_array",
  "params": [{"type": "template", "expression": "Pilates"}]
}
```

Deleting the root removes that entire parameter. As with Delete, removing the left operand of an If comparison also removes its right operand.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.middle.app/middle-docs/product/accounts/workflow-parameters/special.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
