@powerduck/openapi-codegen 0.5.0 → 0.5.2

package/README.md

@@ -1,90 +1,36 @@
 # @powerduck/openapi-codegen
 
-Generate runnable HTTP request examples from OpenAPI documents for **21 languages** and **41 language/client combinations**.
+Generate runnable HTTP request examples from OpenAPI documents. Supports 21 languages and 41 language/client combinations. Browser-compatible, zero runtime dependencies.
 
-`@powerduck/openapi-codegen` is a high-performance, browser-compatible TypeScript library for API documentation systems, developer portals, API explorers, command-line tools, and build-time code generation.
+[![npm version](https://img.shields.io/npm/v/@powerduck/openapi-codegen)](https://www.npmjs.com/package/@powerduck/openapi-codegen)
+[![license](https://img.shields.io/npm/l/@powerduck/openapi-codegen)](https://github.com/PowerDuckie/openapi-codegen/blob/main/LICENSE)
 
-## Features
+## Links
 
-- **Zero runtime dependencies** — works in browser, Node.js, Electron, and edge environments
-- **Dual module support** — native ESM and CommonJS (`require()`)
-- **OpenAPI 3.0, 3.1, and 3.2** support
-- **41 built-in generators** across 21 languages
-- **Parameter serialization** — path, query, header, cookie with full OpenAPI style support
-- **Security schemes** — API key, HTTP bearer, HTTP basic
-- **Body types** — JSON, plain-text, URL-encoded form, multipart form-data
-- **$ref resolution** — in-document JSON Pointer references with circular detection
-- **Example generation** — automatic example values from JSON Schema
-- **TypeScript declarations** — full type safety
-- **Highly optimized** — no `JSON.parse`/`JSON.stringify` deep cloning, structured reference handling
-
-## Supported Languages and Clients
-
-Use the exact `language` and `client` identifiers shown below when calling `generate()`. Identifiers are case-sensitive.
-
-| Language          | `language`   | Supported `client` values                                         |
-| ----------------- | ------------ | ----------------------------------------------------------------- |
-| C                 | `c`          | `libcurl`                                                         |
-| C#                | `csharp`     | `httpclient`, `restsharp`                                         |
-| Clojure           | `clojure`    | `clj-http`                                                        |
-| Dart              | `dart`       | `http`                                                            |
-| F#                | `fsharp`     | `httpclient`                                                      |
-| Go                | `go`         | `new-request`                                                     |
-| HTTP request file | `http`       | `http1`                                                           |
-| Java              | `java`       | `asynchttp`, `java-net-http`, `okhttp`, `unirest`                 |
-| JavaScript        | `javascript` | `fetch`, `axios`, `ofetch`, `jquery`, `xhr`                       |
-| Kotlin            | `kotlin`     | `okhttp`                                                          |
-| Node.js           | `node`       | `fetch`, `axios`, `ofetch`, `undici`                              |
-| Objective-C       | `objc`       | `nsurlsession`                                                    |
-| OCaml             | `ocaml`      | `cohttp`                                                          |
-| PHP               | `php`        | `curl`, `guzzle`, `laravel-http`                                  |
-| PowerShell        | `powershell` | `invoke-webrequest`, `invoke-restmethod`                          |
-| Python            | `python`     | `http-client`, `requests`, `aiohttp`, `httpx-sync`, `httpx-async` |
-| R                 | `r`          | `httr2`                                                           |
-| Ruby              | `ruby`       | `net-http`                                                        |
-| Rust              | `rust`       | `reqwest`                                                         |
-| Shell             | `shell`      | `curl`, `wget`, `httpie`                                          |
-| Swift             | `swift`      | `nsurlsession`                                                    |
-
-> Generator availability does not imply that every client can represent every OpenAPI operation. For example, GNU Wget cannot safely construct arbitrary `multipart/form-data` requests. Use `shell/curl` or `shell/httpie` for multipart uploads.
-
-## Requirements
-
-- Node.js 18 or later (for Node.js usage)
-- A parsed OpenAPI document (JavaScript object)
-- Modern browser with Fetch API (for browser usage)
-
-## Installation
-
-Using npm:
+- [Official Website](https://www.powerduck.com/opensource/openapi-codegen.html)
+- [Documentation](https://www.powerduck.com/docs/openapi-codegen/introduction)
+- [Live Demo](https://www.powerduck.com/demo/openapi-codegen.html)
+- [GitHub](https://github.com/PowerDuckie/openapi-codegen)
+- [npm](https://www.npmjs.com/package/@powerduck/openapi-codegen)
 
-```bash
-npm install @powerduck/openapi-codegen
-```
+---
 
-Using pnpm:
-
-```bash
-pnpm add @powerduck/openapi-codegen
-```
+## Quick Start
 
-Using Yarn:
+### Install
 
 ```bash
-yarn add @powerduck/openapi-codegen
+npm install @powerduck/openapi-codegen
 ```
 
-## Quick Start
-
-### ESM (import)
+### Generate from a document
 
 ```typescript
 import { generate } from "@powerduck/openapi-codegen";
-import document from "./openapi.json" with { type: "json" };
 
 const code = generate({
-  document,
-  path: "/users/{id}",
+  document: openApiDocument,
+  path: "/pets/{id}",
   method: "get",
   language: "javascript",
   client: "fetch",
@@ -93,7 +39,7 @@ const code = generate({
 console.log(code);
 ```
 
-### CommonJS (require)
+### CommonJS equivalent
 
 ```javascript
 const { generate } = require("@powerduck/openapi-codegen");
@@ -103,8 +49,8 @@ const document = JSON.parse(fs.readFileSync("./openapi.json", "utf8"));
 
 const code = generate({
   document,
-  path: "/users/{id}",
-  method: "get",
+  path: "/pets",
+  method: "post",
   language: "python",
   client: "requests",
 });
@@ -112,68 +58,7 @@ const code = generate({
 console.log(code);
 ```
 
-`generate()` returns the generated source code as a string.
-
-## Authentication
-
-Provide credentials through `securityValues`:
-
-```typescript
-import { generate } from "@powerduck/openapi-codegen";
-
-const code = generate({
-  document,
-  path: "/users/{id}",
-  method: "get",
-  language: "javascript",
-  client: "fetch",
-  securityValues: {
-    bearerAuth: "YOUR_ACCESS_TOKEN",
-    apiKey: "YOUR_API_KEY",
-  },
-});
-
-console.log(code);
-```
-
-The keys in `securityValues` must match the security scheme names defined in the OpenAPI document.
-
-**Security note:** Do not commit real credentials to source control.
-
-## Multipart Uploads
-
-```typescript
-import { generate } from "@powerduck/openapi-codegen";
-
-const code = generate({
-  document,
-  path: "/upload/{id}",
-  method: "post",
-  language: "shell",
-  client: "curl",
-  securityValues: {
-    bearerAuth: "YOUR_ACCESS_TOKEN",
-  },
-});
-
-console.log(code);
-```
-
-Generated multipart examples may include placeholder file paths:
-
-```text
-/tmp/file.bin
-```
-
-Replace all placeholder paths before running the generated code.
-
-Some clients cannot safely represent every OpenAPI request. Generation may throw a descriptive error when the selected client is incompatible with an operation.
-
-For example, `shell/wget` does not support arbitrary multipart generation. Use `shell/curl` or `shell/httpie` instead.
-
-## Discover Available Generators
-
-Use `list()` to inspect every installed language/client combination:
+### List available generators
 
 ```typescript
 import { list } from "@powerduck/openapi-codegen";
@@ -183,38 +68,28 @@ for (const { language, client } of list()) {
 }
 ```
 
-You can also select a generator programmatically:
+### Provide credentials
 
 ```typescript
-import { generate, list } from "@powerduck/openapi-codegen";
-
-const generator = list().find(
-  ({ language, client }) => language === "javascript" && client === "fetch",
-);
-
-if (!generator) {
-  throw new Error("The requested generator is not available");
-}
-
 const code = generate({
   document,
-  path: "/users",
+  path: "/pets/{id}",
   method: "get",
-  language: generator.language,
-  client: generator.client,
+  language: "javascript",
+  client: "fetch",
+  securityValues: {
+    bearerAuth: "YOUR_ACCESS_TOKEN",
+    apiKey: "YOUR_API_KEY",
+  },
 });
-
-console.log(code);
 ```
 
-## Custom Server URL
-
-Override the server URL from the OpenAPI document:
+### Override the server URL
 
 ```typescript
 const code = generate({
   document,
-  path: "/users",
+  path: "/pets",
   method: "get",
   language: "shell",
   client: "curl",
@@ -222,363 +97,307 @@ const code = generate({
 });
 ```
 
-## API Reference
-
-### `generate(options)`
-
-Generates an HTTP request example for an OpenAPI operation.
-
-```typescript
-const code = generate({
-  document,
-  path,
-  method,
-  language,
-  client,
-  securityValues,
-  serverUrl,
-  softRefMode,
-});
-```
-
-#### Options
+---
 
-| Option           | Type                          | Required | Description                                  |
-| ---------------- | ----------------------------- | -------: | -------------------------------------------- |
-| `document`       | `unknown` (OpenAPI object)    |      Yes* | Parsed OpenAPI document                      |
-| `path`           | `string`                      |      Yes* | Exact OpenAPI path template                  |
-| `method`         | `string`                      |      Yes* | HTTP operation method                        |
-| `language`       | `string`                      |      Yes | Target language identifier                   |
-| `client`         | `string`                      |      Yes | Target HTTP client identifier                |
-| `securityValues` | `Record<string, string>`      |       No | Credentials for named security schemes       |
-| `serverUrl`      | `string`                      |       No | Override server URL from document            |
-| `softRefMode`    | `boolean`                     |       No | Soft mode for $ref resolution (no throws)    |
-| `request`        | `RequestIR`                   |      Yes* | Pre-normalized request (alternative to doc)  |
-
-\* Either `document` + `path` + `method` OR `request` must be provided.
+## Features
 
-#### Return Value
+- **21 languages, 41 clients** — JavaScript, Python, Go, Java, Ruby, PHP, C#, Rust, Swift, Kotlin, Dart, and more
+- **Full OpenAPI parameter serialization** — path, query, header, cookie parameters with style/explode rules (form, spaceDelimited, pipeDelimited, label, matrix, simple, deepObject)
+- **All body types** — JSON, form-urlencoded, multipart/form-data (text + file fields), XML, text, binary
+- **Security resolution** — Bearer, Basic, API key (header/query/cookie), with `securityValues` for credentials
+- **`$ref` resolution** — in-document JSON Pointer resolution with soft mode for broken/circular refs
+- **Example generation** — generates realistic example values from JSON Schema (respects `example`, `enum`, `const`, `default`, `oneOf`/`anyOf`/`allOf`, types, formats, constraints)
+- **Plugin system** — register custom generators through a simple plugin API
+- **Direct RequestIR** — skip normalization entirely by building a `RequestIR` yourself
+- **Browser-compatible** — zero Node.js dependencies, works in browsers, Edge Functions, and Node.js
+- **Dual ESM/CJS builds** — works with `import` and `require`, with bundled TypeScript declarations
 
-Returns the generated source code as a `string`.
+---
 
-#### Errors
+## GenerateOptions
 
-Generation can throw when:
+```typescript
+interface GenerateOptions {
+  language: string;       // Target language identifier (case-sensitive)
+  client: string;         // Target HTTP client identifier
+  request?: RequestIR;    // Pre-normalized request; skips normalize
+  document?: unknown;     // A parsed OpenAPI document object
+  path?: string;          // Exact OpenAPI path template, e.g. "/pets/{id}"
+  method?: string;        // HTTP method, e.g. "get" / "post"
+  serverUrl?: string;     // Override the server URL from the document
+  securityValues?: Record<string, string>; // Credentials keyed by security scheme name
+  softRefMode?: boolean;  // Do not throw on broken/circular $refs
+}
+```
 
-- The requested path or operation does not exist
-- The language/client combination is unknown
-- The OpenAPI document is invalid or unsupported
-- Required generation data cannot be resolved
-- The selected client cannot safely represent the request
-- A circular $ref is detected (unless `softRefMode` is enabled)
+> Either `request` alone, or `document` + `path` + `method`, must be provided. When `request` is supplied, `document`, `path`, `method`, `serverUrl`, `securityValues`, and `softRefMode` are ignored.
 
-Handle errors when processing untrusted documents or user-selected generators:
+### Input validation errors
 
-```typescript
-try {
-  const code = generate({
-    document,
-    path: "/users/{id}",
-    method: "get",
-    language: "javascript",
-    client: "fetch",
-  });
+`generate()` throws when required input is missing:
 
-  console.log(code);
-} catch (error) {
-  const message = error instanceof Error ? error.message : String(error);
+- `TypeError: generate() requires an options object`
+- `Error: Unsupported generator: <language>/<client>`
+- `TypeError: generate() requires either a 'request' or a 'document' option`
+- `TypeError: generate() requires a 'path' option when using 'document'`
+- `TypeError: generate() requires a 'method' option when using 'document'`
 
-  console.error(`Generation failed: ${message}`);
-  process.exitCode = 1;
-}
-```
+---
 
-### `list()`
+## Top-level API
 
-Returns the available generator descriptors:
+| Export | Signature | Description |
+|---|---|---|
+| `generate` | `(options: GenerateOptions) => string` | Generate runnable source code for one operation |
+| `register` | `(generator: Generator) => void` | Register a custom generator |
+| `get` | `(language: string, client: string) => Generator \| undefined` | Look up a generator |
+| `list` | `() => Array<{ language: string; client: string }>` | List all registered generators |
+| `use` | `(plugin: Plugin) => void` | Apply a plugin that registers generators |
+| `registerBuiltins` | `() => void` | Register all built-in generators (auto-called on import) |
+| `normalize` | `(options) => NormalizedRequest` | Turn a document + path + method into a normalized request |
+| `builtinGenerators` | `Generator[]` | The raw array of all built-in generator definitions |
 
-```typescript
-const generators = list();
-```
+Built-ins are registered automatically when the module loads, so calling `registerBuiltins()` manually is optional.
 
-Each descriptor contains:
+---
 
-```typescript
-interface GeneratorDescriptor {
-  language: string;
-  client: string;
-}
-```
+## Built-in Generators (21 languages, 41 clients)
 
-### `get(language, client)`
+| Language | `language` | `client` values |
+|---|---|---|
+| C | `c` | `libcurl` |
+| C# | `csharp` | `httpclient`, `restsharp` |
+| Clojure | `clojure` | `clj-http` |
+| Dart | `dart` | `http` |
+| F# | `fsharp` | `httpclient` |
+| Go | `go` | `new-request` |
+| HTTP request file | `http` | `http1` |
+| Java | `java` | `asynchttp`, `java-net-http`, `okhttp`, `unirest` |
+| JavaScript | `javascript` | `axios`, `fetch`, `jquery`, `ofetch`, `xhr` |
+| Kotlin | `kotlin` | `okhttp` |
+| Node.js | `node` | `axios`, `fetch`, `ofetch`, `undici` |
+| Objective-C | `objc` | `nsurlsession` |
+| OCaml | `ocaml` | `cohttp` |
+| PHP | `php` | `curl`, `guzzle`, `laravel-http` |
+| PowerShell | `powershell` | `invoke-restmethod`, `invoke-webrequest` |
+| Python | `python` | `aiohttp`, `http-client`, `httpx-async`, `httpx-sync`, `requests` |
+| R | `r` | `httr2` |
+| Ruby | `ruby` | `net-http` |
+| Rust | `rust` | `reqwest` |
+| Shell | `shell` | `curl`, `httpie`, `wget` |
+| Swift | `swift` | `nsurlsession` |
 
-Returns a specific generator by language and client, or `undefined` if not found:
+> Generator availability does not mean every client can represent every operation. For example, `shell/wget` cannot safely build arbitrary `multipart/form-data` requests; use `shell/curl` or `shell/httpie` instead.
 
-```typescript
-const generator = get("javascript", "fetch");
-```
+---
 
-### `register(generator)`
+## Custom Generator
 
-Register a custom generator:
+Implement the `Generator` interface and call `register`:
 
 ```typescript
-import { register } from "@powerduck/openapi-codegen";
+import { register, generate } from "@powerduck/openapi-codegen";
+import type { RequestIR } from "@powerduck/openapi-codegen";
 
 register({
-  language: "custom",
+  language: "mylang",
   client: "my-client",
-  generate: (request) => {
-    // Custom generation logic
-    return "// Custom generated code";
+  generate(request: RequestIR): string {
+    return [
+      `// ${request.method} ${request.baseUrl}${request.path}`,
+      `mylang.request(${JSON.stringify({
+        method: request.method,
+        url: request.baseUrl + request.path,
+      })})`,
+    ].join("\n");
   },
 });
-```
-
-## OpenAPI Document Input
-
-Pass a parsed JavaScript object rather than a JSON or YAML source string.
-
-### JSON
-
-```typescript
-import { readFile } from "node:fs/promises";
-import { generate } from "@powerduck/openapi-codegen";
-
-const source = await readFile("./openapi.json", "utf8");
-const document = JSON.parse(source);
 
 const code = generate({
   document,
-  path: "/pets/{petId}",
+  path: "/pets",
   method: "get",
-  language: "javascript",
-  client: "fetch",
+  language: "mylang",
+  client: "my-client",
 });
-
-console.log(code);
 ```
 
-### YAML
+---
 
-Install a YAML parser separately:
+## Plugin
 
-```bash
-npm install yaml
-```
-
-Parse the document before passing it to `generate()`:
+A plugin bundles one or more generator registrations through `use()`:
 
 ```typescript
-import { readFile } from "node:fs/promises";
-import YAML from "yaml";
-import { generate } from "@powerduck/openapi-codegen";
-
-const source = await readFile("./openapi.yaml", "utf8");
-const document = YAML.parse(source);
+import { use, generate } from "@powerduck/openapi-codegen";
+
+use({
+  name: "internal-generators",
+  register(api) {
+    api.register({
+      language: "go",
+      client: "our-wrapper",
+      generate(request) {
+        return `// go wrapper for ${request.method} ${request.path}`;
+      },
+    });
+    api.register({
+      language: "ruby",
+      client: "our-wrapper",
+      generate(request) {
+        return `# ruby wrapper for ${request.method} ${request.path}`;
+      },
+    });
+  },
+});
 
 const code = generate({
   document,
-  path: "/pets/{petId}",
+  path: "/pets",
   method: "get",
-  language: "javascript",
-  client: "fetch",
+  language: "go",
+  client: "our-wrapper",
 });
-
-console.log(code);
-```
-
-## Browser Usage
-
-The library is fully browser-compatible with zero Node.js dependencies:
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-  <title>API Code Generator</title>
-</head>
-<body>
-  <script type="module">
-    import { generate, list } from "https://esm.sh/@powerduck/openapi-codegen";
-
-    const document = {
-      openapi: "3.1.0",
-      info: { title: "Demo API", version: "1.0.0" },
-      paths: {
-        "/hello": {
-          get: {
-            responses: { "200": { description: "OK" } },
-          },
-        },
-      },
-    };
-
-    const code = generate({
-      document,
-      path: "/hello",
-      method: "get",
-      language: "javascript",
-      client: "fetch",
-    });
-
-    console.log(code);
-  </script>
-</body>
-</html>
 ```
 
-## Generated Code
-
-Generated examples are intended to be readable, runnable starting points. Depending on the selected language and client, they may include:
+---
 
-- A 30-second connection or request timeout
-- HTTP status validation
-- Response body output
-- Resource cleanup
-- Runtime and dependency notes
-- Placeholder multipart file paths
-- Environment-specific proxy or TLS behavior
+## Generate from a Direct RequestIR
 
-Review generated code before using it in production. You may need to:
+Skip `normalize` entirely by building a `RequestIR` yourself:
 
-- Install dependencies for the selected client
-- Replace placeholder parameter values
-- Replace multipart file paths
-- Supply authentication credentials securely
-- Configure certificate trust
-- Configure proxies
-- Adjust timeout and redirect policies
-- Add application-specific response parsing
+```typescript
+import { generate } from "@powerduck/openapi-codegen";
+import type { RequestIR } from "@powerduck/openapi-codegen";
 
-## Performance
+const request: RequestIR = {
+  method: "GET",
+  baseUrl: "https://api.example.com",
+  path: "/users/{id}",
+  parameters: [
+    { name: "id", in: "path", value: 123 },
+    { name: "limit", in: "query", value: 10, style: "form", explode: true },
+  ],
+  headers: [
+    { name: "Accept", in: "header", value: "application/json" },
+  ],
+  body: undefined,
+  security: [],
+};
 
-The library is optimized for high performance:
+const code = generate({
+  request,
+  language: "python",
+  client: "requests",
+});
+```
 
-- **No deep cloning via `JSON.parse(JSON.stringify())`** — uses structured reference handling
-- **Efficient $ref resolution** with caching and circular detection
-- **Lazy example generation** — only generates examples when needed
-- **Zero runtime dependencies** — minimal bundle size (~130KB minified)
-- **Tree-shakeable** — ESM build supports tree-shaking
+---
 
-## Development
+## Core Types
 
-Clone the repository and install dependencies:
+```typescript
+type ParameterLocation = "path" | "query" | "querystring" | "header" | "cookie";
+
+interface Parameter {
+  name: string;
+  in: ParameterLocation;
+  value: unknown;
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+}
 
-```bash
-git clone https://github.com/PowerDuckie/openapi-codegen.git
-cd openapi-codegen
-npm install
-```
+interface Body {
+  mediaType: string;
+  value: unknown;
+  encoding?: Record<string, unknown>;
+}
 
-Run the test suite:
+interface Security {
+  name: string;
+  type: string;
+  scheme?: string;
+  in?: string;
+  paramName?: string;
+  value: string;
+}
 
-```bash
-npm test
-```
+interface RequestIR {
+  method: string;
+  baseUrl: string;
+  path: string;
+  parameters: Parameter[];
+  headers: Parameter[];
+  body?: Body;
+  security: Security[];
+}
 
-Run tests with coverage:
+interface Generator {
+  language: string;
+  client: string;
+  generate(request: RequestIR): string;
+}
 
-```bash
-npm run test:coverage
+interface Plugin {
+  name: string;
+  register(api: { register(generator: Generator): void }): void;
+}
 ```
 
-Build the package:
+---
 
-```bash
-npm run build
-```
+## Error Handling
 
-Run type checking:
+`generate()` throws for missing input or unsupported generators. Wrap calls when processing untrusted documents:
 
-```bash
-npm run typecheck
+```typescript
+try {
+  const code = generate({
+    document,
+    path: "/pets/{id}",
+    method: "get",
+    language: "javascript",
+    client: "fetch",
+  });
+  console.log(code);
+} catch (error) {
+  console.error("Generation failed:", error instanceof Error ? error.message : error);
+}
 ```
 
-Run all release checks:
-
-```bash
-npm run check
-```
+---
 
-Run the demo:
+## Development
 
 ```bash
-npm run demo
-```
-
-## Testing
-
-The project uses:
+# Install dependencies
+npm install
 
-- [Vitest](https://vitest.dev/) for unit and integration tests
-- 270+ tests covering all core modules
-- Full branch coverage for core logic
+# Type check
+npm run typecheck
 
-Run all tests:
+# Build (ESM + CJS + type declarations)
+npm run build
 
-```bash
+# Run tests
 npm test
-```
-
-## Project Structure
 
+# Watch mode
+npx vitest watch
 ```
-src/
-├── index.ts              # Main entry point
-├── types.ts              # TypeScript type definitions
-├── core/
-│   ├── generator.ts      # Generator factory
-│   ├── helpers.ts        # Utility functions (escaping, indentation, etc.)
-│   ├── normalize.ts      # OpenAPI document → RequestIR normalization
-│   ├── refs.ts           # JSON Pointer $ref resolver
-│   ├── registry.ts       # Generator registry (Map-based)
-│   ├── request.ts        # RequestIR → compiled request
-│   ├── serialize.ts      # Parameter serialization (path/query/header/cookie)
-│   ├── example.ts        # JSON Schema → example value generation
-│   └── plugin.ts         # Plugin system
-└── emitters/
-    ├── index.ts          # Unified emitter registry (41 generators)
-    ├── c/                # C (libcurl)
-    ├── csharp/           # C# (httpclient, restsharp)
-    ├── javascript/       # JavaScript (fetch, axios, ofetch, jquery, xhr)
-    ├── python/           # Python (requests, aiohttp, httpx, http-client)
-    └── ...               # 17 more languages
-```
-
-## Security
-
-Generated source code can contain request URLs, headers, parameter values, and credentials supplied to the generator.
 
-Avoid:
+---
 
-- Committing generated examples that contain real credentials
-- Logging secrets in CI output
-- Running unreviewed generated commands in production
-- Passing untrusted file paths directly to generated upload code
+## Related Packages
 
-Report security issues privately to the repository owner instead of opening a public issue.
+- [`@powerduck/openapi-parser`](https://www.npmjs.com/package/@powerduck/openapi-parser) — OpenAPI 3.2 parser, validator, and upgrader
+- [`@powerduck/openapi-request`](https://www.npmjs.com/package/@powerduck/openapi-request) — Execute OpenAPI operations with full parameter serialization
+- [`@powerduck/openapi-cli`](https://www.npmjs.com/package/@powerduck/openapi-cli) — CI-ready batch testing for OpenAPI documents
+- [`@powerduck/x-to-openapi`](https://www.npmjs.com/package/@powerduck/x-to-openapi) — Convert curl commands and Postman Collections to OpenAPI 3.2
 
-## Contributing
-
-Contributions are welcome.
-
-1. Fork the repository.
-2. Create a feature branch.
-3. Add or update tests.
-4. Run the full validation suite.
-5. Commit the changes.
-6. Open a pull request.
-
-```bash
-git checkout -b feature/my-change
-npm install
-npm run check
-git add .
-git commit -m "feat: describe the change"
-git push -u origin feature/my-change
-```
+---
 
 ## License
 
-[MIT](LICENSE)
+MIT