Skip to main content
@ooneex/types is a types-only package that collects the common type definitions, unions, and interfaces shared across Ooneex packages. It has no runtime code, so importing from it adds nothing to your bundle. Use it to keep entity shapes, status values, HTTP methods, and paginated results consistent everywhere.

​
Installation

Add the package with Bun. 
bun add @ooneex/types

​
Usage

Because the package only ships types, you import them with import type and use them to annotate your own values, functions, and entities. Use IBase as the common shape for persisted entities, and StatusType to constrain a record’s lifecycle state to a known set of values. 
import type { IBase, StatusType } from "@ooneex/types";

interface Article extends IBase {
  title: string;
  status: StatusType;
}

const article: Article = {
  id: "art_123",
  title: "Hello world",
  status: "draft", // "draft" | "pending" | "active" | "archived" | ...
  isPublic: true,
  createdAt: new Date(),
};
Use FilterResultType<T> to type the response of any paginated list endpoint, and HttpMethodType (backed by the HTTP_METHODS tuple) to constrain request methods. 
import type { FilterResultType, HttpMethodType } from "@ooneex/types";

const listArticles = async (): Promise<FilterResultType<Article>> => {
  const resources = await fetchArticles();
  return {
    resources,
    total: 240,
    totalPages: 12,
    page: 1,
    limit: 20,
  };
};

const method: HttpMethodType = "POST"; // "GET" | "POST" | "PUT" | "DELETE" | ...
ScalarType is a handy union for primitive values, useful when typing loosely-structured records like query params or config maps. 
import type { ScalarType } from "@ooneex/types";

// boolean | number | bigint | string
const params: Record<string, ScalarType> = {
  page: 1,
  active: true,
  query: "ooneex",
};

​
When to use it

  • You are building an Ooneex package or app and want entity shapes (IBase), lifecycle states (StatusType), or paginated responses (FilterResultType<T>) to match across services.
  • You need a ready-made union for HTTP methods (HttpMethodType), content encodings (EncodingType), charsets (CharsetType), or primitive scalars (ScalarType).
  • You want shared types with zero runtime cost, since the package contains no executable code.
  • You don’t need it for one-off local types that aren’t shared between packages — define those inline instead.