@ir-kit/kit 0.0.1 → 1.0.0

package/docs/openapi-ts-typia.md

@@ -0,0 +1,135 @@
+# @ir-kit/kit/openapi-ts/typia
+
+Typia plugin for [@hey-api/openapi-ts](https://heyapi.dev/). Emits
+[typia](https://typia.io/) Standard Schema validators + JSON Schema
+companions for OpenAPI operations.
+
+## Install
+
+```bash
+pnpm add -d @ir-kit/kit @hey-api/openapi-ts
+pnpm add typia @standard-schema/spec
+```
+
+`@standard-schema/spec` is already a runtime dep of typia; pnpm's
+strict mode hides transitives, so generated code's
+`import type { StandardSchemaV1 } from '@standard-schema/spec'`
+requires the user to list it as a direct install.
+
+Typia's compiler transform is required at build time. Install `ttsc`
+and `@ttsc/unplugin` for your bundler (Vite, Webpack, tsdown, Next.js,
+etc.).
+
+## Usage
+
+```typescript
+import { defineConfig } from '@hey-api/openapi-ts';
+import {
+  defineConfig as defineTypiaConfig,
+  typiaTypeTransformer,
+} from '@ir-kit/kit/openapi-ts/typia';
+
+export default defineConfig({
+  input: 'openapi.json',
+  output: { path: './src/generated' },
+  plugins: [
+    '@hey-api/typescript',
+    {
+      name: '@hey-api/transformers',
+      typeTransformers: [typiaTypeTransformer],
+    },
+    defineTypiaConfig(),
+  ],
+});
+```
+
+`typiaTypeTransformer` annotates generated TypeScript types with typia
+constraint tags (`MinLength<N>`, `Format<"email">`, etc.) derived from
+OpenAPI validation keywords.
+
+## Generated output
+
+For each operation, one Standard Schema validator and (when
+`jsonSchema: true`) one JSON Schema companion:
+
+```ts
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { createValidate, type IValidation, json } from 'typia';
+import type { GetUserData, GetUserResponse } from './types.gen';
+
+const typiaSchemas = json.schemas<[
+  Omit<GetUserData, 'url' | 'path'> & { params: GetUserData['path'] },
+  GetUserResponse,
+]>();
+
+export const tGetUserData:
+  StandardSchemaV1<
+    Omit<GetUserData, 'url' | 'path'> & { params: GetUserData['path'] },
+    Omit<GetUserData, 'url' | 'path'> & { params: GetUserData['path'] }
+  > &
+  ((input: unknown) => IValidation<Omit<GetUserData, 'url' | 'path'> & { params: GetUserData['path'] }>) =
+  createValidate<Omit<GetUserData, 'url' | 'path'> & { params: GetUserData['path'] }>();
+
+export const tGetUserDataJsonSchema = typiaSchemas.schemas[0];
+
+export const tGetUserResponse:
+  StandardSchemaV1<GetUserResponse, GetUserResponse> &
+  ((input: unknown) => IValidation<GetUserResponse>) =
+  createValidate<GetUserResponse>();
+export const tGetUserResponseJsonSchema = typiaSchemas.schemas[1];
+```
+
+- `typia.json.schemas<[T1, T2, ...]>()` is called once per output file;
+  typia deduplicates `$ref`-ed components across the tuple.
+- Request input is reshaped: `path` → `params` to match the standard
+  validator API's default layer mapping (same shape oRPC's
+  `inputStructure: 'detailed'` expects).
+- Error responses (4xx/5xx) get per-status validators:
+  `t{{op}}ResponseError400`, etc.
+
+## Configuration
+
+```ts
+defineTypiaConfig({
+  case: 'camelCase',    // naming case for validators (default)
+  comments: true,       // JSDoc from OpenAPI summary/description
+  jsonSchema: true,     // emit JSON Schema companions
+  requests: {
+    enabled: true,
+    name: 't{{name}}Data',
+    jsonName: 't{{name}}DataJsonSchema',
+  },
+  responses: {
+    enabled: true,
+    name: 't{{name}}Response',
+    jsonName: 't{{name}}ResponseJsonSchema',
+  },
+})
+```
+
+## Drift detection
+
+Typia's tag namespace is type-only — it can't be enumerated at
+runtime. This plugin ships a generated mirror at
+`shared/typia-tags.generated.ts` produced by
+`scripts/sync-tags.ts`. Run after bumping typia:
+
+```bash
+pnpm sync-tags
+```
+
+The generator reads typia's `.d.ts` files with `oxc-parser` to extract
+tag names + `Format.Value` + `Type<V>`'s constraint — no hand-maintained
+mapping tables.
+
+A compile-time coverage gate flags any new typia tag that isn't
+explicitly handled or skipped.
+
+## Requirements
+
+- `@hey-api/openapi-ts` >= 0.95.0
+- `@hey-api/typescript` plugin configured
+- `@hey-api/transformers` plugin configured with
+  `typeTransformers: [typiaTypeTransformer]`
+- `typia` + `@standard-schema/spec` installed at runtime
+- Typia compiler transform configured (via `ttsc` and `@ttsc/unplugin`)

package/docs/openapi.md

@@ -0,0 +1,131 @@
+# `@ir-kit/kit/openapi`
+
+Language-agnostic IR-walking primitives for OpenAPI codegen. This package owns all the **pre-work** every native-SDK emitter needs (parsing the spec into shape, classifying schemas / responses / bodies, iterating paths × methods, deriving canonical names, walking template strings). Per-language emitters (`@ir-kit/openapi-{go,kotlin,swift}`) consume these primitives + provide their own **render** layer, never re-walking the spec themselves.
+
+The shape of the consolidation:
+
+```
+                 IR.Model from @ir-kit/kit/ir (schemas are JSON Schema 2020-12)
+                                    │
+                                    ▼
+                       @ir-kit/kit/openapi (this package)
+                       ┌────────────────────────────┐
+                       │ pure walks:                │
+                       │   iterOperations           │
+                       │   collectLocatedParams     │
+                       │   classifyBody             │
+                       │   classifyReturnShape      │
+                       │   classifyUnion            │
+                       │   classifyObjectShape      │
+                       │   classifyEnumLiterals     │
+                       │   iterateObjectProperties  │
+                       │   parseTemplatedSegment    │
+                       │   splitPathSegments        │
+                       │   deriveBaseName           │
+                       │   ...                      │
+                       │                            │
+                       │ generic dispatchers:       │
+                       │   schemaToType<T,D>(...)   │
+                       │   unionToType<T,D>(...)    │
+                       │   inlineObjectType<T,D>(.) │
+                       └────────────┬───────────────┘
+                                    │ ops: SchemaToTypeOps<T, D>
+              ┌─────────────────────┼─────────────────────┐
+              ▼                     ▼                     ▼
+     @ir-kit/kit/sdk/go    @ir-kit/kit/sdk/kotlin   @ir-kit/kit/sdk/swift
+     ┌──────────────────┐  ┌──────────────────┐    ┌──────────────────┐
+     │ goOps (renders): │  │ ktOps (renders): │    │ swOps (renders): │
+     │  • goPtr/goSlice │  │  • ktNullable    │    │  • swOptional    │
+     │  • goStruct      │  │  • ktDataClass   │    │  • swStruct      │
+     │  • const blocks  │  │  • @Serializable │    │  • CodingKeys    │
+     │  • net/http      │  │  • OkHttp        │    │  • URLSession    │
+     └──────────────────┘  └──────────────────┘    └──────────────────┘
+```
+
+## Why a shared dispatcher
+
+Before this package existed, each of the three native emitters had a full copy of `schemaToType`, `unionToType`, `inlineObjectType`, `buildEnumFromIR`, `typeForPrimitive` — plus their own walks over the spec. About 900 LOC of nearly-identical control flow per emitter (~2.7k total) drifted constantly: one emitter would gain a fix the others missed; one would use `pascal(jsonKey)` and another would use `safeIdent(jsonKey)` for the same role.
+
+Consolidating into `@ir-kit/kit/openapi` + a per-emitter `SchemaToTypeOps<T, D>` record means:
+
+- **One source of truth for spec walks.** Adding a new OpenAPI feature (e.g. handling `discriminator`) lands in one file; all emitters pick it up.
+- **Per-target rendering stays per-target.** Go's pointer-wrap is in `goOps.wrapForUnionSingle`; Kotlin's nullable wrap is in `ktOps.wrapForUnionSingle`. Neither leaks into the other; the dispatcher doesn't care which one is "right".
+- **Type-safety on the contract.** `SchemaToTypeOps<T, D>` is generic over the target type `T` (`GoType` / `KtType` / `SwType`) and decl type `D`. Each emitter gets type errors at compile time if it omits a hook or returns the wrong shape.
+
+## The `SchemaToTypeOps<T, D>` interface
+
+Every emitter implements ~13 hooks in one record (`packages/ir-kit/<lang>/src/ir/type-ops.ts`):
+
+```ts
+interface SchemaToTypeOps<T, D> {
+  // Leaf constructors
+  refType(name: string): T;
+  arrayType(elem: T): T;
+  mapType(value: T): T;
+  voidType(): T;
+  anyType(): T;
+  nullableAnyType(): T;
+  wrapForUnionSingle(inner: T, nullable: boolean): T;
+  unionFallback(nullable: boolean): T;
+  primitiveType(schema: Schema): T | undefined;
+
+  // Naming
+  synthName(ownerName: string, propPath: ReadonlyArray<string>): string;
+
+  // Composites (the dispatcher calls these when it sees the matching shape)
+  buildStructDecl(
+    name: string,
+    properties: ReadonlyArray<ObjectProperty>,
+    ctx: TypeCtx<D>,
+    dispatch: (s: Schema, c: TypeCtx<D>) => T,
+  ): D;
+  emitStringEnum(
+    name: string,
+    raws: ReadonlyArray<string>,
+    emit: (d: D) => void,
+  ): T;
+  emitIntegerEnum(
+    name: string,
+    raws: ReadonlyArray<number>,
+    emit: (d: D) => void,
+  ): T;
+}
+```
+
+Hooks receive `dispatch` so they can recurse back into `schemaToType` when they need an inner type — e.g. `buildStructDecl` calls `dispatch(propSchema, childCtx)` for every property.
+
+## Reading order
+
+If you're picking up this package for the first time:
+
+1. **`src/type/dispatch.ts`** — the `schemaToType<T, D>` function and the `SchemaToTypeOps<T, D>` interface. Start here.
+2. **`packages/ir-kit`** — concrete implementation of every hook. Smallest of the three emitters; the simplest read.
+3. **`src/type/{union,object,enum}.ts`** — the classifiers the dispatcher uses (`classifyUnion`, `classifyObjectShape`, `classifyEnumLiterals`, `iterateObjectProperties`, `assertNoEnumCollisions`). Pure functions over hey-api's IR.
+4. **`src/operation/*`** — operation-level walks (`iterOperations`, `collectLocatedParams`, `successResponses`, `classifyReturnShape`, `parseTemplatedSegment`, `deriveBaseName`, etc.). Each emitter's per-tag method generation calls into these.
+
+## Conventions
+
+- **Pre-work belongs here. Render belongs per-emitter.** When you find a `Object.entries(schema.properties).filter(...)` chain open-coded in two emitters, it goes here. When you find a `goPtr` / `ktNullable` / `swOptional` choice, it stays per-emitter.
+
+- **Classifiers return tagged-union shapes.** `classifyBody(body) → BodyShape`, `classifyUnion(schema) → UnionShape`, `classifyReturnShape(op) → ReturnShape`. Callers switch on `kind`. Adding a new variant ripples through the type checker so every consumer either handles it or fails to compile.
+
+- **Walks are generators, not arrays.** `iterOperations`, `iterateObjectProperties`. Lets callers short-circuit or filter without paying for a full list build. Callers that need an array do `Array.from(...)`.
+
+- **No target imports.** This package depends on `@hey-api/shared` (for IR types) and `@ir-kit/kit/codegen` (for `pascal`, `synthName`). Spec-level primitives (ref / security / constants / normalize) live under `src/spec/` and are re-exported. The package does NOT depend on any go-dsl / kt-dsl / sw-dsl module.
+
+## Adding a new shared walk
+
+When you spot duplication in `@ir-kit/openapi-{go,kotlin,swift}`:
+
+1. Identify the **pre-work** (what does the IR walk produce that's target-neutral?) vs the **render** (what's the target-specific shape it gets wrapped in?).
+2. Add the pre-work helper to this package — pure function, generator, or classifier.
+3. Update each emitter to consume it. Verify the petstore SDK regen is byte-identical (the repo's `examples/petstore/` is the canonical fixture).
+4. Land in one commit per emitter pass for clean git history.
+
+If the duplication is in render — different code paths producing structurally-different target code — it stays per-emitter. Push back on consolidating principled language differences just because they look similar.
+
+## Status
+
+`0.1.0` ships the dispatcher + ~16 pre-work helpers + the `SchemaToTypeOps` interface. The three native SDK emitters (`@ir-kit/openapi-{go,kotlin,swift}`) consume it; the TypeScript emitter (`@ir-kit/kit/sdk/typescript`) wraps `@hey-api/openapi-ts` and bypasses the dispatcher entirely (hey-api owns its own IR walk).
+
+Petstore SDK output for go + swift is byte-identical pre- and post-consolidation across all dispatcher migrations — this is the regression bar.

package/docs/recon.md

@@ -0,0 +1,78 @@
+# @ir-kit/kit/recon
+
+Reverse-engineer an OpenAPI 3.1 document from observed HTTP traffic. Feed it standard Web Fetch `Request` / `Response` pairs and it folds them into a JSON Schema 2020-12 document with templated paths, per-status response schemas, detected auth schemes, and per-origin grouping.
+
+Runtime-agnostic: works in browsers, Node, Deno, Bun, Cloudflare Workers — anywhere `Request` / `Response` exist. Pure functions, no global state, tree-shakable.
+
+Powers [`@ir-kit/glean`](../../apps/glean), the Chrome DevTools extension that emits live specs from browsing.
+
+## Install
+
+```bash
+pnpm add @ir-kit/kit
+```
+
+## Use
+
+```ts
+import { createRecon } from "@ir-kit/kit/recon";
+
+const recon = createRecon({
+  title: "Petstore",
+  version: "0.1.0",
+});
+
+// Anywhere you observe traffic — e.g. a fetch wrapper, a service-worker, a proxy:
+await recon.observe(request, response);
+
+// Whenever you want a snapshot:
+const document = recon.toOpenAPI();
+// → OpenAPIV3_1.Document with paths, components.schemas, components.securitySchemes
+```
+
+`request` / `response` are standard Web Fetch types. Bodies must already be readable — call `.clone()` upstream if you also need to forward the response. Non-JSON bodies are skipped silently.
+
+## What it infers
+
+- **Path templating**: `/pets/42` and `/pets/8` collapse into `/pets/{petId}` with `{ petId: "string" }`. Pure-numeric segments become `integer`. Disable via `pathTemplating: false`.
+- **JSON Schema 2020-12** for every observed JSON request and response body, merged across samples (union types, optional fields, enum candidates).
+- **Per-status response schemas**: `200` and `404` keep distinct shapes.
+- **Auth schemes**: `Authorization: Bearer ...` → `bearerAuth`; `X-API-Key: ...` → `apiKeyAuth`; basic auth too. Detected per-operation, deduped at the components level.
+- **Per-origin grouping**: feed traffic from many backends and snapshot one origin at a time:
+
+```ts
+const justBackend = recon.toOpenAPI({ origin: "https://api.example.com" });
+```
+
+## Options
+
+```ts
+createRecon({
+  redactHeaders: ["authorization", "cookie", "x-api-key"], // sensible defaults built in
+  pathTemplating: true,
+  title: "Reverse-engineered API",
+  version: "0.0.0",
+});
+```
+
+## API surface
+
+| Export | Purpose |
+| --- | --- |
+| `createRecon(config?)` | Returns a `Recon` session. |
+| `Recon.observe(req, res)` | Fold one request/response into the running spec. |
+| `Recon.toOpenAPI(opts?)` | Snapshot the current spec (optionally filtered by origin). |
+| `Recon.sampleCount()` / `originStats()` | Telemetry on what's been folded. |
+| `Recon.clear()` / `clearOrigin(origin)` | Reset all state, or just one origin. |
+| `inferSchema(value)` / `mergeSchema(a, b)` | Lower-level building blocks. |
+| `templatePaths(paths)` / `templateSinglePath(...)` | Path templating in isolation. |
+| `sanitizeHeaders(headers, redact?)` / `DEFAULT_REDACTED_HEADERS` | Header redaction helpers. |
+
+## Pairing
+
+- **[`@ir-kit/glean`](../../apps/glean)** — Chrome DevTools panel that wires this up to the network panel and emits a live, click-to-copy spec.
+- **[`ir spec diff`](./spec-diff.md)** — diff a freshly recon'd spec against a committed one to spot drift between docs and reality.
+
+## License
+
+MIT

package/docs/schema.md

@@ -0,0 +1,55 @@
+# `@ir-kit/kit/schema`
+
+Canonical JSON Schema 2020-12 IR shared across the OpenAPI and AsyncAPI codegen families. `IR.Schema` from `@ir-kit/kit/ir` is this type. Source-agnostic — adapters fold hey-api's `IR.SchemaObject`, raw JSON Schema (any draft), and OpenAPI 3.0 `nullable` quirks into one shape so every emitter (`@ir-kit/openapi-{go,kotlin,swift,typescript}`, `@ir-kit/kit/sdk/asyncapi`, `@ir-kit/k6-codegen`) reads the same model.
+
+## Install
+
+```sh
+npm install @ir-kit/kit
+# adapter from hey-api needs:
+npm install @hey-api/shared
+```
+
+## Use
+
+```ts
+import {
+  type Schema,
+  classifyUnion,
+  classifyObject,
+  classifyEnumLiterals,
+  extractEnumValues,
+} from "@ir-kit/kit/schema";
+
+const schema: Schema = {
+  oneOf: [{ type: "string" }, { type: "null" }],
+};
+
+const shape = classifyUnion(schema);
+// → { kind: "single", inner: { type: "string" }, nullable: true }
+```
+
+## Adapters
+
+```ts
+import { fromHeyApi } from "@ir-kit/kit/schema/adapters/heyapi";
+import { fromJsonSchema } from "@ir-kit/kit/schema/adapters/jsonschema";
+
+const canonical = fromHeyApi(heyApiIrSchemaObject);
+const fromAsync = fromJsonSchema(asyncSchema.json(), { dialect: "draft-07" });
+const fromOas3  = fromJsonSchema(openapi30Schema); // `nullable: true` folded into type[]
+```
+
+## Scope
+
+This is the **dialect**: types + classifiers + adapters. Per-target rendering (Go pointer vs Kotlin nullable, struct emission, enum identifier transforms) lives in each emitter package — see `@ir-kit/kit/openapi`'s `SchemaToTypeOps<T,D>` interface.
+
+Subset of JSON Schema 2020-12. Omitted (codegen can't bind cleanly): `$dynamicRef`, `$dynamicAnchor`, `unevaluatedProperties`, `unevaluatedItems`, `if`/`then`/`else`, `dependentSchemas`, `dependentRequired`, `contains`.
+
+## Status
+
+`0.1.0` — first release. Consumers (`@ir-kit/kit/openapi`, `@ir-kit/kit/sdk/asyncapi`, `@ir-kit/k6-codegen`) migrate incrementally in follow-up changesets.
+
+## Repo
+
+Source at [ahmedrowaihi/ir-kit](https://github.com/ahmedrowaihi/ir-kit/tree/main/packages/ir-kit/docs/schema.md).

package/docs/sdk-asyncapi.md

@@ -0,0 +1,124 @@
+# @ir-kit/kit/sdk/asyncapi
+
+AsyncAPI 3.0 → TypeScript generator. Plugin-compose architecture.
+
+Each plugin emits one slice of generated code (types, Events const, dispatch helpers, AMQP helpers, framework adapters). Caller picks which plugins to enable; orchestrator topologically sorts by `dependsOn` and writes via `@hey-api/codegen-core`'s `Project` pipeline.
+
+## Install
+
+```sh
+pnpm add -D @ir-kit/kit
+```
+
+Peer deps (most are dev-only at consumer side):
+
+- `@asyncapi/parser` `>=3.0.0`
+- `@hey-api/openapi-ts` `>=0.99.0`
+- `@hey-api/codegen-core` `>=0.8.0`
+- `@ir-kit/kit/asyncapi`, `@ir-kit/kit/asyncapi`, `@ir-kit/kit/codegen`
+- `typescript` `>=5.0.0`
+- `amqplib` `>=0.10.0` *(optional — only if you enable the `amqplib` plugin)*
+
+## Usage
+
+```ts
+import {
+  amqplib,
+  dispatch,
+  eventMap,
+  events,
+  generate,
+  indexBarrel,
+  typescript,
+} from "@ir-kit/kit/sdk/asyncapi";
+
+await generate({
+  input: "./asyncapi.yaml",
+  output: "./generated",
+  plugins: [
+    typescript(),
+    events(),
+    eventMap(),
+    dispatch(),
+    amqplib(),
+    indexBarrel(),
+  ],
+});
+```
+
+For a full RabbitMQ run (producer + consumer end-to-end), see `examples/petstore/events/` in the ir-kit monorepo.
+
+## Built-in plugins
+
+| Plugin | File(s) emitted | Description |
+|---|---|---|
+| `typescript()` | `types.gen.ts` | TS types from message payload and component schemas (via `@hey-api/openapi-ts`). Names taken from spec message ids and component names. |
+| `events()` | `events.gen.ts` | `Events` const with `{type, routingKey, exchange, exchangeType, contentType}` per channel/operation, plus an `EventName` type alias |
+| `eventMap()` | `event-map.gen.ts` | `EventMap` keyed by event-type literal → message interface, `AnyMessage` union, `isMessageOfType` discriminator |
+| `dispatch()` | `dispatch.gen.ts` + `handlers.gen.ts` | Generic `Registry` runtime (with `.on(...)`, `.dispatch`, `.toCallback(...)`, `.bindings`) + spec-bound `handlers()` factory |
+| `amqplib()` | `amqp.gen.ts` | `assertExchanges` / `bindAndConsume` / `publish` helpers — pure passthroughs to `amqplib` (no hidden defaults) |
+| `indexBarrel()` | `index.gen.ts` | Barrel re-export of every other enabled plugin's surface |
+
+Plugins compose freely. Each plugin's `dependsOn` ensures correct ordering even if the user lists them out of order.
+
+## Authoring custom plugins
+
+```ts
+import { definePluginConfig } from "@ir-kit/kit/sdk/asyncapi";
+
+export const myPlugin = definePluginConfig<
+  "my-plugin",
+  { fileName?: string },
+  { fileName: string },
+  unknown
+>({
+  name: "my-plugin",
+  defaultConfig: { fileName: "my.gen.ts" },
+  dependsOn: ["typescript"], // run after the typescript plugin
+  handler(plugin) {
+    for (const ev of plugin.forEach("message")) {
+      if (ev.type !== "message") continue;
+      // ...inspect ev.message...
+    }
+    plugin.emit({
+      path: plugin.config.fileName,
+      content: "// my custom code\n",
+    });
+    // or, for AST emission:
+    // plugin.emitTs("my.gen.ts", [$.const("x").export().assign($.literal(1))], { header: "// ..." });
+  },
+});
+```
+
+The `PluginInstance` exposes:
+
+- `plugin.config` — typed resolved config
+- `plugin.api` — typed plugin api (other plugins fetch via `plugin.getApi(name)`)
+- `plugin.document` — the parsed `AsyncAPIDocumentInterface`
+- `plugin.files` — files emitted so far (for plugins like `index-barrel` that inspect prior output)
+- `plugin.emit({path, content})` — emit a file as raw text
+- `plugin.emitTs(path, nodes, {header?, imports?, exports?})` — emit a file built with Hey API's `$` DSL (`import { $ } from "@hey-api/openapi-ts"`), rendered by Hey API's TypeScript renderer; a string is printed as-is after the nodes
+- `plugin.getApi<T>(name)` — fetch another plugin's exposed api
+- `plugin.forEach('message' | 'channel' | 'operation', ...)` — iterate spec entities
+
+## How the pipeline works
+
+```
+asyncapi.yaml
+  └─ @asyncapi/parser → AsyncAPIDocumentInterface
+      └─ orchestrator (topological sort by dependsOn)
+          └─ for each plugin:
+                handler(PluginInstance)
+                  ├─ plugin.emit(rawText)   → RawTextNode → Project.files
+                  └─ plugin.emitTs(nodes)   → TsStatementNode → Project.files
+          └─ project.plan() + project.render()
+              ├─ TsStatementRenderer → ts.createPrinter
+              └─ RawTextRenderer → concat
+          └─ write outputs to disk
+```
+
+## Related
+
+- [`ir generate`](./generate.md): the `asyncapi` target runs this generator from `ir.config.ts`
+- [`@ir-kit/kit/sdk/typescript`](../openapi-typescript) — sister generator for OpenAPI 3.x specs
+- [`fixtures/user-events.yaml`](../../fixtures/user-events.yaml) — minimal AsyncAPI 3.0 spec used by tests