> Markdown version of [Details](https://vaadin.com/docs/v23/components/details). Section index: [llms.txt](https://vaadin.com/docs/v23/components/llms.txt)

# Details

Details is an expandable panel for showing and hiding content from the user, to make the UI less cluttered.

**TypeScript** — `details-basic.ts`

```typescript
@customElement('details-basic')
export class Example extends LitElement {
  protected override createRenderRoot() {
    const root = super.createRenderRoot();
    // Apply custom theme (only supported if your app uses one)
    applyTheme(root);
    return root;
  }

  protected override render() {
    return html`
      <vaadin-details opened>
        <div slot="summary">Contact information</div>

        <vaadin-vertical-layout>
          <span>Sophia Williams</span>
          <span>sophia.williams@company.com</span>
          <span>(501) 555-9128</span>
        </vaadin-vertical-layout>
      </vaadin-details>
    `;
  }
}
```

**Java** — `DetailsBasic.java`

```java
Span name = new Span("Sophia Williams");
Span email = new Span("sophia.williams@company.com");
Span phone = new Span("(501) 555-9128");

VerticalLayout content = new VerticalLayout(name, email, phone);
content.setSpacing(false);
content.setPadding(false);

Details details = new Details("Contact information", content);
details.setOpened(true);

add(details);
```

## <a id="anatomy"></a>Anatomy

Details consists of a summary area and a content area.

### <a id="summary"></a>Summary

The Summary is the part that’s always visible, and typically describes the contents, for example with a title. Clicking on the summary toggles the content area’s visibility.

The summary supports rich content and can contain any component. This can be used, for example, to display the status of the corresponding content.

**TypeScript** — `details-summary.ts`

```typescript
@customElement('details-summary')
export class Example extends LitElement {
  protected override createRenderRoot() {
    const root = super.createRenderRoot();
    // Apply custom theme (only supported if your app uses one)
    applyTheme(root);
    return root;
  }

  @state()
  private items: Country[] = [];

  @state()
  private responsiveSteps: FormLayoutResponsiveStep[] = [
    { minWidth: 0, columns: 1 },
    { minWidth: '20em', columns: 2 },
  ];

  protected override async firstUpdated() {
    this.items = await getCountries();
  }

  protected override render() {
    return html`
      <vaadin-details opened>
        <vaadin-horizontal-layout
          slot="summary"
          style="justify-content: space-between; width: 100%;"
        >
          <span>Contact information</span>

          <vaadin-horizontal-layout
            style="color: var(--lumo-error-text-color); margin-left: var(--lumo-space-s)"
          >
            <vaadin-icon
              icon="vaadin:exclamation-circle"
              style="width: var(--lumo-icon-size-s); height: var(--lumo-icon-size-s);"
            ></vaadin-icon>
            <span>2 errors</span>
          </vaadin-horizontal-layout>
        </vaadin-horizontal-layout>

        <vaadin-form-layout .responsiveSteps="${this.responsiveSteps}">
          <vaadin-text-field
            label="Address"
            value="4027 Amber Lake Canyon"
            colspan="2"
          ></vaadin-text-field>

          <vaadin-text-field label="ZIP code" required></vaadin-text-field>

          <vaadin-text-field label="City" required></vaadin-text-field>

          <vaadin-combo-box
            label="Country"
            item-label-path="name"
            item-value-path="id"
            .items="${this.items}"
          ></vaadin-combo-box>
        </vaadin-form-layout>
      </vaadin-details>
    `;
  }
}
```

**TypeScript** — `Country.ts`

```typescript
/**
 * This module is generated from com.vaadin.demo.domain.Country.
 * All changes to this file are overridden. Consider editing the corresponding Java file if necessary.
 * @see {@link file:///srv/jenkins/workspace/docs/docs-site-v23/docs/src/main/java/com/vaadin/demo/domain/Country.java}
 */
export default interface Country {
  name: string;
  abbreviation: string;
  id: number;
}
```

**Java** — `DetailsSummary.java`

```java
HorizontalLayout summary = new HorizontalLayout();
summary.setSpacing(false);

Icon icon = VaadinIcon.EXCLAMATION_CIRCLE.create();
icon.getStyle().set("width", "var(--lumo-icon-size-s)");
icon.getStyle().set("height", "var(--lumo-icon-size-s)");

HorizontalLayout errorBadge = new HorizontalLayout(icon,
        new Span(" 2 errors"));
errorBadge.setSpacing(false);
errorBadge.getStyle().set("color", "var(--lumo-error-text-color)");
errorBadge.getStyle().set("margin-left", "var(--lumo-space-s)");

summary.add(new Text("Contact information"), errorBadge);

FormLayout content = new FormLayout();
content.setResponsiveSteps(new FormLayout.ResponsiveStep("0", 1),
        new FormLayout.ResponsiveStep("20em", 2));

TextField address = new TextField("Address");
address.setValue("4027 Amber Lake Canyon");
content.add(address, 2);

TextField zipCode = new TextField("ZIP code");
zipCode.setRequired(true);
content.add(zipCode);

TextField city = new TextField("City");
city.setRequired(true);
content.add(city);

ComboBox<Country> countries = new ComboBox<>("Country");
countries.setItems(DataService.getCountries());
countries.setItemLabelGenerator(Country::getName);
content.add(countries);

Details details = new Details(summary, content);
details.setOpened(true);

add(details);
```

### <a id="content"></a>Content

This is the collapsible part of Details. It can contain any component. When the content area is collapsed, the content is invisible and inaccessible by keyboard or screen reader.

**TypeScript** — `details-content.ts`

```typescript
@customElement('details-content')
export class Example extends LitElement {
  static override styles = css`
    a {
      text-decoration: none;
      color: var(--lumo-primary-text-color);
    }
  `;

  protected override createRenderRoot() {
    const root = super.createRenderRoot();
    // Apply custom theme (only supported if your app uses one)
    applyTheme(root);
    return root;
  }

  protected override render() {
    return html`
      <vaadin-details opened>
        <div slot="summary">Analytics</div>

        <vaadin-vertical-layout>
          <a href="#">Dashboard</a>
          <a href="#">Reports</a>
          <a href="#">Data sources</a>
        </vaadin-vertical-layout>
      </vaadin-details>

      <vaadin-details opened>
        <div slot="summary">Customers</div>

        <vaadin-vertical-layout>
          <a href="#">Accounts</a>
          <a href="#">Contacts</a>
        </vaadin-vertical-layout>
      </vaadin-details>

      <vaadin-details opened>
        <div slot="summary">Finances</div>

        <vaadin-vertical-layout>
          <a href="#">Invoices</a>
          <a href="#">Transactions</a>
          <a href="#">Statements</a>
        </vaadin-vertical-layout>
      </vaadin-details>
    `;
  }
}
```

**Java** — `DetailsContent.java`

```java
Details analyticsDetails = createDetails("Analytics",
        createStyledAnchor("#", "Dashboard"),
        createStyledAnchor("#", "Reports"),
        createStyledAnchor("#", "Data sources"));

Details customersDetails = createDetails("Customers",
        createStyledAnchor("#", "Accounts"),
        createStyledAnchor("#", "Contacts"));

Details financesDetails = createDetails("Finances",
        createStyledAnchor("#", "Invoices"),
        createStyledAnchor("#", "Transactions"),
        createStyledAnchor("#", "Statements"));

add(analyticsDetails, customersDetails, financesDetails);
```

## <a id="theme-variants"></a>Theme Variants

Details has three theme variants: `filled`, `small`, and `reverse`. Theme variants can be combined with each other. For example, all three themes variants can be applied to the same Details component.

### <a id="filled"></a>Filled

The `filled` theme variant makes the component’s boundaries visible, which helps tie its content together visually and distinguishes it from the surrounding UI.

**TypeScript** — `details-filled.ts`

```typescript
@customElement('details-filled')
export class Example extends LitElement {
  protected override createRenderRoot() {
    const root = super.createRenderRoot();
    // Apply custom theme (only supported if your app uses one)
    applyTheme(root);
    return root;
  }

  protected override render() {
    return html`
      <vaadin-details opened theme="filled">
        <div slot="summary">Members (8)</div>

        <ul>
          <li>Blake Martin</li>
          <li>Caroline Clark</li>
          <li>Avery Torres</li>
          <li>Khloe Scott</li>
          <li>Camila Fisher</li>
          <li>Gavin Lewis</li>
          <li>Isabella Powell</li>
          <li>Zoe Wilson</li>
        </ul>
      </vaadin-details>
    `;
  }
}
```

**Java** — `DetailsFilled.java`

```java
UnorderedList content = new UnorderedList(new ListItem("Blake Martin"),
        new ListItem("Caroline Clark"), new ListItem("Avery Torres"),
        new ListItem("Khloe Scott"), new ListItem("Camila Fisher"),
        new ListItem("Gavin Lewis"), new ListItem("Isabella Powell"),
        new ListItem("Zoe Wilson"));

Details details = new Details("Members (8)", content);
details.setOpened(true);
details.addThemeVariants(DetailsVariant.FILLED);

add(details);
```

### <a id="small"></a>Small

Use the `small` theme variant for compact UIs.

**TypeScript** — `details-small.ts`

```typescript
@customElement('details-small')
export class Example extends LitElement {
  protected override createRenderRoot() {
    const root = super.createRenderRoot();
    // Apply custom theme (only supported if your app uses one)
    applyTheme(root);
    return root;
  }

  protected override render() {
    return html`
      <vaadin-details opened theme="small">
        <div slot="summary">Members (8)</div>

        <ul>
          <li>Blake Martin</li>
          <li>Caroline Clark</li>
          <li>Avery Torres</li>
          <li>Khloe Scott</li>
          <li>Camila Fisher</li>
          <li>Gavin Lewis</li>
          <li>Isabella Powell</li>
          <li>Zoe Wilson</li>
        </ul>
      </vaadin-details>
    `;
  }
}
```

**Java** — `DetailsSmall.java`

```java
UnorderedList content = new UnorderedList(new ListItem("Blake Martin"),
        new ListItem("Caroline Clark"), new ListItem("Avery Torres"),
        new ListItem("Khloe Scott"), new ListItem("Camila Fisher"),
        new ListItem("Gavin Lewis"), new ListItem("Isabella Powell"),
        new ListItem("Zoe Wilson"));

Details details = new Details("Members (8)", content);
details.setOpened(true);
details.addThemeVariants(DetailsVariant.SMALL);

add(details);
```

### <a id="reverse"></a>Reverse

The reverse theme variant places the toggle icon after the summary contents, which can be useful for visually aligning the summary with other content.

**TypeScript** — `details-reverse.ts`

```typescript
@customElement('details-reverse')
export class Example extends LitElement {
  protected override createRenderRoot() {
    const root = super.createRenderRoot();
    // Apply custom theme (only supported if your app uses one)
    applyTheme(root);
    return root;
  }

  protected override render() {
    return html`
      <vaadin-details opened theme="reverse">
        <div slot="summary">Members (8)</div>

        <ul>
          <li>Blake Martin</li>
          <li>Caroline Clark</li>
          <li>Avery Torres</li>
          <li>Khloe Scott</li>
          <li>Camila Fisher</li>
          <li>Gavin Lewis</li>
          <li>Isabella Powell</li>
          <li>Zoe Wilson</li>
        </ul>
      </vaadin-details>
    `;
  }
}
```

**Java** — `DetailsReverse.java`

```java
UnorderedList content = new UnorderedList(new ListItem("Blake Martin"),
        new ListItem("Caroline Clark"), new ListItem("Avery Torres"),
        new ListItem("Khloe Scott"), new ListItem("Camila Fisher"),
        new ListItem("Gavin Lewis"), new ListItem("Isabella Powell"),
        new ListItem("Zoe Wilson"));

Details details = new Details("Members (8)", content);
details.setOpened(true);
details.addThemeVariants(DetailsVariant.REVERSE);

add(details);
```

### <a id="disabled"></a>Disabled

Details can be disabled to prevent them from being expanded or collapsed. Components inside a disabled expanded Details are automatically disabled as well.

**TypeScript** — `details-disabled.ts`

```typescript
@customElement('details-disabled')
export class Example extends LitElement {
  protected override createRenderRoot() {
    const root = super.createRenderRoot();
    // Apply custom theme (only supported if your app uses one)
    applyTheme(root);
    return root;
  }

  protected override render() {
    return html`
      <vaadin-details disabled>
        <div slot="summary">Members (8)</div>

        <ul>
          <li>Blake Martin</li>
          <li>Caroline Clark</li>
          <li>Avery Torres</li>
          <li>Khloe Scott</li>
          <li>Camila Fisher</li>
          <li>Gavin Lewis</li>
          <li>Isabella Powell</li>
          <li>Zoe Wilson</li>
        </ul>
      </vaadin-details>
    `;
  }
}
```

**Java** — `DetailsDisabled.java`

```java
UnorderedList content = new UnorderedList(new ListItem("Blake Martin"),
        new ListItem("Caroline Clark"), new ListItem("Avery Torres"),
        new ListItem("Khloe Scott"), new ListItem("Camila Fisher"),
        new ListItem("Gavin Lewis"), new ListItem("Isabella Powell"),
        new ListItem("Zoe Wilson"));

Details details = new Details("Members (8)", content);
details.setEnabled(false);

add(details);
```

## <a id="best-practices"></a>Best Practices

Use Details to group related content and to reduce the risk of overwhelming the user with information. However, avoid putting important information in a Details component unless it’s expanded by default. Otherwise, the user might not notice it.

Details can be used instead of Accordion if there is a need to see content from multiple collapsible content areas, simultaneously.

The expandable and collapsible nature of Details can sometimes be difficult for users to discover. Use the [filled variant](#filled) and apply a [tooltips](https://vaadin.com/docs/v23/components/tooltip.md) (since V23.3) to make this more discoverable.

## <a id="related-components"></a>Related Components

| Component                                                        | Usage recommendations                                                                           |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| [Accordion](https://vaadin.com/docs/v23/components/accordion.md) | Vertically stacked set of expandable panels, in which only one panel can be expanded at a time. |
| [Tabs](https://vaadin.com/docs/v23/components/tabs.md)           | Component for organizing and grouping content into navigable sections.                          |

`25CA6A07-DDDB-47F3-9E6D-EEAB00498336`
