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

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, 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)
• IProject / IProjectLink / IProjectFilters — Project definitions with linking and filter capabilities (src/project/)
• IWorkspace / IWorkspaceMember — Core workspace entity and membership details (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)
• IModule / IModuleFilters — Project module types (src/module.ts)
• IEpic / IEpicLite — Epic-level issue grouping (src/epics.ts)

UI and Layout Types

View System Types

The view system separates display configuration from data queries:

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/preview/packages/types/src/views.ts); IViewProps — [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)
• IGanttLayout / IKanbanLayout — Concrete layout implementations (src/layout.ts)

Command Palette and Navigation

Interactive UI components have strongly-typed contracts:

• ICommand / ICommandGroup — Global command palette definitions (src/command-palette.ts)
• INavigationPreferences — User navigation UI settings (src/navigation-preferences.ts)

Activity and Collaboration Types

Activity Log Types

Activity tracking uses generic, reusable base types:

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/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)
• IUserLite — Minimal reference for lists and foreign keys
• IUserProfile — Extended activity and preference data

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/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)
• 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)

Webhook Types

Outgoing event notifications:

• IWebhook / IWebhookPayload — Webhook configuration and delivery contracts (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)

Rich Filter DSL

Advanced query building with type-safe operators:

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/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)

AI Integration Types

AI-powered features have dedicated types:

• TChatMessage / TChatMessageRole — Chat and suggestion payloads (src/ai.ts)

Enum Centralization

Core enumerations live in 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:

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:

npm install @plane/types

// 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 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 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, projects in src/project/project.ts, and workspaces in 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}