# Introduction

Learn the key concepts about content definitions.

A content definition is a structured JSON format that specifies the actual values for the attributes defined in a [Schema](/reference/content/schema/introduction).

## Content types

For each content schema, there is an associated content type that defines its value.

These content types are:

- **Number**: Numeric values, such as prices, quantities, and percentages.
- **Boolean**: True or false values, such as on/off or yes/no switches.
- **Text**: Textual values, such as titles, descriptions, and paragraphs.
- **List**: Collections of items such as lists of tags, images, or products.
- **Structure**: A group of attributes, such as a button's label and link.

> **Question: What about other schema types?**
>
> The other schema types not listed here are based on these basic types.
>
> For example, the union schema allows multiple structure variations, so when you define content for a union schema, you are essentially working with structures. The same principle applies to reference and file schemas.

For more information on each content type, see [Content types](/reference/content/definition/types).

## Dynamic values

As a personalization platform, we go beyond static content.

You can use [CQL expressions](/reference/cql/expressions/basics) to define dynamic content based on the user's context, such as their profile, location, or device.

See [Placeholders](/reference/content/definition/placeholders#dynamic-values) for more information.

## Constraints

To ensure optimal performance, we enforce some constraints on the content. While the [schema constraints](/reference/content/schema/introduction#constraints) are based on the structure, the content constraints are based on the actual values.

These constraints include:

- Up to 30 items in a list
- Up to 10 dynamic values
- Maximum complexity score of 50.

> **Deep dive: What is a complexity score?**
>
> The complexity score tells how complex a content is based on the number of entries it contains.
>
> To calculate the score, start with 0 and then add up the complexity of the content as follows:
>
> - **Structures**: Count 1 for the structure itself, and add the complexity of its attributes.
> - **Lists**: Count 1 for the list itself, plus the complexity of each item in the list.
> - **Primitives**: Count 1 for each primitive type.
>
> Let's apply this to the following example:
>
> ```pmsjson
> {
>   "type": "structure",
>   "attributes": {
>     "heading": {
>       "type": "text",
>       "value": {
>         "type": "static",
>         "value": "Sign up for free"
>       }
>     },
>     "subheading": {
>       "type": "text",
>       "value": {
>         "type": "static",
>         "value": "It only takes a few seconds."
>       }
>     },
>     "features": {
>       "type": "list",
>       "items": [
>         {
>           "type": "text",
>           "value": {
>             "type": "static",
>             "value": "Unlimited projects"
>           }
>         },
>         {
>           "type": "text",
>           "value": {
>             "type": "static",
>             "value": "Unlimited users"
>           }
>         }
>       ]
>     }
>   }
> }
> ```
>
> Based on the rules above, we can calculate the complexity as follows:
>
> - Count 1 for the structure itself
> - Count 3 for the attributes
> - Count 2 for the items in the list.
>
> That gives us a **complexity score of 6**.

## Explore

- [Content types](/reference/content/definition/types): Explore the different types available to define your content.
- [Schema reference](/reference/content/schema/introduction): Learn how to define the structure of your content.