# @plane/types Package: Complete Guide to TypeScript Types in Plane

> Explore the @plane/types package for over 50 domain-specific TypeScript types covering entities UI components integrations and utilities. Master Plane's type system.

- Repository: [Plane/plane](https://github.com/makeplane/plane)
- Tags: api-reference
- Published: 2026-08-23

---

**The @plane/types package defines 50+ domain-specific TypeScript modules covering entities (issues, projects, workspaces), UI components (views, layouts, command palette), integrations (calendar, webhooks, importers), and generic utilities—all re-exported through a single entry point.**

The `@plane/types` package serves as Plane's central type registry, providing shared TypeScript definitions that enforce consistency across the monorepo. Located at [`packages/types/src/index.ts`](https://github.com/makeplane/plane/blob/main/packages/types/src/index.ts), it aggregates type definitions from modular files and exposes them for consumption by frontend packages (`@plane/ui`, `@plane/editor`) and backend services alike.

## Core Domain Entity Types

### Issues, Projects, and Workspaces

The most frequently used types model Plane's three-tier entity hierarchy:

- **`IIssue`** / **`IIssueLite`** — Full issue definition and lightweight reference variant ([`src/issues.ts`](https://github.com/makeplane/plane/blob/main/src/issues.ts))
- **`IProject`** / **`IProjectLink`** / **`IProjectFilters`** — Project definitions with linking and filter capabilities (`src/project/`)
- **`IWorkspace`** / **`IWorkspaceMember`** — Core workspace entity and membership details ([`src/workspace.ts`](https://github.com/makeplane/plane/blob/main/src/workspace.ts))

### Cycles, Modules, and Epics

Agile planning constructs have dedicated type modules:

- **`TCycle`** / **`TCycleFilters`** — Sprint/cycle definitions and filtering options ([`src/cycle.ts`](https://github.com/makeplane/plane/blob/main/src/cycle.ts))
- **`IModule`** / **`IModuleFilters`** — Project module types ([`src/module.ts`](https://github.com/makeplane/plane/blob/main/src/module.ts))
- **`IEpic`** / **`IEpicLite`** — Epic-level issue grouping ([`src/epics.ts`](https://github.com/makeplane/plane/blob/main/src/epics.ts))

## UI and Layout Types

### View System Types

The view system separates display configuration from data queries:

```ts
import { IView, IViewProps } from "@plane/types";

const kanbanConfiguration: IView = {
  id: "view_001",
  name: "My Kanban",
  type: "kanban",
  query: { filters: { status: ["todo", "in-progress"] } },
  props: {
    layout: "kanban",
    group_by: "status",
  } as IViewProps,
};

```

Source: `IView` — [[`src/views.ts`](https://github.com/makeplane/plane/blob/main/src/views.ts)](https://github.com/makeplane/plane/blob/preview/packages/types/src/views.ts); `IViewProps` — [[`src/view-props.ts`](https://github.com/makeplane/plane/blob/main/src/view-props.ts)](https://github.com/makeplane/plane/blob/preview/packages/types/src/view-props.ts)

### Layout Type Hierarchy

Layout definitions follow an inheritance pattern:

- **`IBaseLayoutList`** / **`IBaseLayoutKanban`** — Base interfaces shared by specific layouts ([`src/base-layouts.ts`](https://github.com/makeplane/plane/blob/main/src/base-layouts.ts))
- **`IGanttLayout`** / **`IKanbanLayout`** — Concrete layout implementations ([`src/layout.ts`](https://github.com/makeplane/plane/blob/main/src/layout.ts))

### Command Palette and Navigation

Interactive UI components have strongly-typed contracts:

- **`ICommand`** / **`ICommandGroup`** — Global command palette definitions ([`src/command-palette.ts`](https://github.com/makeplane/plane/blob/main/src/command-palette.ts))
- **`INavigationPreferences`** — User navigation UI settings ([`src/navigation-preferences.ts`](https://github.com/makeplane/plane/blob/main/src/navigation-preferences.ts))

## Activity and Collaboration Types

### Activity Log Types

Activity tracking uses generic, reusable base types:

```ts
import { TWorkspaceBaseActivity } from "@plane/types";

const logEntry: TWorkspaceBaseActivity<"title", "updated"> = {
  id: "act_123",
  field: "title",
  epoch: Date.now(),
  verb: "updated",
  comment: "Changed the issue title",
  old_value: "Old title",
  new_value: "New title",
  actor: "user_456",
  created_at: new Date().toISOString(),
  updated_at: new Date().toISOString(),
  workspace: "ws_789",
};

```

Source: `TBaseActivity` — [[`src/activity.ts`](https://github.com/makeplane/plane/blob/main/src/activity.ts)](https://github.com/makeplane/plane/blob/preview/packages/types/src/activity.ts)

### User and Membership Types

The user model supports multiple access patterns:

- **`IUser`** — Full profile with authentication metadata ([`src/users.ts`](https://github.com/makeplane/plane/blob/main/src/users.ts))
- **`IUserLite`** — Minimal reference for lists and foreign keys
- **`IUserProfile`** — Extended activity and preference data

```ts
import { IUser } from "@plane/types";

function printUserSummary(user: IUser) {
  console.log(
    `${user.display_name} (${user.email}) — Joined ${new Date(
      user.date_joined
    ).toLocaleDateString()}`
  );
}

```

Source: [[`src/users.ts`](https://github.com/makeplane/plane/blob/main/src/users.ts)](https://github.com/makeplane/plane/blob/preview/packages/types/src/users.ts)

## Integration and External Service Types

### Calendar and Communication Integrations

Third-party connectivity types include:

- **`ICalendarIntegration`** / **`ICalendarEvent`** — Google Calendar, Outlook support ([`src/calendar.ts`](https://github.com/makeplane/plane/blob/main/src/calendar.ts))
- **`IIntegration`** / **`IIntegrationConfig`** — Generic contract for Slack, Lark, etc. (`src/integration/`)

### Importer Types

Data migration from external systems:

- **`IJiraImporterPayload`** / **`IGithubImporterPayload`** — Jira and GitHub import structures ([`src/importer.ts`](https://github.com/makeplane/plane/blob/main/src/importer.ts))

### Webhook Types

Outgoing event notifications:

- **`IWebhook`** / **`IWebhookPayload`** — Webhook configuration and delivery contracts ([`src/webhook.ts`](https://github.com/makeplane/plane/blob/main/src/webhook.ts))

## Utility and Generic Types

### Common Helper Types

Reusable type utilities for null safety and partial updates:

- **`TNullable<T>`** — Nullable wrapper type
- **`TPartial<T>`** — Partial type variant

Source: `src/common/` or `src/utils/`

### Pagination Type

Standardized list response shape:

- **`TPaginationResponse<T>`** — Generic paginated response wrapper ([`src/pagination.ts`](https://github.com/makeplane/plane/blob/main/src/pagination.ts))

### Rich Filter DSL

Advanced query building with type-safe operators:

```ts
import {
  IRichFilterExpression,
  TFilterOperator,
} from "@plane/types";

const priorityFilter: IRichFilterExpression = {
  field: "priority",
  operator: "eq" as TFilterOperator,
  value: "high",
};

```

Source: [[`src/rich-filters/expression.ts`](https://github.com/makeplane/plane/blob/main/src/rich-filters/expression.ts)](https://github.com/makeplane/plane/blob/preview/packages/types/src/rich-filters/expression.ts)

## Specialized Feature Types

### Editor Content Model

Rich-text editor types define the document structure:

- **`TEditorContent`** / **`TEditorBlock`** — Content model for Plane's editor (`src/editor/`)

### Analytics and Telemetry

Observability data contracts:

- **`TAnalyticsEvent`** / **`TAnalyticsPayload`** — Telemetry event structures ([`src/analytics.ts`](https://github.com/makeplane/plane/blob/main/src/analytics.ts))

### AI Integration Types

AI-powered features have dedicated types:

- **`TChatMessage`** / **`TChatMessageRole`** — Chat and suggestion payloads ([`src/ai.ts`](https://github.com/makeplane/plane/blob/main/src/ai.ts))

### Enum Centralization

Core enumerations live in [`src/enums.ts`](https://github.com/makeplane/plane/blob/main/src/enums.ts):

- **`EIssueType`** — Issue classification
- **`EStateGroup`** — State categorization
- **`EStartOfTheWeek`** — Regional calendar preferences

## Package Structure and Entry Point

All type modules funnel through a single export file at [`packages/types/src/index.ts`](https://github.com/makeplane/plane/blob/main/packages/types/src/index.ts):

```ts
export * from "./activity";
export * from "./ai";
export * from "./analytics";
export * from "./api_token";
export * from "./auth";
export * from "./calendar";
export * from "./charts";
export * from "./command-palette";
// ... additional exports
export * from "./workspace";
export * from "./workspace-views";

```

This barrel export pattern enables clean imports throughout the monorepo:

```bash
npm install @plane/types

```

```ts
// Any consumer package
import { IIssue, IWorkspace, TNullable } from "@plane/types";

```

## Summary

- **@plane/types defines 50+ type modules** organized by domain—entities, UI, integrations, and utilities
- **Entry point at [`src/index.ts`](https://github.com/makeplane/plane/blob/main/src/index.ts)** re-exports all modules for single-import consumption
- **Core entity types** (`IIssue`, `IProject`, `IWorkspace`) form the data model foundation
- **Layout and view types** (`IView`, `IViewProps`, `IBaseLayoutKanban`) power the flexible UI system
- **Integration types** support calendar, importer, webhook, and third-party service connections
- **Generic helpers** (`TNullable`, `TPaginationResponse<T>`) provide cross-cutting type utilities

## Frequently Asked Questions

### What is the @plane/types package used for?

The `@plane/types` package provides shared TypeScript type definitions that ensure type safety across Plane's monorepo. Frontend packages like `@plane/ui` and `@plane/editor` import these types to maintain consistency with backend API contracts, eliminating duplication and preventing drift between client and server code.

### How do I import types from @plane/types?

Install the package in your consumer project, then import directly from the package name. The barrel export at [`src/index.ts`](https://github.com/makeplane/plane/blob/main/src/index.ts) makes all types available through a single import path: `import { IIssue, IWorkspace } from "@plane/types"`. No deep imports are required for standard usage.

### Where are the core entity types defined in @plane/types?

Core entities follow a predictable file structure: issues in [`src/issues.ts`](https://github.com/makeplane/plane/blob/main/src/issues.ts), projects in [`src/project/project.ts`](https://github.com/makeplane/plane/blob/main/src/project/project.ts), and workspaces in [`src/workspace.ts`](https://github.com/makeplane/plane/blob/main/src/workspace.ts). Each domain typically exports a full type (e.g., `IIssue`), a lightweight variant (`IIssueLite`), and related filter or activity types.

### Does @plane/types include utility types or only domain models?

The package includes both. Domain-specific types like `IIssue` and `IWorkspace` coexist with generic utilities like `TNullable<T>` and `TPaginationResponse<T>`. These helpers appear in `src/common/` or similar utility directories and support null safety, partial updates, and standardized API response shapes.