# Installation
> Take the design layer as a package and the components from the registry.
Source: https://ziiz.vercel.app/installation
ziiz ships in two pieces because they change at different rates. The **theme** is one stylesheet that defines the ramp, the type roles, the materials and the prose layer. It is versioned, and an app takes updates by bumping a dependency. The **components** are source files that an app owns and edits. They come from a registry and never update on their own.
## Quick start [#quick-start]
Start from a shadcn project.
Skip this if `components.json` already exists. The Vega preset is the one ziiz components are built on.
```bash
npx shadcn@latest init --preset vega
```
`init` writes a stock theme block into `app/globals.css`. Delete everything below the imports except `@custom-variant dark`: the next step supplies the theme, and the stock block's own font and color variables would sit on top of it.
Point
`components.json`
at the registry.
The registry is served straight from the repository, so there is no deploy between a merge and an install.
```json title="components.json"
{
"registries": {
"@ziiz": "https://raw.githubusercontent.com/nafisazizir/ziiz/main/apps/www/public/r/{name}.json"
}
}
```
Add the theme.
```bash
npx shadcn@latest add @ziiz/theme --overwrite
```
One item does the setup. It installs the `@nafisazizir/ziiz` package, `tw-animate-css` and `shadcn`, adds their three imports to the Tailwind entry in the right order, and replaces `lib/utils.ts` with a `cn` that understands the type roles. `--overwrite` is what lets it replace that file; without the flag the CLI stops to ask.
Set the fonts.
The theme reads `--font-sans` and `--font-mono` from `html` or `:root`. With next/font that is the `variable` option; ziiz uses Inter with `ss03` and Geist Mono. An app that sets neither gets Tailwind's default stacks, not a broken page.
```tsx title="app/layout.tsx"
const inter = Inter({ subsets: ["latin"], variable: "--font-sans" })
const mono = Geist_Mono({ subsets: ["latin"], variable: "--font-mono" })
```
Set up dark mode.
Dark mode is the `.dark` class on `html`. With next-themes (`npm install next-themes`), that is `attribute="class"` on the provider, plus `suppressHydrationWarning` on `html` because the class is set before React hydrates. Without it, toggle the class yourself.
```tsx title="app/layout.tsx"
{children}
```
Add components.
Every item lists what it imports, so one command pulls in a component, the components it composes and the packages they need.
```bash
npx shadcn@latest add @ziiz/button
```
After that, every Tailwind utility speaks the ramp (`bg-gray-100`, `text-gray-1000`, `border-gray-alpha-400`), the 31 type roles are single classes (`text-heading-32`, `text-copy-16`, `text-label-13`), the eight materials are too (`material-menu`, `material-modal`), and `typeset` sets prose. The stock Tailwind palette is disabled on purpose; only the ramp compiles.
Type roles are single utilities, so the stock `cn` does not know that
`text-label-14` and `text-copy-16` conflict. It keeps both, and stylesheet
order decides which one paints, so a `className` override on a component works
or fails by accident. `@nafisazizir/ziiz/cn` builds on the `cn` package with
the roles as one font-size group and the materials as another. The `utils`
item is a one-line re-export of it, and every component depends on it.
## Manual setup [#manual-setup]
The theme item is a shortcut for four edits. Doing them by hand gives the same result.
Install the packages.
```bash
npm install @nafisazizir/ziiz tw-animate-css shadcn
```
`tw-animate-css` provides the enter and exit animations (`animate-in`, `fade-in-0`) that overlays use; `shadcn/tailwind.css` provides the `data-open:` and `data-closed:` variants and the accordion keyframes. Both are required, not optional.
Import the stylesheets, in this order.
```css title="app/globals.css"
@import "tailwindcss";
@import "tw-animate-css";
@import "shadcn/tailwind.css";
@import "@nafisazizir/ziiz/theme.css";
```
Re-export
`cn`
.
```ts title="lib/utils.ts"
export { cn } from "@nafisazizir/ziiz/cn"
```
Fonts and dark mode, as above.
Add a fifth import, `@nafisazizir/ziiz/shadcn.css`. It maps shadcn's slot
names (`bg-background`, `text-muted-foreground`, `border-input`) onto the ramp
so components written against that vocabulary render on it unchanged. ziiz
components speak the ramp directly and do not need it.
## Components [#components]
The registry publishes every component on this site plus the documentation primitives it is written with (`callout`, `steps`, `code-block`, `code-tabs`, `component-preview`, `component-source`), which install into `components/docs/`. Search it from the CLI:
```bash
npx shadcn@latest search @ziiz
npx shadcn@latest view @ziiz/button
```
## Prose [#prose]
Long-form content needs no components. Add `typeset` to the container and every heading, paragraph, list, code span and table inside binds to a type role. See [Prose](/prose) for the full element set.
```tsx
{children}
```
## Agents [#agents]
The system is written down for coding agents as well as people. Three pieces:
```bash
npx shadcn@latest add @ziiz/skill
```
The `skill` item installs the ziiz skill into `.agents/skills/ziiz/`: the vocabulary, the rules a component must follow, and the greps that check them. Claude Code, Codex and Cursor read that folder.
```bash
npx shadcn@latest mcp init --client claude
```
The shadcn MCP reads the `@ziiz` entry from `components.json`, so an agent can search, view and add registry items as tools. `--client` also takes `cursor`, `vscode` and `codex`.
Every page on this site is also markdown. [/llms.txt](/llms.txt) lists them with descriptions, [/llms-full.txt](/llms-full.txt) is the guide, the foundation and every component page in one file, and any page is at `/llms.mdx/` followed by its path, such as `/llms.mdx/components/button`.
---
# Colors
> Learn how to work with our color system.
Source: https://ziiz.vercel.app/colors
## Scales [#scales]
There are 10 color scales in the system: backgrounds, gray, gray alpha, blue, red, amber, green, teal, purple, and pink. Values are defined in oklch, so wide-gamut color renders on supported browsers and displays. Every non-background scale has the same 10 steps with the same roles. The sections below describe each role once, and it applies to every scale. The swatches use gray as the representative ramp.
The scales are hand-tuned per step, not interpolated. Some steps deliberately reverse (Color 4 on the alpha scale is lighter than Color 3), so treat every step as a named role, never a point on a gradient.
## Backgrounds [#backgrounds]
There are two background colors for pages and UI components. In most instances, you should use Background 1, especially when color is being placed on top of the background. Background 2 should be used sparingly when a subtle background differentiation is needed.
## Colors 1–3: Component backgrounds [#colors-13-component-backgrounds]
The first three colors are component backgrounds, on every scale: Color 1 at rest, Color 2 on hover, Color 3 when pressed or selected. In practice there are two ladders.
Filled components, like secondary buttons and badges, step 1 → 2 → 3 as written.
If a component's default background is Background 1 (the page surface showing through, like ghost buttons, menu items and tab chips), the ladder shifts down a rung: Color 1 is the hover background and Color 2 the active background. Components that rest transparent take that shift on the alpha scale, so the state reads over any surface.
Two refinements hold on both ladders. A transient open state (`aria-expanded`, `data-open`) pins to the hover step: the highlight lives in the popup, so the trigger only ever looks hovered. And hovering an already-selected control deepens one step further (`gray-alpha-300` on the alpha ladder, `gray-950` on the inverted fills) so selection never swallows the hover response.
## Colors 4–6: Borders [#colors-46-borders]
These three colors are designed for UI component borders.
In practice, borders default to the alpha scale; alpha hairlines hold up over any surface. Bordered controls and text fields step the hairline to Color 5 on hover. For fields, that border step is the entire hover response. Color 6's "active border" role is filled by the focus signature: solid gray-600 replaces the hairline on focus rather than stepping the alpha scale.
## Colors 7–8: High contrast backgrounds [#colors-78-high-contrast-backgrounds]
These two colors are designed for high contrast UI component backgrounds.
## Colors 9–10: Text and icons [#colors-910-text-and-icons]
These two colors are designed for accessible text and icons.
## shadcn mapping [#shadcn-mapping]
The shadcn semantic slots are pure `var(--ds-*)` aliases onto the ramp, never values.
---
# Typography
> Rules of typesetting throughout the system.
Source: https://ziiz.vercel.app/typography
## Usage [#usage]
Our typography styles can be consumed as Tailwind classes. The classes below pre-set a combination of `font-size`, `line-height`, `letter-spacing`, and `font-weight` for you.
To make use of the **Subtle** and **Strong** modifiers, all you have to do is use the `` element nested as the descendant of a given typography class:
```tsx
Copy 16 with Strong
```
## Headings [#headings]
Used to introduce pages or sections.
## Buttons [#buttons]
Only to be used within components that render buttons.
## Label [#label]
Designed for single-lines, and given ample line-height for highlighting & marrying up with icons.
## Copy [#copy]
Designed for multiple lines of text, having a higher line height than Label.
---
# Materials
> Elevation presets combining background, border, shadow, and radius.
Source: https://ziiz.vercel.app/materials
## Surface [#surface]
Four levels of elevation for elements that sit in the page. Radius steps up with elevation.
In-page surfaces in the component library are flat by decision: cards, sidebars, inputs and wells draw a hairline `border-gray-alpha-400` on `bg-background-100` and carry no shadow, so no `ui` component uses a Surface material today. The tiers remain available for content that genuinely needs to lift off the page (marketing sections, dashboards, previews) and for consumers whose surfaces are not flat.
## Floating [#floating]
Four levels of elevation for elements that float above the page, ordered from closest to furthest off the surface.
## Best practices [#best-practices]
### When to use [#when-to-use]
* Reach for a material instead of composing background, border, shadow, and radius by hand. The class encodes the elevation role, not just the look.
* Pick the type from where the element sits in the layered hierarchy: `base` and `small` for resting surfaces, `medium` and `large` for raised content, `tooltip` and `menu` for popovers, `modal` and `fullscreen` for takeovers. In the component library, `menu` and `modal` do nearly all the work.
* Never stack two materials on the same element. If a child needs more lift, it becomes its own material one tier up.
### Behavior [#behavior]
* Keep the elevation choice in step with the element's `z-index` band, so a `tooltip`-typed surface never renders visually beneath a `base` card.
* Favor the lowest tier that still reads as separated from its background; over-elevating is the most common source of visual noise.
* Don't override a material's shadow or radius inline. If a surface needs different chrome, it belongs to a different tier.
### Accessibility [#accessibility]
* Materials are decorative chrome. Semantics live on the role-bearing element: `role="dialog"` on a modal, `role="tooltip"` on a tooltip, never on the class.
* Elevation is never the only signal: pair floating surfaces with focus management, and keep the focus ring on interactive children inside.
* Check both themes. Dark shadows use higher opacities than light, yet still barely register against a black page; in dark, separation comes from the hairline ring, so verify it reads wherever the material lands.
---
# Prose
> The prose layer: one class that typesets long-form content onto the type roles.
Source: https://ziiz.vercel.app/prose
## Usage [#usage]
Add `typeset` to a container. Every heading, paragraph, list, link, code span and table inside binds to a type role with a fixed rhythm, so a docs body, a blog article or rendered markdown is plain elements with no classes.
```tsx
Title
Body copy on Copy 16, headings on the article scale.
```
Every rule is scoped with `:where()`, so a utility on the element still wins, and a subtree marked `not-typeset` opts out entirely. Rhythm is set by two custom properties, `--typeset-flow` between blocks and `--typeset-section` above a section heading. Everything below this line is one typeset body, written as bare elements.
***
# Heading 1 binds to Heading 40 [#heading-1-binds-to-heading-40]
The first heading level inside a body is the page-title role. This paragraph is Copy 16 on Color 9. Every block sits 24px below the one before it, headings included.
A second paragraph keeps the flow gap. Inline semantics bind too: **strong is the Copy role's Strong modifier**, *emphasis stays italic*, `code` becomes a chip, ⌘K is a key cap, mark highlights, and abbreviations carry a dotted underline. A [link](#lists) is underlined on the text color, never on the accent.
## Heading 2 binds to Heading 32 [#heading-2-binds-to-heading-32]
Section headings take the section gap above, 72px by default. The role is applied as is: no weight, size or leading is overridden, so a heading here is identical to the same role anywhere in the app. A `code` span inside a heading keeps its Copy 13 Mono role too.
### Heading 3 binds to Heading 24 [#heading-3-binds-to-heading-24]
Subsections take 64px above.
#### Heading 4 binds to Heading 20 [#heading-4-binds-to-heading-20]
Minor headings take 48px above.
##### Heading 5 binds to Heading 16, Heading 6 to 14 [#heading-5-binds-to-heading-16-heading-6-to-14]
The smallest steps, 32px above, for run-in labels inside a subsection.
## Lists [#lists]
Unordered lists use a disc, then a circle when nested.
* The marker sits on Color 6, a step lighter than the body.
* Items are 8px apart with 8px of padding after the marker, and a nested list keeps that gap.
* Nested items use a circle.
* They indent by the same 20px as the parent.
* A block inside an item takes the item gap, whether it follows text or not.
Like this paragraph.
Ordered lists use decimals.
1. Read the roadmap.
2. Cut the seam.
3. Ship the layer.
Definition lists set the term on Color 10 and indent the detail.
Role
A named combination of size, leading, tracking and weight.
Ramp
The ten-step scale every color in the system is drawn from.
## Quotes, rules and disclosures [#quotes-rules-and-disclosures]
A blockquote is a pull quote: the text sits on Heading 24 with hanging quote marks drawn by the layer, and a trailing `footer` carries the attribution, with `cite` for the name. It takes half the section gap above and below.
{
"Minting short-lived tokens instead of keeping provider credentials in paused sandboxes has removed a whole class of security risk for us."
}
Disclosures take the Accordion component's shape on the body role, with no hairline between rows. Adjacent ones stack; each opens on its own, since markdown cannot group them.
Is this a native details element?
{
"Yes. The summary is the trigger with the chevron at the end, and this content sits flush beneath it with 16px below, the same as the accordion panel."
}
A second paragraph keeps the panel's 16px gap.
What does it not do?
{
"It does not animate open and closed, and it does not close its siblings when opened. Both need the component."
}
Where does the look come from?
{
"The Accordion component is the source of truth; the prose layer mirrors it by hand."
}
***
A horizontal rule is a 1px line on Color 2 with 80px above, 160px on wide screens, marking a break larger than any section.
## Code [#code]
Inline code is the Copy 13 Mono chip on Color 1. Code blocks are Copy 13 Mono on Background 2 with a hairline and 16px of padding. Syntax color is a pipeline concern and lands on the tokens inside; the surface is the same everywhere.
```css
@import "@nafisazizir/ziiz/theme.css";
.article {
--typeset-flow: 1rem;
--typeset-section: 4rem;
}
```
## Tables [#tables]
Tables match the table component: Heading 14 header cells, Label 14 body cells with tabular numerals, and a hover on each row. The separator sits on the cell, so appending a row never needs a rule to change.
| Element | Role | Gap above |
| ------------- | ---------- | --------- |
| h1 | Heading 40 | 72px |
| h2 | Heading 32 | 72px |
| h3 | Heading 24 | 64px |
| h4 | Heading 20 | 48px |
| p, ul, ol, dl | Copy 16 | 24px |
| pre, table | inherits | 28px |
| blockquote | Heading 24 | 36px |
| figure | inherits | 40px |
## Figures [#figures]
{"image or embed"}
{
"A figure takes 40px above and below; its caption is Copy 14 on Color 9, centered, 16px below."
}
## Opting out [#opting-out]
A component with its own chrome sits inside a body by marking its root `not-typeset`. Nothing inside it inherits paragraph margins, link underlines or code chips. The alert below is stock; the button next to it is a plain component in a plain paragraph and needs no marker because no rule targets it.
Stock alert inside a typeset body
Its code and link render as the component
styles them, not as prose.
## Density [#density]
The two rhythm properties are the only knobs. The block below sets `--typeset-flow` to 12px and `--typeset-section` to 32px on a nested container, and everything inside tightens.
A denser body
Paragraphs sit 12px apart instead of 24px.
Section headings pull in from 72px to 32px, subsections to 28px.
Another section
Lists keep their own 8px item gap.
Only the two properties changed.
---
# Accordion
> A vertically stacked set of interactive headings that each reveal a section of content.
Source: https://ziiz.vercel.app/components/accordion
## Installation [#installation]
Command
Manual
```bash
npx shadcn@latest add @ziiz/accordion
```
Install the following dependencies:
```bash
npm install @base-ui/react @tabler/icons-react
```
Copy and paste the following code into your project.
Update the import paths to match your project setup.
## Usage [#usage]
```tsx showLineNumbers
import {
Accordion,
AccordionContent,
AccordionItem,
AccordionTrigger,
} from "@/components/ui/accordion"
```
```tsx showLineNumbers
Is it accessible?
Yes. It adheres to the WAI-ARIA design pattern.
```
## Composition [#composition]
Use the following composition to build an `Accordion`:
```text
Accordion
├── AccordionItem
│ ├── AccordionTrigger
│ └── AccordionContent
└── AccordionItem
├── AccordionTrigger
└── AccordionContent
```
## Basic [#basic]
A basic accordion that shows one item at a time. The first item is open by default.
## Multiple [#multiple]
Use the `multiple` prop to allow multiple items to be open at the same time.
## Disabled [#disabled]
Use the `disabled` prop on `AccordionItem` to disable individual items.
## Borders [#borders]
Add `border` to the `Accordion` and `border-b last:border-b-0` to the `AccordionItem` to add borders to the items.
## Card [#card]
Wrap the `Accordion` in a `Card` component.
## API Reference [#api-reference]
See the [Base UI](https://base-ui.com/react/components/accordion#api-reference) documentation for more information.
---
# Alert
> Displays a callout for user attention.
Source: https://ziiz.vercel.app/components/alert
## Installation [#installation]
Command
Manual
```bash
npx shadcn@latest add @ziiz/alert
```
Install the following dependencies:
```bash
npm install class-variance-authority
```
Copy and paste the following code into your project.
Update the import paths to match your project setup.
## Usage [#usage]
```tsx showLineNumbers
import {
Alert,
AlertAction,
AlertDescription,
AlertTitle,
} from "@/components/ui/alert"
```
```tsx showLineNumbers
Heads up!
You can add components and dependencies to your app using the cli.
```
## Composition [#composition]
Use the following composition to build an `Alert`:
```text
Alert
├── Icon
├── AlertTitle
├── AlertDescription
└── AlertAction
```
## Basic [#basic]
A basic alert with an icon, title and description.
## Destructive [#destructive]
Use `variant="destructive"` to create a destructive alert.
## Action [#action]
Use `AlertAction` to add a button or other action element to the alert.
## Custom Colors [#custom-colors]
You can customize the alert colors by adding custom classes such as `bg-amber-50 dark:bg-amber-950` to the `Alert` component.
## API Reference [#api-reference]
### Alert [#alert]
The `Alert` component displays a callout for user attention.
| Prop | Type | Default |
| --------- | ---------------------------- | ----------- |
| `variant` | `"default" \| "destructive"` | `"default"` |
### AlertTitle [#alerttitle]
The `AlertTitle` component displays the title of the alert.
| Prop | Type | Default |
| ----------- | -------- | ------- |
| `className` | `string` | - |
### AlertDescription [#alertdescription]
The `AlertDescription` component displays the description or content of the alert.
| Prop | Type | Default |
| ----------- | -------- | ------- |
| `className` | `string` | - |
### AlertAction [#alertaction]
The `AlertAction` component displays an action element (like a button) positioned absolutely in the top-right corner of the alert.
| Prop | Type | Default |
| ----------- | -------- | ------- |
| `className` | `string` | - |
---
# Alert Dialog
> A modal dialog that interrupts the user with important content and expects a response.
Source: https://ziiz.vercel.app/components/alert-dialog
## Installation [#installation]
Command
Manual
```bash
npx shadcn@latest add @ziiz/alert-dialog
```
Install the following dependencies:
```bash
npm install @base-ui/react
```
Copy and paste the following code into your project.
Update the import paths to match your project setup.
## Usage [#usage]
```tsx showLineNumbers
import {
AlertDialog,
AlertDialogAction,
AlertDialogCancel,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
AlertDialogTrigger,
} from "@/components/ui/alert-dialog"
```
```tsx showLineNumbers
}>
Show Dialog
Are you absolutely sure?
This action cannot be undone. This will permanently delete your account
from our servers.
CancelContinue
```
## Composition [#composition]
Use the following composition to build an `AlertDialog`:
```text
AlertDialog
├── AlertDialogTrigger
└── AlertDialogContent
├── AlertDialogHeader
│ ├── AlertDialogMedia
│ ├── AlertDialogTitle
│ └── AlertDialogDescription
└── AlertDialogFooter
├── AlertDialogCancel
└── AlertDialogAction
```
## Basic [#basic]
A basic alert dialog with a title, description, and cancel and continue buttons.
## Small [#small]
Use the `size="sm"` prop to make the alert dialog smaller.
## Media [#media]
Use the `AlertDialogMedia` component to add a media element such as an icon or image to the alert dialog.
## Small with Media [#small-with-media]
Use the `size="sm"` prop to make the alert dialog smaller and the `AlertDialogMedia` component to add a media element such as an icon or image to the alert dialog.
## Destructive [#destructive]
Use the `AlertDialogAction` component to add a destructive action button to the alert dialog.
## API Reference [#api-reference]
### size [#size]
Use the `size` prop on the `AlertDialogContent` component to control the size of the alert dialog. It accepts the following values:
| Prop | Type | Default |
| ------ | ------------------- | ----------- |
| `size` | `"default" \| "sm"` | `"default"` |
### AlertDialogAction and AlertDialogCancel [#alertdialogaction-and-alertdialogcancel]
Both render a [`Button`](/components/button). `AlertDialogAction` accepts all of its props; `AlertDialogCancel` accepts its `variant`, `size` and `shape`.
| Prop | Type | Default |
| --------- | ------------------------ | ------------------------------------------ |
| `variant` | `Button["variant"]` | `"default"` (Action), `"outline"` (Cancel) |
| `size` | `Button["size"]` | `"default"` |
| `shape` | `"default" \| "rounded"` | `"default"` |
For more information about the other components and their props, see the [Base UI documentation](https://base-ui.com/react/components/alert-dialog#api-reference).
---
# Aspect Ratio
> Displays content within a desired ratio.
Source: https://ziiz.vercel.app/components/aspect-ratio
## Installation [#installation]
Command
Manual
```bash
npx shadcn@latest add @ziiz/aspect-ratio
```
Copy and paste the following code into your project.
Update the import paths to match your project setup.
## Usage [#usage]
```tsx showLineNumbers
import { AspectRatio } from "@/components/ui/aspect-ratio"
```
```tsx showLineNumbers
```
## Square [#square]
A square aspect ratio component using the `ratio={1 / 1}` prop. This is useful for displaying images in a square format.
## Portrait [#portrait]
A portrait aspect ratio component using the `ratio={9 / 16}` prop. This is useful for displaying images in a portrait format.
## API Reference [#api-reference]
### AspectRatio [#aspectratio]
The `AspectRatio` component displays content within a desired ratio.
| Prop | Type | Default | Required |
| ----------- | -------- | ------- | -------- |
| `ratio` | `number` | - | Yes |
| `className` | `string` | - | No |
For more information, see the [Base UI documentation](https://base-ui.com/react/components/aspect-ratio#api-reference).
---
# Attachment
> Displays a file or image attachment with media, metadata, upload state, and actions.
Source: https://ziiz.vercel.app/components/attachment
The `Attachment` component displays a file or image attachment, its media, name, and metadata, with optional actions and upload state. Use it for files and images in chat composers, message threads, and upload lists.
## Installation [#installation]
Command
Manual
```bash
npx shadcn@latest add @ziiz/attachment
```
Install the following dependencies:
```bash
npm install @base-ui/react class-variance-authority
```
Copy and paste the following code into your project.
Update the import paths to match your project setup.
## Usage [#usage]
```tsx
import {
Attachment,
AttachmentAction,
AttachmentActions,
AttachmentContent,
AttachmentDescription,
AttachmentMedia,
AttachmentTitle,
} from "@/components/ui/attachment"
```
```tsx
sales-dashboard.pdfPDF · 2.4 MB
```
## Composition [#composition]
Use the following composition to build an attachment:
```text
Attachment
├── AttachmentMedia
├── AttachmentContent
│ ├── AttachmentTitle
│ └── AttachmentDescription
├── AttachmentActions
│ └── AttachmentAction
└── AttachmentTrigger
```
Use `AttachmentGroup` to lay out multiple attachments in a scrollable row:
```text
AttachmentGroup
├── Attachment
└── Attachment
```
## Features [#features]
* Icon and image media through `AttachmentMedia`
* Upload states: `idle`, `uploading`, `processing`, `error`, and `done` with built-in styling and a shimmer while in progress
* Three sizes and horizontal or vertical orientation
* A full-card `AttachmentTrigger` that opens a link or dialog while the actions stay independently clickable
* Scrollable, snapping `AttachmentGroup` with an edge fade
* Customizable styling through the `className` prop on every part
## Image [#image]
Set `variant="image"` on `AttachmentMedia` and render an `` inside it. Use `orientation="vertical"` to stack the media above the content.
## States [#states]
Set `state` to reflect the upload lifecycle. `uploading` and `processing` shimmer the title, and `error` switches to a destructive treatment.
## Sizes [#sizes]
Use `size` to switch between `default`, `sm`, and `xs`.
## Group [#group]
Wrap attachments in `AttachmentGroup` to lay them out in a horizontally scrollable, snapping row with an edge fade.
## Trigger [#trigger]
Add an `AttachmentTrigger` to make the whole card open a link or dialog. It fills the card behind the actions, so the actions stay clickable.
```tsx showLineNumbers
```
## Accessibility [#accessibility]
`AttachmentAction` renders a `Button`, and `AttachmentTrigger` renders a real `