Documentation

# NPM
npm install openapi-sync

# Yarn
yarn add openapi-sync

# PNPM
pnpm add openapi-sync

# Global Installation
npm install -g openapi-sync

# Direct Usage (No Installation)
npx openapi-sync

// openapi.sync.json
{
  "refetchInterval": 5000,
  "folder": "./src/api",
  "api": {
    "petstore": "https://petstore3.swagger.io/api/v3/openapi.json"
  }
}

npx openapi-sync

import { getPetById } from "./src/api/petstore/endpoints";
import { IPet } from "./src/api/petstore/types";

// Use the endpoint URL
const petUrl = getPetById("123"); // Returns: "/pet/123"

// Use the generated types
const pet: IPet = {
  id: 1,
  name: "Fluffy",
  status: "available"
};

{
  "$schema": "./node_modules/openapi-sync/openapi.sync.schema.json",
  "preset": "react-query-zod",
  "api": {
    "petstore": "https://petstore3.swagger.io/api/v3/openapi.json"
  }
}

import { defineConfig } from "openapi-sync";

export default defineConfig({
  preset: "react-query-zod",
  api: {
    petstore: "https://petstore3.swagger.io/api/v3/openapi.json",
  },
  // Overrides: User values always take precedence over preset defaults
  folder: "./src/api",
});

// openapi.sync.ts
import { defineConfig } from "openapi-sync";

export default defineConfig({
  api: {
    // 1. Bearer Token
    billingApi: {
      url: "https://api.example.com/billing/openapi.json",
      auth: {
        type: "bearer",
        token: process.env.BILLING_API_TOKEN!,
      },
    },

    // 2. Basic Auth
    internalApi: {
      url: "https://internal.example.com/spec.json",
      auth: {
        type: "basic",
        username: process.env.INTERNAL_USER!,
        password: process.env.INTERNAL_PASSWORD!,
      },
    },

    // 3. API Key in Header or Query
    analyticsApi: {
      url: "https://analytics.example.com/openapi.json",
      auth: {
        type: "apiKey",
        in: "header",
        name: "X-API-Key",
        value: process.env.ANALYTICS_KEY!,
      },
    },

    // 4. Custom Headers
    customApi: {
      url: "https://api.example.com/spec.json",
      auth: {
        type: "custom",
        headers: {
          "X-Organization-Id": "org_12345",
          "X-Api-Secret": process.env.API_SECRET!,
        },
      },
    },

    // 5. Automatic ${env.VAR} placeholder resolution
    // (Automatically reads from .env, .env.local, or next.config.js)
    envResolvedApi: {
      url: "https://api.example.com/spec.json",
      auth: {
        type: "bearer",
        token: "${env.SPEC_ACCESS_TOKEN}",
      },
    },
  },
});

folderSplit: {
  byTags: true  // Creates folders like admin/, user/, pet/
}

folderSplit: {
  customFolder: ({ method, path, tags, operationId }) => {
    // Admin endpoints go to admin folder
    if (tags?.includes("admin")) return "admin";
    
    // API versioning
    if (path.startsWith("/api/v1/")) return "v1";
    if (path.startsWith("/api/v2/")) return "v2";
    
    // Method-based organization
    if (method === "GET") return "read";
    if (method === "POST" || method === "PUT") return "write";
    
    return null; // Use default structure
  }
}

src/api/
├── petstore/
│   ├── admin/
│   │   ├── endpoints.ts
│   │   └── types.ts
│   ├── user/
│   │   ├── endpoints.ts
│   │   └── types.ts
│   └── pet/
│       ├── endpoints.ts
│       └── types.ts
└── shared.ts

validations: {
  library: "zod",  // "zod" | "yup" | "joi"
  generate: {
    query: true,   // Generate query parameter validations
    dto: true      // Generate request body validations
  },
  name: {
    prefix: "I",
    suffix: "Schema",
    useOperationId: true
  }
}

# For Zod
npm install zod

# For Yup
npm install yup

# For Joi
npm install joi

import { IAddPetDTOSchema } from "./src/api/petstore/validation";
import { z } from "zod";

// Validate request body
try {
  const validatedData = IAddPetDTOSchema.parse(req.body);
  // Data is now validated and typed
} catch (error) {
  if (error instanceof z.ZodError) {
    console.error("Validation errors:", error.errors);
  }
}

import { Request, Response, NextFunction } from "express";
import { z } from "zod";

export const validate = <T extends z.ZodTypeAny>(schema: T) => {
  return (req: Request, res: Response, next: NextFunction) => {
    try {
      schema.parse(req.body);
      next();
    } catch (error) {
      if (error instanceof z.ZodError) {
        res.status(400).json({
          error: "Validation failed",
          details: error.errors
        });
      }
    }
  };
};

// Usage
import { IAddPetDTOSchema } from "./api/validation";
router.post("/pet", validate(IAddPetDTOSchema), handler);

customCode: {
  enabled: true,              // Enable custom code preservation
  position: "bottom",         // "top" | "bottom" | "both"
  markerText: "CUSTOM CODE",  // Custom marker text
  includeInstructions: true   // Include helpful instructions
}

// endpoints.ts (after generation)
export const getPet = (petId: string) => `/pet/${petId}`;

// 🔒 CUSTOM CODE START
// Add your custom code here - it will be preserved
export const legacyGetPet = (id: string) => `/api/v1/pet/${id}`;

export const buildPetUrl = (petId: string, includePhotos: boolean) => {
  const base = getPet(petId);
  return includePhotos ? `${base}?include=photos` : base;
};
// 🔒 CUSTOM CODE END

export const updatePet = (petId: string) => `/pet/${petId}`;

endpoints: {
  exclude: {
    // Exclude by tags
    tags: ["deprecated", "internal"],
    
    // Exclude specific endpoints
    endpoints: [
      { path: "/admin/users", method: "DELETE" },
      { regex: "^/internal/.*", method: "GET" },
      { path: "/debug" }  // All methods
    ]
  }
}

endpoints: {
  include: {
    // Include only public endpoints
    tags: ["public"],
    
    // Include specific endpoints
    endpoints: [
      { path: "/public/users", method: "GET" },
      { regex: "^/public/.*" }
    ]
  }
}

// openapi.sync.json or openapi.sync.ts
export default {
  apis: [
    {
      name: "petstore_py",
      url: "https://petstore.swagger.io/v2/swagger.json",
      destination: "./src/api/petstore_py",
      language: "python", // 🐍 Generates types.py and endpoints.py
      folderSplit: {
        byTags: true
      }
    }
  ]
};

from dataclasses import dataclass
from typing import Optional, List, Union, Dict, Any

@dataclass
class Pet:
    """Pet model schema
    
    Attributes:
        id: Unique identifier for the pet
        name: Name of the pet
        category: Pet category
        status: Pet status in the store
    """
    id: Optional[int] = None
    name: Optional[str] = None
    category: Optional["Category"] = None
    status: Optional[str] = None

@dataclass
class GetPetByIdQuery:
    include_deleted: Optional[bool] = None

class Endpoint:
    def __init__(self, name: str, path: str, method: str, url):
        self.name = name
        self.path = path
        self.method = method
        self.url = url

class Endpoints:
    GET_PET_BY_ID = Endpoint(
        name="getPetById",
        path="/pet/{petId}",
        method="GET",
        url=lambda petId: f"/pet/{petId}"
    )

# Generate Fetch client
npx openapi-sync generate-client --type fetch

# Generate Axios client
npx openapi-sync generate-client --type axios

# Generate React Query hooks
npx openapi-sync generate-client --type react-query

# Generate SWR hooks
npx openapi-sync generate-client --type swr

# Generate RTK Query API
npx openapi-sync generate-client --type rtk-query

# Filter by tags
npx openapi-sync generate-client --type fetch --tags pets,users

# Filter by endpoint names
npx openapi-sync generate-client --type axios --endpoints getPetById,createPet

# Generate for specific API
npx openapi-sync generate-client --type react-query --api petstore

# Specify output directory
npx openapi-sync generate-client --type swr --output ./src/clients

# Set base URL
npx openapi-sync generate-client --type fetch --base-url https://api.example.com

// 1. Generate the client
// npx openapi-sync generate-client --type react-query

// 2. Setup in your app
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import apiClient from "./api/petstore/client/client";

// Configure API client
apiClient.updateConfig({
  baseURL: "https://api.example.com",
  headers: {
    Authorization: "Bearer your-auth-token",
  },
});

const queryClient = new QueryClient();

function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <YourComponent />
    </QueryClientProvider>
  );
}

// 3. Use in components
import { useGetPetById, useCreatePet } from "./api/petstore/client/hooks";

function PetDetails({ petId }: { petId: string }) {
  // Query hook for GET requests
  const { data, isLoading, error } = useGetPetById({ petId });

  // Mutation hook for POST/PUT/PATCH/DELETE
  const createPet = useCreatePet({
    onSuccess: (newPet) => {
      console.log("Pet created:", newPet);
    },
  });

  const handleCreate = () => {
    createPet.mutate({
      data: {
        name: "Fluffy",
        species: "cat",
      },
    });
  };

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <h1>{data?.name}</h1>
      <p>Status: {data?.status}</p>
      <button onClick={handleCreate}>Create New Pet</button>
    </div>
  );
}

import { setApiConfig, getPetById, createPet } from "./api/petstore/client";

// Configure the client
setApiConfig({
  baseURL: "https://api.example.com",
  auth: { token: "your-token" },
  headers: {
    "X-Custom-Header": "value",
  },
});

// Use the client
async function fetchPet(petId: string) {
  try {
    const pet = await getPetById({ petId });
    console.log("Pet:", pet);
  } catch (error) {
    if (error instanceof ApiError) {
      console.error("API Error:", error.statusCode, error.response);
    }
  }
}

async function addNewPet() {
  const newPet = await createPet({
    data: {
      name: "Max",
      species: "dog",
      age: 3,
    },
  });
  console.log("Created:", newPet);
}

import apiClient from "./api/petstore/client";

// Configure the client
apiClient.updateConfig({
  baseURL: "https://api.example.com",
  timeout: 10000,
  headers: {
    "X-App-Version": "1.0.0",
    Authorization: "Bearer your-auth-token",
  },
});

// Use the client
async function example() {
  // GET request
  const pet = await apiClient.getPetById({ petId: "123" });
  
  // POST request
  const newPet = await apiClient.createPet({
    data: {
      name: "Buddy",
      species: "dog",
    },
  });
  
  // PUT request
  await apiClient.updatePet(
    { petId: "123" },
    { name: "Buddy Updated" }
  );
  
  // DELETE request
  await apiClient.deletePet({ petId: "123" });
}

import { useGetPetById, useCreatePet } from "./api/petstore/client/hooks";

function PetProfile({ petId }: { petId: string }) {
  // SWR automatically handles caching, revalidation, and more
  const { data, error, isLoading, mutate } = useGetPetById({ petId });

  const { trigger, isMutating } = useCreatePet();

  const handleCreate = async () => {
    try {
      const newPet = await trigger({
        arg: {
          data: {
            name: "Charlie",
            species: "cat",
          },
        },
      });
      // Revalidate the pet list
      mutate();
    } catch (err) {
      console.error("Failed to create pet:", err);
    }
  };

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error loading pet</div>;

  return (
    <div>
      <h2>{data?.name}</h2>
      <button onClick={handleCreate} disabled={isMutating}>
        {isMutating ? "Creating..." : "Create New Pet"}
      </button>
    </div>
  );
}

// 1. Setup store
import { configureStore } from "@reduxjs/toolkit";
import { apiApi } from "./api/petstore/client/api";

export const store = configureStore({
  reducer: {
    [apiApi.reducerPath]: apiApi.reducer,
  },
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware().concat(apiApi.middleware),
});

// 2. Use in components
import { useGetPetByIdQuery, useCreatePetMutation } from "./api/petstore/client/api";

function PetCard({ petId }: { petId: string }) {
  const { data, isLoading, error } = useGetPetByIdQuery({ 
    params: { petId } 
  });
  
  const [createPet, { isLoading: isCreating }] = useCreatePetMutation();

  const handleCreate = async () => {
    try {
      await createPet({
        data: {
          name: "Luna",
          species: "cat",
        },
      }).unwrap();
      alert("Pet created!");
    } catch (err) {
      console.error("Failed:", err);
    }
  };

  return (
    <div>
      {isLoading && <div>Loading...</div>}
      {error && <div>Error!</div>}
      {data && (
        <div>
          <h3>{data.name}</h3>
          <p>{data.species}</p>
        </div>
      )}
      <button onClick={handleCreate} disabled={isCreating}>
        Create Pet
      </button>
    </div>
  );
}

api/
└── petstore/
    ├── client/
    │   ├── client.ts      # Base API client
    │   ├── hooks.ts       # React Query/SWR hooks
    │   ├── api.ts         # RTK Query API (if applicable)
    │   ├── index.ts       # Exports
    │   └── README.md      # Usage documentation
    ├── endpoints.ts
    ├── types/
    │   ├── index.ts
    │   └── shared.ts
    └── validations.ts

// openapi.sync.ts
import { IConfig } from "openapi-sync/types";

const config: IConfig = {
  folder: "./src/api",
  api: {
    petstore: "https://petstore3.swagger.io/api/v3/openapi.json",
  },
  // Client generation configuration
  clientGeneration: {
    enabled: true,
    type: "react-query",
    baseURL: "https://api.example.com",
    tags: ["pets", "users"],  // Optional: filter by tags
    endpoints: ["getPetById"], // Optional: specific endpoints
    auth: {
      type: "bearer",
      in: "header",
    },
    errorHandling: {
      generateErrorClasses: true,
    },
    reactQuery: {
      version: 5,
      mutations: true,
      infiniteQueries: false,
    },
  },
};

export default config;

// client.ts (Generated)

// Auto-generated client code...

// ============================================================
// 🔒 CUSTOM CODE START
// Add your custom code below this line
// This section will be preserved during regeneration
// ============================================================

// Your custom helper functions
export function buildPaginatedUrl(
  baseUrl: string,
  page: number,
  limit: number
) {
  return `${baseUrl}?page=${page}&limit=${limit}`;
}

// Custom interceptors
export function setupCustomInterceptors() {
  // Your custom logic
}

// 🔒 CUSTOM CODE END
// ============================================================

// Before v5.0.0 (Complex setup)
import { configureStore } from '@reduxjs/toolkit';
import { petsApi } from './pets/api';
import { usersApi } from './users/api';
import { ordersApi } from './orders/api';

export const store = configureStore({
  reducer: {
    [petsApi.reducerPath]: petsApi.reducer,
    [usersApi.reducerPath]: usersApi.reducer,
    [ordersApi.reducerPath]: ordersApi.reducer,
  },
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware()
      .concat(petsApi.middleware)
      .concat(usersApi.middleware)
      .concat(ordersApi.middleware),
});

// After v5.0.0 (Simple setup!)
import { configureStore } from '@reduxjs/toolkit';
import { setupApiStore } from './api/petstore/apis';

export const store = configureStore({
  reducer: setupApiStore.reducer,
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware().concat(setupApiStore.middleware),
});

// That's it! All API slices are automatically configured ✨

// Generated pets/api.ts
const petsApi = createApi({
  reducerPath: 'petsApi',  // ✅ Unique!
  // ...
});

// Generated users/api.ts
const usersApi = createApi({
  reducerPath: 'usersApi',  // ✅ Unique!
  // ...
});

// No more "Duplicate property" TypeScript errors!

// Clean default import
import petsApi from './pets/api';
import { useGetPetsQuery } from './pets/api';

// Or use the aggregated apis.ts
import { petsApi, useGetPetsQuery } from './apis';

// v5.0.0 - Correct types! ✅
export function useCreatePet(
  config?: SWRMutationConfiguration<
    Pet,
    Error,
    string,
    { data: PetRequest }  // Correct: single level
  >
) {
  return useSWRMutation(
    'createPet',
    async (_, { arg }: { arg: { data: PetRequest } }) => {
      return apiClient.createPet(arg);
    },
    config
  );
}

// Usage - works perfectly!
const { trigger } = useCreatePet();
await trigger({ arg: { data: { name: 'Fluffy' } } });

/**
 * SWR Hooks - Complete Usage Guide
 * 
 * ## Quick Start
 * 
 * 1. Configure SWR globally:
 * ```typescript
 * <SWRConfig value={{ revalidateOnFocus: false }}>
 *   {children}
 * </SWRConfig>
 * ```
 * 
 * ## Examples
 * 
 * ### Reading Data (GET)
 * ```typescript
 * const { data, error, isLoading } = useGetPets();
 * ```
 * 
 * ### Creating Data (POST)
 * ```typescript
 * const { trigger, isMutating } = useCreatePet();
 * await trigger({ arg: { data: { name: 'Luna' } } });
 * ```
 * 
 * ### Optimistic Updates
 * ```typescript
 * revalidate({ ...data, name: newName }, false);
 * await trigger({ arg: { ... } });
 * await revalidate(); // Sync with server
 * ```
 * 
 * [... 200+ more lines of examples ...]
 */

// Generated imports (aliased to avoid conflicts)
import {
  getPets as getPets_endpoint,
  getPetById as getPetById_endpoint,
  createPet as createPet_endpoint,
} from './endpoints';

// Generated functions (no conflict!)
export async function getPets() {
  const _url = getPets_endpoint;  // Uses aliased import
  return fetchAPI(_url, { method: 'GET' });
}

export async function getPetById(params: { url: { id: string } }) {
  const _url = getPetById_endpoint(params.url.id);  // Uses aliased import
  return fetchAPI(_url, { method: 'GET' });
}

// v5.0.0 - ESLint compliant! ✅
const apiClient = {
  setApiConfig,
  getPets,
  getPetById,
  createPet,
};

export default apiClient;

// No more "Assign object to variable" ESLint warnings!

api/
└── petstore/
    ├── clients.ts       # All API client functions
    ├── hooks.ts         # All React Query/SWR hooks  
    ├── endpoints.ts     # Endpoint definitions
    ├── types.ts         # TypeScript types
    └── validations.ts   # Validation schemas

# Clean, simple structure for smaller APIs!

api/
└── petstore/
    ├── clients.ts       # Aggregates all clients (Fetch/Axios)
    ├── hooks.ts         # Aggregates all hooks (React Query/SWR)
    ├── apis.ts          # Aggregates all APIs (RTK Query) + setupApiStore
    ├── pets/
    │   ├── client.ts    # Pet-specific client
    │   ├── hooks.ts     # Pet-specific hooks
    │   ├── api.ts       # Pet-specific RTK Query API
    │   ├── types.ts     # Pet-specific types
    │   └── endpoints.ts # Pet-specific endpoints
    └── users/
        ├── client.ts
        ├── hooks.ts
        ├── api.ts
        ├── types.ts
        └── endpoints.ts

# Perfect for large APIs with many endpoints!

# Sync API types and endpoints
npx openapi-sync

# Generate API client
npx openapi-sync generate-client --type react-query

# Run with custom refetch interval
npx openapi-sync --refreshinterval 30000
npx openapi-sync -ri 30000

# Get help
npx openapi-sync --help
npx openapi-sync generate-client --help

# Standard non-interactive setup
npx openapi-sync init --no-interactive \
  --api-name petstore \
  --api-url https://petstore3.swagger.io/api/v3/openapi.json \
  --output-folder ./src/api \
  --client-type react-query \
  --validation-library zod \
  --config-format typescript \
  --json

# Initialize with authentication for protected specs
npx openapi-sync init --no-interactive \
  --api-name backend \
  --api-url https://api.example.com/openapi.json \
  --auth-type bearer \
  --auth-token '${env.SPEC_TOKEN}' \
  --preset react-query-zod \
  --run-sync \
  --json

# Zero-config sync with preset
npx openapi-sync --api-url https://petstore3.swagger.io/api/v3/openapi.json --preset react-query-zod --folder ./src/api

# Zero-config sync with protected spec
npx openapi-sync --api-url https://api.example.com/openapi.json --auth-type bearer --auth-token "$MY_TOKEN" --preset next-fetch

# Multiple APIs via CLI
npx openapi-sync --api users=https://api.example.com/users.json --api billing=https://api.example.com/billing.json --preset axios-zod

# Override existing disk config properties on-the-fly
npx openapi-sync --folder ./dist/api --validation-lib yup --no-docs

# Raw JSON configuration via CLI
npx openapi-sync --config-json '{"api":{"main":"https://api.example.com/spec.json"},"preset":"react-query-zod"}'

# Config file says type: "fetch"
# But CLI argument takes precedence:
npx openapi-sync generate-client --type rtk-query

# Result: Generates RTK Query (not Fetch) ✅

# This works for all options:
npx openapi-sync generate-client \
  --type swr \
  --base-url https://api.example.com \
  --tags pets,users

# CLI values override config values!

# npx openapi-sync init

? Organize generated code into folders by OpenAPI tags? Yes
# ✅ Automatically enables byTags: true
# (No extra question needed!)

? Generate API client code? Yes
? Which client type would you like? React Query
# ... continues with setup

# Sync and get a structured JSON result
npx openapi-sync --json

# Validate config without writing files
npx openapi-sync validate --json

# List all endpoints as JSON
npx openapi-sync list-endpoints --json

# Page/search endpoint discovery for large specs
npx openapi-sync list-endpoints --api petstore --path-contains pet --limit 10 --offset 0 --json

# Inspect one endpoint in full detail
npx openapi-sync get-endpoint --api petstore --operation-id getPetById --json

# Read one generated TypeScript declaration
npx openapi-sync read-type --api petstore --type-name Pet --json

# Generate client with JSON output (great for agents)
npx openapi-sync generate-client --type react-query --json

# Silent mode (no stdout noise) — exit code tells you the result
npx openapi-sync --silent && echo "Sync OK!"

# Run the human-readable diagnostic report
npx openapi-sync doctor

# Machine-readable output for CI/CD checks or AI agents
npx openapi-sync doctor --json

{
  "healthy": true,
  "checks": [
    { "name": "Configuration", "status": "ok", "message": "Valid openapi.sync.ts found" },
    { "name": "Spec Reachability: petstore", "status": "ok", "message": "HTTP 200 OK (20 endpoints discovered)" },
    { "name": "Peer Dependency: zod", "status": "ok", "message": "zod v3.23.8 installed" },
    { "name": "Output Directory", "status": "ok", "message": "./src/api is writable" }
  ],
  "recommendations": []
}

# Preview stale files without deleting anything
npx openapi-sync purge --dry-run

# Output preview as machine-readable JSON
npx openapi-sync purge --dry-run --json

# Delete stale files without interactive confirmation (CI & Agent-safe)
npx openapi-sync purge --yes

# Limit stale cleanup to a specific configured API
npx openapi-sync purge --api petstore --yes

import { Init, GenerateClient } from "openapi-sync";

// 1. Sync types, endpoints, and validation schemas
const syncResult = await Init({ silent: true });
if (syncResult.success) {
  console.log("Files written:", syncResult.filesWritten);
  console.log("Endpoints synchronized:", syncResult.endpointCount);
}

// 2. Generate a typed API client programmatically
const clientResult = await GenerateClient({
  type: "react-query", // "fetch" | "axios" | "react-query" | "swr" | "rtk-query"
  silent: true,
});
console.log("Client files written:", clientResult.filesWritten);

import {
  ValidateConfig,
  ListEndpoints,
  GetEndpointDetails,
  ReadGeneratedType,
} from "openapi-sync";

// Pre-flight validation (no files written)
const validation = await ValidateConfig({ silent: true });
console.log("Config valid?", validation.valid);

// Search & paginate endpoints
const endpoints = await ListEndpoints({
  apiName: "petstore",
  pathContains: "pet",
  limit: 10,
  offset: 0,
  silent: true,
});
console.log("Found endpoints:", endpoints.petstore);

// Deep inspection of a single endpoint
const detail = await GetEndpointDetails({
  apiName: "petstore",
  operationId: "getPetById",
  silent: true,
});
console.log("Method:", detail.endpoint.method);
console.log("Parameters:", detail.endpoint.parameters);

// Read exact generated TypeScript interface
const typeDecl = await ReadGeneratedType({
  apiName: "petstore",
  typeName: "Pet",
  silent: true,
});
console.log(typeDecl);

import { Doctor, Purge } from "openapi-sync";

// 1. Run diagnostic health checks
const report = await Doctor({ silent: true });
console.log("System healthy?", report.healthy);
if (!report.healthy) {
  console.warn("Recommendations:", report.recommendations);
}

// 2. Detect and purge stale generated files
const purgeReport = await Purge({ yes: true, silent: true });
console.log("Removed stale files:", purgeReport.purged);

{
  "mcpServers": {
    "openapi-sync": {
      "command": "npx",
      "args": ["-y", "openapi-sync-mcp"],
      "cwd": "${workspaceFolder}"
    }
  }
}

{
  "mcpServers": {
    "openapi-sync": {
      "command": "npx",
      "args": ["-y", "openapi-sync-mcp"],
      "cwd": "/path/to/your/project"
    }
  }
}

{
  "mcpServers": {
    "openapi-sync": {
      "command": "npx",
      "args": ["-y", "openapi-sync-mcp"]
    }
  }
}

{
  "context_servers": [
    {
      "name": "openapi-sync",
      "command": {
        "path": "npx",
        "args": ["-y", "openapi-sync-mcp"]
      }
    }
  ]
}

{
  "mcpServers": {
    "openapi-sync": {
      "command": "npx",
      "args": ["-y", "openapi-sync-mcp"]
    }
  }
}

# Prompt in Cursor Agent or Claude Desktop:
"We need to implement the billing page. Use openapi-sync to find all subscription-related endpoints, inspect the checkout session schema, and generate a React Query client."

# Autonomous Multi-Turn Execution Flow:
# 1. Calls 'openapi_sync_read_config' to check configured API sources
# 2. Calls 'openapi_sync_list_endpoints' with pathContains: "subscription"
# 3. Calls 'openapi_sync_get_endpoint_details' for operationId "createCheckoutSession"
# 4. Calls 'openapi_sync_read_generated_type' for "CreateCheckoutSessionDTO"
# 5. Calls 'openapi_sync_generate_client' with type: "react-query"
# 6. Builds the frontend UI using the exact generated types and hooks!

import { Init } from "openapi-sync";

await Init({ 
  refetchInterval: 10000 
});

import {
  IConfig,
  IOpenApiSpec,
  IOpenApSchemaSpec,
  IConfigReplaceWord,
  IConfigExclude,
  IConfigInclude,
  IConfigDoc
} from "openapi-sync/types";