TypeScript Type Generation

Generate TypeScript types for the M0 Orchestration API directly from the OpenAPI specification.

Quick Start

npx openapi-typescript https://orchestration-api.m0.xyz/openapi.json -o ./m0-swap.d.ts

This generates a type definition file with full type coverage for all API endpoints, request parameters, and response objects.

Generated Types

The generated file exports types organized by OpenAPI structure:

import type { components, operations } from './m0-swap';
 
// Schema types (most commonly used)
type Asset = components['schemas']['Asset'];
type Quote = components['schemas']['Quote'];
type Order = components['schemas']['Order'];
type OrdersResponse = components['schemas']['OrdersResponse'];
type OrderStatus = components['schemas']['OrderStatus'];
type Route = components['schemas']['Route'];
type Chain = components['schemas']['Chain'];
type Payload = components['schemas']['Payload'];
type EvmPayload = components['schemas']['EvmPayload'];
type SvmPayload = components['schemas']['SvmPayload'];
 
// Operation types (for request/response typing)
type QuoteRequest = operations['quote_quote']['requestBody']['content']['application/json'];
type QuoteResponse = operations['quote_quote']['responses']['200']['content']['application/json'];

Usage with fetch

Create a typed wrapper for API calls:

import type { components } from './m0-swap';
 
type Quote = components['schemas']['Quote'];
type Asset = components['schemas']['Asset'];
type Order = components['schemas']['Order'];
type OrdersResponse = components['schemas']['OrdersResponse'];
 
const API_BASE = 'https://orchestration-api.m0.xyz';
 
export async function getQuotes(params: {
  route: {
    source: { chain: string; address: string };
    destination: { chain: string; address: string };
  };
  amountIn: string;
  sender: string;
  recipient?: string;
}): Promise<Quote[]> {
  const response = await fetch(`${API_BASE}/quote`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(params),
  });
  return response.json();
}
 
export async function getSupportedAssets(): Promise<Asset[]> {
  const response = await fetch(`${API_BASE}/supported-assets`);
  return response.json();
}
 
export async function getOrders(params?: {
  sender?: string;
  status?: 'CREATED' | 'COMPLETED' | 'CANCELLED';
  originChainId?: number;
  destChainId?: number;
  limit?: number;
  offset?: number;
}): Promise<OrdersResponse> {
  const query = new URLSearchParams();
  if (params?.sender) query.set('sender', params.sender);
  if (params?.status) query.set('status', params.status);
  if (params?.originChainId !== undefined) query.set('originChainId', String(params.originChainId));
  if (params?.destChainId !== undefined) query.set('destChainId', String(params.destChainId));
  if (params?.limit !== undefined) query.set('limit', String(params.limit));
  if (params?.offset !== undefined) query.set('offset', String(params.offset));
 
  const queryString = query.toString();
  const url = queryString ? `${API_BASE}/orders?${queryString}` : `${API_BASE}/orders`;
 
  const response = await fetch(url);
  return response.json();
}
 
export async function getOrderStatus(orderId: string): Promise<Order> {
  const response = await fetch(`${API_BASE}/order-status/${orderId}`);
  return response.json();
}

Type Aliases

For convenience, create a types file that re-exports commonly used types:

// types/m0-swap.ts
import type { components } from './m0-swap.d.ts';
 
export type Asset = components['schemas']['Asset'];
export type Quote = components['schemas']['Quote'];
export type Order = components['schemas']['Order'];
export type OrdersResponse = components['schemas']['OrdersResponse'];
export type OrderStatus = components['schemas']['OrderStatus'];
export type Route = components['schemas']['Route'];
export type AssetAddress = components['schemas']['AssetAddress'];
export type Payload = components['schemas']['Payload'];
export type EvmPayload = components['schemas']['EvmPayload'];
export type SvmPayload = components['schemas']['SvmPayload'];
export type Chain = components['schemas']['Chain'];
export type ChainRuntime = components['schemas']['ChainRuntime'];
export type Providers = components['schemas']['Providers'];
export type QuoteType = components['schemas']['QuoteType'];

Then import from your alias file:

import type { Quote, Asset, EvmPayload } from './types/m0-swap';

Keeping Types Updated

Regenerate types when the API changes:

# Add to package.json scripts
{
  "scripts": {
    "generate:types": "openapi-typescript https://orchestration-api.m0.xyz/openapi.json -o ./src/types/m0-swap.d.ts"
  }
}

pnpm generate:types

openapi-typescript Options

Common options for customization:

# Output to specific directory
npx openapi-typescript https://orchestration-api.m0.xyz/openapi.json -o ./src/types/api.d.ts
 
# Generate with immutable types (readonly)
npx openapi-typescript https://orchestration-api.m0.xyz/openapi.json -o ./api.d.ts --immutable
 
# Export types (for re-exporting)
npx openapi-typescript https://orchestration-api.m0.xyz/openapi.json -o ./api.d.ts --export-type

See the openapi-typescript documentation for more options.

API Reference

For interactive schema exploration and testing, visit the API Reference.