---
title: Metadata Types Overview
description: A comprehensive guide to every metadata type used in ObjectStack application development
---

# Metadata Types Overview

In ObjectStack, an application is defined entirely by **metadata** — declarative configurations that describe data models, user interfaces, business logic, and security rules. The Kernel interprets these metadata definitions at runtime to produce a fully functional application.

This section provides a detailed guide for each metadata type you use when building an application.

## Metadata Categories

### Data Layer

Define your business data model and integrity rules.

| Metadata Type | Description | File Convention |
| :--- | :--- | :--- |
| [**Object**](./object) | Business entity definitions — tables, fields, capabilities | `*.object.ts` / `*.object.yml` |
| [**Field**](./field) | Individual property definitions within objects — 40+ types | Defined inline within Object |
| [**Validation**](./validation) | Data integrity rules — formula, uniqueness, format, state machine | Defined inline or standalone |

### UI Layer

Define how users interact with data.

| Metadata Type | Description | File Convention |
| :--- | :--- | :--- |
| [**View**](./view) | List views and form views — grid, kanban, calendar, gantt | `*.view.ts` / `*.view.yml` |
| [**Page**](./page) | Custom pages with component-based layouts | `*.page.ts` / `*.page.yml` |
| [**App**](./app) | Application container — navigation, branding, permissions | `*.app.ts` / `*.app.yml` |
| [**Dashboard**](./dashboard) | Analytics dashboards with chart widgets | `*.dashboard.ts` / `*.dashboard.yml` |

### Automation Layer

Define business logic and process automation.

| Metadata Type | Description | File Convention |
| :--- | :--- | :--- |
| [**Flow**](./flow) | Visual automation — decision trees, data operations, screens | `*.flow.ts` / `*.flow.yml` |
| [**Workflow**](./workflow) | Event-triggered rules — field updates, alerts, HTTP calls | `*.workflow.ts` / `*.workflow.yml` |

### Security Layer

Define access control and data visibility.

| Metadata Type | Description | File Convention |
| :--- | :--- | :--- |
| [**Permission**](./permission) | Permission sets — object CRUD, field security, tab visibility | `*.permission.ts` / `*.permission.yml` |

## How Metadata Works Together

```
┌─────────────────────────────────────────────────┐
│                   App (Container)                │
│  ┌──────────┐  ┌───────────┐  ┌──────────────┐  │
│  │Navigation│  │  Branding │  │  Permissions  │  │
│  └──────────┘  └───────────┘  └──────────────┘  │
├─────────────────────────────────────────────────┤
│            Views / Pages / Dashboards            │
│  ┌─────────┐  ┌──────────┐  ┌───────────────┐   │
│  │ListView  │  │ FormView │  │   Dashboard   │   │
│  │(grid,    │  │(sections,│  │  (widgets,    │   │
│  │ kanban)  │  │ fields)  │  │   charts)     │   │
│  └─────────┘  └──────────┘  └───────────────┘   │
├─────────────────────────────────────────────────┤
│               Objects + Fields                   │
│  ┌──────────────────────────────────────────┐    │
│  │  Object: name, fields, capabilities      │    │
│  │  Fields: text, number, select, lookup ... │    │
│  │  Validations: formula, uniqueness, format │    │
│  └──────────────────────────────────────────┘    │
├─────────────────────────────────────────────────┤
│          Flows + Workflows + Permissions          │
│  ┌───────────┐  ┌───────────┐  ┌────────────┐   │
│  │   Flow    │  │ Workflow  │  │ Permission │   │
│  │(visual    │  │(event     │  │(CRUD, field│   │
│  │ logic)    │  │ triggers) │  │ security)  │   │
│  └───────────┘  └───────────┘  └────────────┘   │
└─────────────────────────────────────────────────┘
```

## Quick Example

A minimal application requires at least an **Object** definition:

```typescript
import { ObjectSchema, Field } from '@objectstack/spec/data';

export const Task = ObjectSchema.create({
  name: 'task',
  label: 'Task',
  fields: {
    title: Field.text({ label: 'Title', required: true }),
    status: Field.select({
      label: 'Status',
      options: [
        { label: 'To Do', value: 'todo', default: true },
        { label: 'In Progress', value: 'in_progress' },
        { label: 'Done', value: 'done' },
      ],
    }),
    assignee: Field.lookup('user', { label: 'Assignee' }),
  },
  enable: { apiEnabled: true, searchable: true },
});
```

From this single definition, ObjectStack automatically generates CRUD APIs, form views, and list views. As your application grows, you add **Views**, **Flows**, **Permissions**, and other metadata to customize behavior.

## Next Steps

Start with the core building blocks:

1. [**Object**](./object) — Define your data entities
2. [**Field**](./field) — Configure field types and properties
3. [**View**](./view) — Customize list and form layouts
4. [**Flow**](./flow) — Add business logic and automation
