docs: add a "key concepts" page for updateTypes

[jamietanna]

To have a central, user-friendly, view of what each update type is and what it's useful.

Then, this can link out to in-depth pages (#40777) if necessary

[jamietanna]

Potential starting point:

Claude Opus 4.8

---
title: Update types
description: Learn what Renovate's update types are, how they're decided, and how to use them
---

# Update types

Whenever Renovate finds an update for a dependency, it assigns that update an **update type**, such as `major`, `minor`, or `digest`.
The update type is a label that describes _what kind_ of update it is.

Renovate uses the update type for two main things:

1. **Targeting configuration** — you can apply different settings to different kinds of updates (for example, automerge `patch` updates but not `major` ones).
1. **Splitting updates into branches/PRs** — Renovate decides how many separate branches/PRs to create partly based on the update types it found.

This page explains the available update types, how Renovate decides them, and how you can use them in your config.

## The update types

Most update types can be used in configuration.
A few are used internally by Renovate and are listed separately below.

### Configurable update types

You can set configuration for these update types (for example `"minor": { "automerge": true }`) and match them with [`matchUpdateTypes`](../configuration-options.md#matchupdatetypes) inside [`packageRules`](../configuration-options.md#packagerules).

| Update type          | What it means                                                                | When you'll see it                                                                                          |
| -------------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `major`              | A major version increase, e.g. `1.2.3` → `2.0.0`.                            | A new major version is available.                                                                           |
| `minor`              | A minor version increase, e.g. `1.2.3` → `1.3.0`.                            | A new minor version is available.                                                                           |
| `patch`              | A patch version increase, e.g. `1.2.3` → `1.2.4`.                            | A new patch version is available.                                                                           |
| `pin`                | Pinning an existing range to an exact version, e.g. `^1.2.3` → `1.2.3`.      | You use, or opt in to, [`rangeStrategy: pin`](../configuration-options.md#rangestrategy).                   |
| `digest`             | The digest changed, but the tag/version did not, e.g. a Docker image digest. | A pinned digest has a newer value for the same tag.                                                         |
| `pinDigest`          | Adding a digest to a currently-unpinned tag.                                 | You use a preset like [`helpers:pinGitHubActionDigests`](../presets-helpers.md#pingithubactiondigests), or enable [`pinDigests`](../configuration-options.md#pindigests). |
| `rollback`           | Going _back_ to an older version.                                            | Your current version can no longer be found in the registry, and [`rollbackPrs`](../configuration-options.md#rollbackprs) is enabled. |
| `replacement`        | Swapping a dependency for a different name or registry.                       | A [replacement](../configuration-options.md#replacement) rule or preset matches the dependency.            |
| `lockFileMaintenance` | Refreshing the whole lock file, without any change to the package file.      | You enable [`lockFileMaintenance`](../configuration-options.md#lockfilemaintenance).                        |

### Internal update types

These values exist but can't be configured directly with a config object:

| Update type      | What it means                                                                                                              |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------- |
| `bump`           | Bumping an in-range range so the constraint matches the new version, e.g. `^1.2.3` → `^1.2.4`, when using [`rangeStrategy: bump`](../configuration-options.md#rangestrategy). |
| `lockfileUpdate` | An in-range update that only changes the lock file, not the package file.                                                 |

!!! note
    `bump` is special: you _can_ use it inside `matchUpdateTypes`, but it doesn't replace the semver type.
    A bump of `^1.2.3` → `^1.2.4` is still a `patch` update _and_ a `bump`, so both values match.

## How Renovate decides the update type

The update type is not a single fixed property of a version — it depends on the context of the update:

- **`major` / `minor` / `patch`** are decided by the [versioning](../modules/versioning/index.md) module by comparing the current and new versions.
  Because each ecosystem has its own versioning rules, the same version jump can be classified differently across managers (for example `docker` versioning behaves differently to `semver`).
- **`pin` and `bump`** come from your [`rangeStrategy`](../configuration-options.md#rangestrategy).
- **`digest` and `pinDigest`** come from digest handling for datasources that support digests (such as Docker or GitHub Actions).
- **`rollback`** is used when your current version can no longer be found in the registry.
- **`replacement`** comes from replacement rules and presets.
- **`lockFileMaintenance`** is a scheduled maintenance task rather than a response to a new version.

## Using update types in your config

There are two ways to apply configuration based on update type.

### Config object form

Each configurable update type is also a configuration object.
Anything you put inside it applies only to updates of that type:

```json
{
  "patch": {
    "automerge": true
  },
  "major": {
    "dependencyDashboardApproval": true
  }
}
```

### `matchUpdateTypes` in `packageRules`

Use [`matchUpdateTypes`](../configuration-options.md#matchupdatetypes) when you want to combine the update type with other matchers (such as a manager or package name):

```json
{
  "packageRules": [
    {
      "matchManagers": ["npm"],
      "matchUpdateTypes": ["patch", "digest"],
      "automerge": true
    }
  ]
}
```

## Update types vs. separate branches/PRs

A common point of confusion is that the update type alone does _not_ decide how many PRs you get.
Renovate first works out the update types that are available, then a set of `separate*` options decides how to split them into branches/PRs:

- [`separateMajorMinor`](../configuration-options.md#separatemajorminor) (default `true`) — keep `major` updates in a separate PR from `minor`/`patch`.
- [`separateMultipleMajor`](../configuration-options.md#separatemultiplemajor) — get one PR _per_ major version (e.g. `v2` and `v3`) instead of jumping straight to the newest major.
- [`separateMinorPatch`](../configuration-options.md#separateminorpatch) (default `false`) — split `patch` updates out from `minor` updates.
- [`separateMultipleMinor`](../configuration-options.md#separatemultipleminor) — get one PR per minor version stream (e.g. `3.9.x`, `3.10.x`).

For example, if you're on `1.0.0` and both `1.0.1` (patch) and `1.1.0` (minor) are available, then with the defaults Renovate creates a single PR for `1.1.0`.
Set `separateMinorPatch` to `true` to get two PRs instead — which is handy if you want to automerge `patch` but manually review `minor`.

!!! tip
    `separateMajorMinor` and `separateMultipleMajor` take priority over grouping.
    If you group packages but still get separate `major` PRs, that's why — see [`separateMajorMinor`](../configuration-options.md#separatemajorminor) for how to force grouping.

Here's how a found update flows from a raw version comparison to a PR:

```mermaid
flowchart TD
    FOUND[Renovate finds a newer version]
    TYPE{Determine update type}
    RANGE[rangeStrategy?<br>pin / bump]
    SEMVER[versioning module<br>major / minor / patch]
    DIGEST[digest / pinDigest]
    OTHER[rollback / replacement /<br>lockFileMaintenance]

    SEP{separate* options}
    GROUP{packageRules / groups}
    PR[Branch and PR created]

    FOUND --> TYPE
    TYPE --> RANGE
    TYPE --> SEMVER
    TYPE --> DIGEST
    TYPE --> OTHER

    RANGE --> SEP
    SEMVER --> SEP
    DIGEST --> SEP
    OTHER --> SEP

    SEP --> GROUP
    GROUP --> PR
```

## What update types are _not_

Two things are commonly assumed to be part of the update type, but are decided separately:

- **Stability / pre-releases.**
  An update to a release candidate or other unstable version is still classified as `major`/`minor`/`patch` based on its version number.
  Whether Renovate proposes unstable versions at all is controlled by the [versioning](../modules/versioning/index.md) module, together with [`ignoreUnstable`](../configuration-options.md#ignoreunstable) and [`respectLatest`](../configuration-options.md#respectlatest).
- **Whether an update is "breaking".**
  A non-`major` update can still be breaking (for example, bumping a minimum language version).
  Renovate has a separate concept, `isBreaking`, which is decided independently of the update type — see [versioning](../modules/versioning/index.md#breaking-changes).

## Update types in templates

Renovate exposes boolean flags for the update type so you can use them in [templates](../templates.md), for example in commit messages and PR bodies:

- `isMajor`, `isMinor`, `isPatch`
- `isPin`, `isPinDigest`
- `isRollback`, `isReplacement`
- `isLockfileUpdate`
- `isRange`, `isSingleVersion`

For example:

```
{{#if isMajor}}Major update — check the changelog before merging.{{/if}}
```

See [templates](../templates.md) for the full list of available fields.

## Relevant configuration options

- [`matchUpdateTypes`](../configuration-options.md#matchupdatetypes) — match specific update types inside `packageRules`.
- [`major`](../configuration-options.md#major), [`minor`](../configuration-options.md#minor), [`patch`](../configuration-options.md#patch) — configuration for semver update types.
- [`pin`](../configuration-options.md#pin), [`pinDigest`](../configuration-options.md#pindigest), [`digest`](../configuration-options.md#digest) — configuration for pinning and digest updates.
- [`rollback`](../configuration-options.md#rollback), [`replacement`](../configuration-options.md#replacement), [`lockFileMaintenance`](../configuration-options.md#lockfilemaintenance) — configuration for the remaining update types.
- [`separateMajorMinor`](../configuration-options.md#separatemajorminor), [`separateMultipleMajor`](../configuration-options.md#separatemultiplemajor), [`separateMinorPatch`](../configuration-options.md#separateminorpatch), [`separateMultipleMinor`](../configuration-options.md#separatemultipleminor) — control how update types are split into branches/PRs.
- [`rangeStrategy`](../configuration-options.md#rangestrategy) — influences whether you get `pin` and `bump` updates.