@nxgt/openapi-httpyz 0.1.0

package/README.md

@@ -0,0 +1,590 @@
+# @nxgt/openapi-httpyz
+
+Binds the operations [`@nxgt/openapi-codegen`](https://www.npmjs.com/package/@nxgt/openapi-codegen)
+generates from an OpenAPI spec onto a client of
+[`@nxgt/httpyz`](https://www.npmjs.com/package/@nxgt/httpyz). Every call is
+checked against the spec at compile time: the path, the parameters, the body
+and each reply the operation declares. A reply is a union narrowed on its
+status, so nothing throws for a status the spec declares.
+
+The client sends, with its middleware, auth, retries and timeouts. The
+binding adds what the spec knows: how each parameter and body is written,
+the replies each operation declares, and checks by the server's own
+validators.
+
+> **0.x.** The API is still settling.
+
+## Install
+
+```sh
+bun add @nxgt/httpyz @nxgt/openapi-httpyz zod
+bun add -d @nxgt/openapi-codegen typescript
+```
+
+Both peers are required: `@nxgt/httpyz`, since the binding uses your client,
+not a copy of its own, and `typescript` 6, for the types. The generated
+`operations.ts` imports `zod`, so the app needs it too.
+
+## Setup
+
+Generate the spec's files, into `generated/openapi` unless `-o` says
+otherwise:
+
+```sh
+bunx nxgt-openapi generate -i openapi.yaml
+```
+
+Then bind them:
+
+```ts
+import { createHttpClient } from '@nxgt/httpyz';
+import { createOpenApiClient } from '@nxgt/openapi-httpyz';
+import { operations } from './generated/openapi/operations.js';
+
+const http = createHttpClient({
+	baseUrl: 'https://api.example.com',
+	timeout: 10_000,
+});
+
+export const api = createOpenApiClient(http, operations);
+```
+
+`operations`, the runtime table of the generated `operations.ts`, holds each
+parameter's location and style, the body's media types, each reply's schema,
+and the server's validators. Its type also carries each operation's input and
+replies, `ClientOperations` of the generated `types.ts`, so the client is
+typed from the table alone:
+
+- `api.get` offers the paths that have a GET operation, and takes what the
+  operation at the chosen path takes.
+- The client has only the methods the spec has an operation for: no `trace`
+  on a spec without a TRACE operation.
+
+The types may also be given, as a table generated before
+`@nxgt/openapi-codegen` carried them requires:
+`createOpenApiClient<ClientOperations, OperationsByRoute>(http, operations)`.
+`OperationsByRoute` may be left out: it is worked out of `ClientOperations`.
+
+The client keeps that table as `api.operations`, for a package built over it,
+such as [`@nxgt/httpyz-query/openapi`](https://www.npmjs.com/package/@nxgt/httpyz-query).
+
+The client's options are the client's own: see
+[`@nxgt/httpyz`](https://www.npmjs.com/package/@nxgt/httpyz#setup). The
+binding's, `validate` and `decode`, are listed under
+[`createOpenApiClient`](#createopenapiclient).
+
+## Calls
+
+```ts
+// By method and path, QUERY included
+const reply = await api.get('/employees/{id}', { param: { id } });
+
+// By operationId
+await api.op('updateEmployee', { param: { id }, json: { name: 'Ada' } });
+
+// fetch options, a timeout or a retry come last
+await api.op('listEmployees', { query: { page: 2 } }, { signal, timeout: 2_000 });
+```
+
+A path the spec has no operation for, for that method, does not compile.
+The input holds each part of the request, as `ClientOperations` types it:
+
+| Key | Holds | Written |
+| --- | --- | --- |
+| `param` | path parameters | encoded into the path |
+| `query` | query parameters | a list as a repeated key, or joined with commas when the spec says `explode: false` |
+| `header` | header parameters, by lowercased name | a list joined with commas |
+| `json` | a JSON body | `JSON.stringify`, as the JSON type the spec declares |
+| `form` | a form body | URL-encoded when that is the declared type, else multipart `FormData`; a list as a repeated field |
+| `text` | a text body | as it is, as the text type the spec declares |
+| `body` | a binary body: `Blob`, `ArrayBuffer`, `Uint8Array` | as it is, as the binary type the spec declares |
+
+The input may be left out when nothing in it is required, and an operation
+that takes nothing takes no input: `api.op('health')`, or
+`api.op('health', { signal })`.
+
+## Cancelling
+
+A call's init takes the client's own ways to end it early: its `signal`,
+and `latest`, a key that aborts the call before it with the same key.
+`api.group()` is the same client over the client's `http.group()`, whose
+calls and streams end together:
+
+```ts
+// Typing ahead: only the last search stays in flight
+await api.get('/employees', { query: { name } }, { latest: 'search' });
+
+const page = api.group();
+const employees = await page.op('listEmployees');
+page.cancel(); // on leaving the page: its calls and streams still running abort
+```
+
+A cancelled call rejects with an `AbortError`, never a `ClientError`: tell
+it from a failure with the client's `isAbortError()`. The group goes on
+after `cancel()`, and `page.signal` aborts on the next one. The details are
+in [the client's README](https://www.npmjs.com/package/@nxgt/httpyz#cancelling).
+
+## Replies
+
+A call resolves to one of the replies the spec declares:
+
+```ts
+import { unwrap } from '@nxgt/httpyz';
+
+const reply = await api.get('/employees/{id}', { param: { id } });
+reply.status; // 200 | 404
+reply.type; // the declared media type: 'application/json'
+reply.data; // Employee when status is 200, ErrorResponse when it is 404
+reply.response; // the Response, for its headers: its body is read
+
+const employee = unwrap(reply, 200); // or a ReplyStatusError
+```
+
+A form reply's `data` is its `FormData`, and a binary one's a `Blob`. A
+status the spec does not declare for the operation throws the client's
+`UndeclaredStatusError`; errors are the client's own, listed in
+[its README](https://www.npmjs.com/package/@nxgt/httpyz#errors).
+
+## Streams
+
+An operation whose reply the spec describes an item at a time, with OpenAPI
+3.2's `itemSchema`, is read with `stream()`, by its `operationId`. Server-sent
+events come through the client's `events()`, each narrowed on its name, and
+JSON Lines through its `lines()`:
+
+```ts
+const feed = api.stream('watchFeed', { query: { topic: 'news' } });
+for await (const event of feed) {
+	if (event.event === 'added') event.data.name; // Item
+	else event.data; // 'note': text
+}
+
+for await (const item of api.stream('exportItems', { json: { limit: 100 } })) {
+	item.id;
+}
+```
+
+- It connects when read, and `close()` or a `break` ends it. Events
+  reconnect as `EventSource` does, but for POST and PATCH; the init after the
+  input takes `reconnect`, `lastEventId` and `onUnknownEvent`, beside the call
+  options.
+- It sends the stream's declared media type as `Accept`, and writes the input
+  as a call does.
+- `validate` checks the request on the first read, before anything is sent,
+  and each item against its schema; `decode` yields what each schema
+  outputs.
+- Only an operation with a stream is accepted; the others do not compile.
+
+An event the spec does not declare is not yielded: it goes to
+`onUnknownEvent`. The stream API is the client's, described in
+[its README](https://www.npmjs.com/package/@nxgt/httpyz#streams).
+
+## Validating and decoding
+
+The types hold a call to the spec, but not the values in it: a `page` of `0`
+where the spec says `minimum: 1`, or a reply from a server that drifted.
+`validate` checks both with the schemas in the generated `operations` table:
+
+- **The request**, before it is sent, by the validators the server runs, on
+  what the server will read: each parameter as the text it travels as, the
+  JSON as it parses, a form as its fields. A request the server would refuse
+  throws a `ValidationError` with the same issues, and is never sent.
+- **The reply**, before it is returned: a JSON or text reply against its
+  schema, as [`@nxgt/openapi-hono`](https://www.npmjs.com/package/@nxgt/openapi-hono)
+  checks its own with `validateResponses`.
+
+```ts
+createOpenApiClient(http, operations, { validate: { request: true } });
+```
+
+Unlike a plain call of the client, which checks a declared reply by default,
+the binding checks nothing by default: the types already hold both ends to
+the spec.
+
+`decode` returns each reply as its schema outputs it, which differs from what
+JSON carries once the spec is generated with `dates: 'date'`: a date-time is
+a `Date`. The client's replies are typed so:
+
+```ts
+const api = createOpenApiClient(http, operations, { decode: true });
+const employee = unwrap(await api.get('/employees/{id}', { param: { id } }), 200);
+employee.hiredAt; // Date
+```
+
+With the types given, a third type argument says the client decodes:
+`createOpenApiClient<ClientOperations, OperationsByRoute, true>`, which does
+not compile without `decode: true`. Decoding validates the reply, whatever
+`validate` says.
+
+## API
+
+The examples below use a spec with `getEmployee` at `GET /employees/{id}`,
+`listEmployees` at `GET /employees`, `createEmployee` at `POST /employees`,
+and `watchFeed`, an event stream, at `GET /feed`.
+
+### Functions
+
+#### createOpenApiClient
+
+```ts
+// With decode: true, the replies are typed as their schemas output them
+function createOpenApiClient<Ops extends OperationsShape<Ops>, Routes = RoutesOf<Ops>>(
+	http: HttpClient,
+	operations: OperationTable<Ops>,
+	options: OpenApiOptions & { readonly decode: true },
+): OpenApiClient<Ops, Routes, true>;
+
+function createOpenApiClient<
+	Ops extends OperationsShape<Ops>,
+	Routes = RoutesOf<Ops>,
+	Decoded extends boolean = false,
+>(
+	http: HttpClient,
+	operations: OperationTable<Ops>,
+	...options: OpenApiArgs<Decoded>
+): OpenApiClient<Ops, Routes, Decoded>;
+```
+
+Binds the generated `operations` table onto `http`, a client of
+`createHttpClient()` or one of its groups. `Ops` is inferred from the table;
+`Routes` defaults to `RoutesOf<Ops>`; `Decoded` is `true` when `decode: true`
+is passed. See [Setup](#setup) and [Validating and decoding](#validating-and-decoding).
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `validate` | `boolean \| { request?: boolean; response?: boolean }` | neither | Checks with the spec's schemas, throwing a `ValidationError`: the request before it is sent, the reply before it is returned. `true` is both |
+| `decode` | `true \| false` | `false` | `true` returns each reply as its schema outputs it, and types it so. It validates the reply, whatever `validate` says. A literal: a `boolean` variable does not compile, since the replies' type depends on it |
+
+Returns an [`OpenApiClient`](#openapiclient). It throws nothing itself: an
+unknown `operationId` or path fails the call made with it.
+
+### The client
+
+#### op
+
+```ts
+api.op<K extends keyof Ops & string>(id: K, ...args: Args<Ops, K>): Promise<WithResponse<OperationReply<Ops, K, Decoded>>>;
+```
+
+Calls an operation by its `operationId`, with its input, if it takes one,
+then an [`OperationInit`](#operationinit). See [Calls](#calls).
+
+Resolves to one of the declared replies, `{ status, type, data, response }`,
+as in [Replies](#replies). Rejects with a `ValidationError` when `validate`
+refuses the request or the reply, with the client's errors, such as
+`UndeclaredStatusError`, and with an `Error` for an `operationId` the table
+does not have.
+
+#### Path methods
+
+```ts
+api.get<P extends PathsOf<Routes, 'get'>>(path: P, ...args: Args<Ops, IdOf<Ops, Routes, 'get', P>>): Promise<WithResponse<OperationReply<Ops, IdOf<Ops, Routes, 'get', P>, Decoded>>>;
+// and put, post, delete, options, head, patch, trace, query: each the spec has an operation for
+```
+
+Calls the operation at a method and a path, as the spec writes it:
+`api.get('/employees/{id}', { param: { id } })`. The client types only the
+methods in [`MethodsOf<Routes>`](#methodsof), each taking only its
+[`PathsOf`](#pathsof). The arguments, reply and errors are those of
+[`op`](#op); a path with no operation for the method rejects with an `Error`.
+
+#### stream
+
+```ts
+api.stream<K extends StreamIds<Ops>>(id: K, ...args: StreamArgs<Ops, K>): OperationStreamOf<Ops, K, Decoded>;
+```
+
+Reads an operation's stream by its `operationId`, an item at a time: an
+`EventStream` of events narrowed on `event`, or a `Stream` of JSON lines. It
+takes the input, then a [`StreamInit`](#streaminit). See [Streams](#streams).
+
+It connects when read, and `close()` ends it. It throws an `Error`, where it
+is called, for an operation without a stream. A `ValidationError` from
+`validate`, or a client error, is thrown where the stream is read.
+
+#### group
+
+```ts
+api.group(): OpenApiGroup<Ops, Routes, Decoded>;
+```
+
+The same client, with the same options, over the client's `http.group()`:
+its calls and streams also end on its `cancel()`. See [Cancelling](#cancelling).
+
+#### group.cancel
+
+```ts
+page.cancel(reason?: unknown): void;
+```
+
+Aborts every call and stream of the group still running, with `reason`, or
+an `AbortError`. The group goes on: the calls made after it run.
+
+#### group.signal
+
+```ts
+readonly page.signal: AbortSignal;
+```
+
+Aborts on the next `cancel()`: for work of your own that ends with the
+group's calls. It is a new signal after each `cancel()`.
+
+#### operations
+
+```ts
+readonly api.operations: OperationTable<Ops>;
+```
+
+The generated `operations` table the client was bound to, for a package
+built over it that reads the spec as the client does, such as
+[`@nxgt/httpyz-query/openapi`](https://www.npmjs.com/package/@nxgt/httpyz-query).
+
+### Types
+
+#### OpenApiClient
+
+```ts
+type OpenApiClient<Ops extends OperationsShape<Ops>, Routes = RoutesOf<Ops>, Decoded extends boolean = false> = {
+	op: …; // see op
+	stream: …; // see stream
+	group(): OpenApiGroup<Ops, Routes, Decoded>;
+	readonly operations: OperationTable<Ops>;
+} & PathMethods<Ops, Routes, Decoded>;
+```
+
+What `createOpenApiClient()` returns: the members are under
+[The client](#the-client).
+
+#### OpenApiGroup
+
+```ts
+type OpenApiGroup<Ops, Routes = RoutesOf<Ops>, Decoded extends boolean = false> =
+	OpenApiClient<Ops, Routes, Decoded> & {
+		cancel(reason?: unknown): void;
+		readonly signal: AbortSignal;
+	};
+```
+
+What [`group()`](#group) returns: the client, with
+[`cancel`](#groupcancel) and [`signal`](#groupsignal).
+
+#### PathMethods
+
+```ts
+type PathMethods<Ops, Routes = RoutesOf<Ops>, Decoded extends boolean = false> = {
+	readonly [M in MethodsOf<Routes>]: <P extends PathsOf<Routes, M>>(
+		path: P,
+		...args: Args<Ops, IdOf<Ops, Routes, M, P>>
+	) => Promise<WithResponse<OperationReply<Ops, IdOf<Ops, Routes, M, P>, Decoded>>>;
+};
+```
+
+The [path methods](#path-methods) alone, for a package that offers them on an
+object of its own, as [`@nxgt/datasource-rest`](https://www.npmjs.com/package/@nxgt/datasource-rest)
+does. `PathMethods<ClientOperations>` has `get` and `post` on the example spec.
+
+#### OpenApiOptions
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `validate` | `boolean \| { readonly request?: boolean; readonly response?: boolean }` | Checks the request, the reply, or both (`true`). Default: neither |
+
+The options of [`createOpenApiClient`](#createopenapiclient), beside `decode`.
+
+#### OpenApiArgs
+
+```ts
+type OpenApiArgs<Decoded extends boolean> = Decoded extends true
+	? [options: OpenApiOptions & { readonly decode: true }]
+	: [options?: OpenApiOptions & { readonly decode?: false }];
+```
+
+The options argument of `createOpenApiClient()`, required with `decode: true`
+when `Decoded` is `true`. `OpenApiArgs<false>` resolves to
+`[options?: OpenApiOptions & { readonly decode?: false }]`.
+
+#### OperationInit
+
+```ts
+type OperationInit = Omit<CallOptions, 'operationId'>;
+```
+
+What a call takes after its input: the client's call options, the binding
+naming the call itself.
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `headers` | `HeadersInit` | Over the client's `headers`; a `Content-Type` here gives way to the one a JSON, text or binary body sets |
+| `timeout` | `number` | This call's timeout, instead of the client's |
+| `retry` | `number \| RetryOptions \| false` | This call's retry, instead of the client's: `false` never retries |
+| `latest` | `string` | Aborts the call before it with the same key, if it still runs |
+| `signal`, `cache`, `credentials`, … | as in `RequestInit` | fetch's own options, but `method`, `body` and `headers` |
+
+#### StreamInit
+
+```ts
+interface StreamInit extends OperationInit {
+	reconnect?: boolean | ReconnectOptions;
+	lastEventId?: string;
+	onUnknownEvent?: (event: ServerEvent) => void;
+}
+```
+
+What [`stream()`](#stream) takes after its input.
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `reconnect` | `boolean \| ReconnectOptions` | Events only: connects again when the connection drops or the stream ends, as `EventSource` does. Default: on, but for POST and PATCH |
+| `lastEventId` | `string` | Events only: sent as `Last-Event-ID` on the first connection |
+| `onUnknownEvent` | `(event: ServerEvent) => void` | Events only: an event the spec does not declare, which is not yielded |
+
+#### Args
+
+A call's arguments after the `operationId` or the path: the operation's own,
+then an `OperationInit`.
+`Args<ClientOperations, 'getEmployee'>` resolves to
+`[input: { param: { id: number } }, init?: OperationInit]`.
+
+#### StreamArgs
+
+A stream's arguments after the `operationId`: the operation's own, then a
+`StreamInit`.
+`StreamArgs<ClientOperations, 'watchFeed'>` resolves to
+`[input: { query: { topic: string } }, init?: StreamInit]`.
+
+#### OperationReply
+
+An operation's replies, decoded or as JSON carries them, as `op()` and the
+path methods resolve to them without `response`.
+`OperationReply<ClientOperations, 'getEmployee', false>` resolves to
+`ClientOperations['getEmployee']['wire']`, and with `true` to its `reply`.
+
+#### OperationStreamOf
+
+What [`stream()`](#stream) returns: an `EventStream` for server-sent events, a
+`Stream` for JSON lines, of items decoded or as JSON carries them.
+`OperationStreamOf<ClientOperations, 'watchFeed', false>` resolves to
+`EventStream<ClientOperations['watchFeed']['stream']['wire']>`.
+
+#### StreamIds
+
+The operations that reply with a stream: the only ones `stream()` accepts.
+`StreamIds<ClientOperations>` resolves to `'watchFeed'`.
+
+#### RoutesOf
+
+`OperationsByRoute`, worked out of `ClientOperations`: each `'method path'`
+to its `operationId`, and the default of `Routes`.
+`RoutesOf<ClientOperations>['get /employees/{id}']` resolves to `'getEmployee'`.
+
+#### MethodsOf
+
+The methods the spec has an operation for: the only path methods a client
+offers. `MethodsOf<RoutesOf<ClientOperations>>` resolves to `'get' | 'post'`.
+
+#### PathsOf
+
+The paths with an operation for a method.
+`PathsOf<RoutesOf<ClientOperations>, 'get'>` resolves to
+`'/employees' | '/employees/{id}' | '/feed'`.
+
+#### IdOf
+
+The `operationId` of the operation at a method and a path.
+`IdOf<ClientOperations, RoutesOf<ClientOperations>, 'get', '/employees/{id}'>`
+resolves to `'getEmployee'`.
+
+#### OperationsShape
+
+```ts
+type OperationsShape<Ops> = { [K in keyof Ops]: ClientOperation };
+```
+
+The constraint on `Ops`: the generated `ClientOperations`, an entry per
+`operationId`.
+
+#### ClientOperation
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `method` | `Method` | The operation's method, lowercased |
+| `path` | `string` | The path as the spec writes it |
+| `args` | `readonly unknown[]` | What a call takes after the `operationId`: `[input]`, `[input?]` or `[]` |
+| `reply` | `unknown` | Every declared reply, `{ status; type; data }`, decoded |
+| `wire` | `unknown` | The same replies as JSON carries them |
+| `stream` | `OperationStream`, optional | A reply read an item at a time, when the operation has one |
+
+What the binding reads of an entry of the generated `ClientOperations`.
+
+#### OperationStream
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `kind` | `'sse' \| 'jsonl'` | Server-sent events, or JSON lines |
+| `item` | `unknown` | Each item, decoded: an event narrowed on `event`, or a line |
+| `wire` | `unknown` | Each item as JSON carries it |
+
+The `stream` of a `ClientOperation`.
+
+#### OperationTable
+
+```ts
+type OperationTable<Ops> = {
+	readonly [K in keyof Ops]: RuntimeOperation & { readonly '~client'?: Ops[K] };
+};
+```
+
+The type of the generated `operations` table, and of `api.operations`. Each
+entry carries its `ClientOperations` entry as `'~client'`, a type that is
+never set, which is how `createOpenApiClient(http, operations)` infers `Ops`.
+
+#### RuntimeOperation
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `method` | `Method` | The operation's method |
+| `path` | `string` | As the spec writes it: `/employees/{id}` |
+| `parameters` | `readonly RuntimeParameter[]` | How each parameter is written |
+| `param`, `query`, `header` | `StandardSchemaV1`, optional | The server's validators of each location, which read text: for `validate` |
+| `body` | `{ required: boolean; content: { [mediaType]: RuntimeMedia } }`, optional | The request body's media types |
+| `responses` | `{ [status]: { [mediaType]: RuntimeMedia } }` | Each declared reply's media types |
+
+What the binding reads of an entry of the `operations` table.
+
+#### RuntimeParameter
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `name` | `string` | As the spec writes it |
+| `in` | `'path' \| 'query' \| 'header'` | Where it goes |
+| `required` | `boolean` | Whether the spec requires it |
+| `explode` | `boolean` | A query list as `?a=1&a=2` (`true`) or `?a=1,2` (`false`) |
+| `list` | `boolean` | Whether it is validated as a list |
+
+An entry of a `RuntimeOperation`'s `parameters`.
+
+#### RuntimeMedia
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `kind` | `'json' \| 'form' \| 'text' \| 'binary' \| 'sse' \| 'jsonl'` | How the content is read or written |
+| `schema` | `StandardSchemaV1`, optional | The content's schema; absent for binary content and a stream |
+| `events` | `{ [event]: StandardSchemaV1 \| null }`, optional | `sse`: each event's data, by name: a schema for JSON, `null` for text |
+| `item` | `StandardSchemaV1`, optional | `jsonl`: each item |
+
+A media type of a `RuntimeOperation`'s `body` or `responses`.
+
+## Traps
+
+- **Without `decode`, a reply is typed as JSON carries it**: with
+  `dates: 'date'`, a date-time is a string.
+- **A request is typed as JSON carries it, whatever `decode` says.** With
+  `dates: 'date'`, a date-time in a body or a query is still typed as a
+  string: pass `date.toISOString()`.
+- **Give each operation its exact statuses.** A `default` or `4XX` reply is
+  not generated, so it throws `UndeclaredStatusError`.
+- **A stream's request is refused where the stream is read**, not where
+  `stream()` is called: put the `try` around the `for await`.
+- **The client's `baseUrl` is still required outside a browser**, and its
+  options, `auth`, `retry` and `use` included, apply to every call the
+  binding makes.

package/dist/client/create-openapi-client.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `createOpenApiClient`: the operations `@nxgt/openapi-codegen` generates,
+ * bound onto a client of `createHttpClient`. The client sends; the binding
+ * adds what the spec knows: how each parameter and body is written, the
+ * replies each operation declares, and checks by the server's own schemas.
+ */
+import { type HttpClient } from '@nxgt/httpyz';
+import type { OpenApiArgs, OpenApiClient, OpenApiOptions, OperationsShape, OperationTable, RoutesOf } from './types';
+/**
+ * A client for a spec, bound to the `operations` table of the generated
+ * `operations.ts`, which carries the spec's types: nothing else to import.
+ *
+ * ```ts
+ * const http = createHttpClient({ baseUrl: 'https://api.example.com' });
+ * const api = createOpenApiClient(http, operations);
+ * const reply = await api.get('/employees/{id}', { param: { id } });
+ * if (reply.status === 200) reply.data.name;
+ * ```
+ *
+ * With `decode: true`, each reply is returned as its schema outputs it, and
+ * typed so. The types may also be given: `createOpenApiClient<ClientOperations,
+ * OperationsByRoute, true>`, whose `true` then requires `decode: true`.
+ */
+export declare function createOpenApiClient<Ops extends OperationsShape<Ops>, Routes = RoutesOf<Ops>>(http: HttpClient, operations: OperationTable<Ops>, options: OpenApiOptions & {
+    readonly decode: true;
+}): OpenApiClient<Ops, Routes, true>;
+export declare function createOpenApiClient<Ops extends OperationsShape<Ops>, Routes = RoutesOf<Ops>, Decoded extends boolean = false>(http: HttpClient, operations: OperationTable<Ops>, ...[given]: OpenApiArgs<Decoded>): OpenApiClient<Ops, Routes, Decoded>;
+//# sourceMappingURL=create-openapi-client.d.ts.map

package/dist/client/create-openapi-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-openapi-client.d.ts","sourceRoot":"","sources":["../../src/client/create-openapi-client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAEN,KAAK,UAAU,EAGf,MAAM,cAAc,CAAC;AAItB,OAAO,KAAK,EACX,WAAW,EACX,aAAa,EACb,cAAc,EACd,eAAe,EACf,cAAc,EACd,QAAQ,EAIR,MAAM,SAAS,CAAC;AA6DjB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAClC,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,EAEtB,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,cAAc,CAAC,GAAG,CAAC,EAC/B,OAAO,EAAE,cAAc,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,GACjD,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AACpC,wBAAgB,mBAAmB,CAClC,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,EACtB,OAAO,SAAS,OAAO,GAAG,KAAK,EAE/B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,cAAc,CAAC,GAAG,CAAC,EAC/B,GAAG,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,GAC9B,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC"}

package/dist/client/types.d.ts

@@ -0,0 +1,194 @@
+/**
+ * The types of a client bound to a generated spec. Every lookup is an index
+ * into the interfaces the generator wrote (`ClientOperations`,
+ * `OperationsByRoute`), so a call costs TypeScript the same whether the spec
+ * has five operations or five hundred.
+ */
+import type { CallOptions, EventStream, Method, ReconnectOptions, ServerEvent, StandardSchemaV1, Stream, WithResponse } from '@nxgt/httpyz';
+/** What the binding reads of an entry of the generated `ClientOperations`. */
+export interface ClientOperation {
+    readonly method: Method;
+    readonly path: string;
+    /** What a call takes after the `operationId`: `[input]`, `[input?]` or `[]`. */
+    readonly args: readonly unknown[];
+    /** Every declared reply, `{ status; type; data }`, decoded. */
+    readonly reply: unknown;
+    /** The same replies as JSON carries them. */
+    readonly wire: unknown;
+    /** A reply read an item at a time, when the operation has one. */
+    readonly stream?: OperationStream;
+}
+/** An operation's stream: server-sent events, or JSON lines. */
+export interface OperationStream {
+    readonly kind: 'sse' | 'jsonl';
+    /** Each item, decoded: an event narrowed on `event`, or a line. */
+    readonly item: unknown;
+    /** Each item as JSON carries it. */
+    readonly wire: unknown;
+}
+/** The generated `ClientOperations`: an entry per `operationId`. */
+export type OperationsShape<Ops> = {
+    [K in keyof Ops]: ClientOperation;
+};
+/** How a parameter is written: an entry of `parameters` in `operations.ts`. */
+export interface RuntimeParameter {
+    readonly name: string;
+    readonly in: 'path' | 'query' | 'header';
+    readonly required: boolean;
+    /** A query list as `?a=1&a=2` (true) or `?a=1,2` (false). */
+    readonly explode: boolean;
+    readonly list: boolean;
+}
+export interface RuntimeMedia {
+    readonly kind: 'json' | 'form' | 'text' | 'binary' | 'sse' | 'jsonl';
+    readonly schema?: StandardSchemaV1;
+    /** `sse`: each event's data, by name: a schema for JSON, `null` for text. */
+    readonly events?: {
+        readonly [event: string]: StandardSchemaV1 | null;
+    };
+    /** `jsonl`: each item. */
+    readonly item?: StandardSchemaV1;
+}
+/** What the binding reads of an entry of the generated `operations` table. */
+export interface RuntimeOperation {
+    readonly method: Method;
+    /** As the spec writes it: `/employees/{id}`. */
+    readonly path: string;
+    readonly parameters: readonly RuntimeParameter[];
+    /** The server's validators of each location, which read text: for `validate`. */
+    readonly param?: StandardSchemaV1;
+    readonly query?: StandardSchemaV1;
+    readonly header?: StandardSchemaV1;
+    readonly body?: {
+        readonly required: boolean;
+        readonly content: {
+            readonly [mediaType: string]: RuntimeMedia;
+        };
+    };
+    readonly responses: {
+        readonly [status: number]: {
+            readonly [mediaType: string]: RuntimeMedia;
+        };
+    };
+}
+/**
+ * The generated `operations` table, keyed like `ClientOperations`. Each entry
+ * carries its `ClientOperations` entry as `'~client'`, a type that is never
+ * set, which is how `createOpenApiClient(http, operations)` infers `Ops`.
+ */
+export type OperationTable<Ops> = {
+    readonly [K in keyof Ops]: RuntimeOperation & {
+        readonly '~client'?: Ops[K];
+    };
+};
+/** `OperationsByRoute`, worked out of `ClientOperations`: `'get /items/{id}'` to its `operationId`. */
+export type RoutesOf<Ops extends OperationsShape<Ops>> = {
+    [K in keyof Ops as `${Ops[K]['method']} ${Ops[K]['path']}`]: K;
+};
+export interface OpenApiOptions {
+    /**
+     * Checks with the spec's schemas, throwing a `ValidationError`: the
+     * request before it is sent, the reply before it is returned. `true` is
+     * both. Default: neither, since the types already hold both to the spec.
+     */
+    validate?: boolean | {
+        readonly request?: boolean;
+        readonly response?: boolean;
+    };
+}
+/**
+ * The binding's options, and `decode`, which returns each reply as its schema
+ * outputs it: with `dates: 'date'`, a date-time as a `Date`. It changes the
+ * replies' types: a client whose types are given says so in its third type
+ * argument, `createOpenApiClient<ClientOperations, OperationsByRoute, true>`,
+ * which in turn requires `decode: true`. Decoding validates the reply.
+ */
+export type OpenApiArgs<Decoded extends boolean> = Decoded extends true ? [options: OpenApiOptions & {
+    readonly decode: true;
+}] : [options?: OpenApiOptions & {
+    readonly decode?: false;
+}];
+/** What a call takes after its input: the core client's call options. */
+export type OperationInit = Omit<CallOptions, 'operationId'>;
+/** A call's arguments after the `operationId` or the path. */
+export type Args<Ops extends OperationsShape<Ops>, K extends keyof Ops> = [
+    ...Ops[K]['args'],
+    init?: OperationInit
+];
+/** An operation's replies: decoded, or as JSON carries them. */
+export type OperationReply<Ops extends OperationsShape<Ops>, K extends keyof Ops, Decoded extends boolean> = Decoded extends true ? Ops[K]['reply'] : Ops[K]['wire'];
+/** The operations that reply with a stream. Worked out once per client type. */
+export type StreamIds<Ops> = {
+    [K in keyof Ops]: Ops[K] extends {
+        readonly stream: OperationStream;
+    } ? K : never;
+}[keyof Ops] & string;
+/** What a stream takes after its input: the call options, and for events, how to resume. */
+export interface StreamInit extends OperationInit {
+    /**
+     * Events only: connects again when the connection drops or the stream
+     * ends, as `EventSource` does. Default: on, but for POST and PATCH.
+     */
+    reconnect?: boolean | ReconnectOptions;
+    /** Events only: sent as `Last-Event-ID` on the first connection. */
+    lastEventId?: string;
+    /** Events only: an event the spec does not declare, which is not yielded. */
+    onUnknownEvent?: (event: ServerEvent) => void;
+}
+/** A stream's arguments after the `operationId`. */
+export type StreamArgs<Ops extends OperationsShape<Ops>, K extends keyof Ops> = [...Ops[K]['args'], init?: StreamInit];
+/** What `stream()` returns: events narrowed on `event`, or lines; decoded, or as JSON carries them. */
+export type OperationStreamOf<Ops extends OperationsShape<Ops>, K extends keyof Ops, Decoded extends boolean> = Ops[K] extends {
+    readonly stream: {
+        readonly kind: infer Kind;
+        readonly item: infer Item;
+        readonly wire: infer Wire;
+    };
+} ? Kind extends 'sse' ? EventStream<Decoded extends true ? Item : Wire> : Stream<Decoded extends true ? Item : Wire> : never;
+/** A bound client whose calls end together. */
+export type OpenApiGroup<Ops extends OperationsShape<Ops>, Routes = RoutesOf<Ops>, Decoded extends boolean = false> = OpenApiClient<Ops, Routes, Decoded> & {
+    /**
+     * Aborts every call and stream of the group still running, with `reason`,
+     * or an `AbortError`. The group goes on: the calls made after it run.
+     */
+    cancel(reason?: unknown): void;
+    /** Aborts on the next `cancel()`: for work of your own that ends with the group's calls. */
+    readonly signal: AbortSignal;
+};
+/** The paths with an operation for method `M`: `'/items/{id}'` from `'get /items/{id}'`. */
+export type PathsOf<Routes, M extends Method> = keyof Routes extends infer Route ? Route extends `${M} ${infer Path}` ? Path : never : never;
+/** The methods the spec has an operation for: the only ones a client offers. */
+export type MethodsOf<Routes> = keyof Routes extends infer Route ? Route extends `${infer M extends Method} ${string}` ? M : never : never;
+/** The `operationId` of the operation at `M P`. */
+export type IdOf<Ops, Routes, M extends Method, P extends string> = Routes[`${M} ${P}` & keyof Routes] & keyof Ops;
+export type OpenApiClient<Ops extends OperationsShape<Ops>, Routes = RoutesOf<Ops>, Decoded extends boolean = false> = {
+    /** Calls an operation by its `operationId`. */
+    op<K extends keyof Ops & string>(id: K, ...args: Args<Ops, K>): Promise<WithResponse<OperationReply<Ops, K, Decoded>>>;
+    /**
+     * Reads an operation's stream, an item at a time, by its `operationId`:
+     * its events, each narrowed on `event`, or its JSON lines. It connects when
+     * read: `for await (const event of api.stream('watchFeed', input))`.
+     */
+    stream<K extends StreamIds<Ops>>(id: K, ...args: StreamArgs<Ops, K>): OperationStreamOf<Ops, K, Decoded>;
+    /**
+     * The same client over the core client's `group()`: its calls and streams
+     * also end on `cancel()`, a page's or a component's together.
+     */
+    group(): OpenApiGroup<Ops, Routes, Decoded>;
+    /**
+     * The generated `operations` the client was bound to: for a package built
+     * over it, such as `@nxgt/httpyz-query/openapi`, which reads the spec as
+     * the client does.
+     */
+    readonly operations: OperationTable<Ops>;
+} & PathMethods<Ops, Routes, Decoded>;
+/**
+ * A method per HTTP method the spec has an operation for, which calls the
+ * operation at a path: `api.get('/employees/{id}', { param: { id } })`. For
+ * a package that offers them on an object of its own, as
+ * `@nxgt/datasource-rest` does.
+ */
+export type PathMethods<Ops extends OperationsShape<Ops>, Routes = RoutesOf<Ops>, Decoded extends boolean = false> = {
+    readonly [M in MethodsOf<Routes>]: <P extends PathsOf<Routes, M>>(path: P, ...args: Args<Ops, IdOf<Ops, Routes, M, P>>) => Promise<WithResponse<OperationReply<Ops, IdOf<Ops, Routes, M, P>, Decoded>>>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/client/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EACX,WAAW,EACX,WAAW,EACX,MAAM,EACN,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,MAAM,EACN,YAAY,EACZ,MAAM,cAAc,CAAC;AAEtB,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;IAClC,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CAClC;AAED,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACvB;AAED,oEAAoE;AACpE,MAAM,MAAM,eAAe,CAAC,GAAG,IAAI;KAAG,CAAC,IAAI,MAAM,GAAG,GAAG,eAAe;CAAE,CAAC;AAEzE,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAA;KAAE,CAAC;IACxE,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACjC;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACjD,iFAAiF;IACjF,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE;QACf,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC3B,QAAQ,CAAC,OAAO,EAAE;YAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAAA;SAAE,CAAC;KACjE,CAAC;IACF,QAAQ,CAAC,SAAS,EAAE;QACnB,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG;YAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAAA;SAAE,CAAC;KAC1E,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,GAAG,IAAI;IACjC,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,GAAG,gBAAgB,GAAG;QAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;KAC5B;CACD,CAAC;AAEF,uGAAuG;AACvG,MAAM,MAAM,QAAQ,CAAC,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,IAAI;KACvD,CAAC,IAAI,MAAM,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC;CAC9D,CAAC;AAEF,MAAM,WAAW,cAAc;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EACN,OAAO,GACP;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC/D;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,OAAO,SAAS,OAAO,IAAI,OAAO,SAAS,IAAI,GACpE,CAAC,OAAO,EAAE,cAAc,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,GACrD,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAE5D,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;AAE7D,8DAA8D;AAC9D,MAAM,MAAM,IAAI,CAAC,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,IAAI;IACzE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,aAAa;CACpB,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,cAAc,CACzB,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,CAAC,SAAS,MAAM,GAAG,EACnB,OAAO,SAAS,OAAO,IACpB,OAAO,SAAS,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,gFAAgF;AAChF,MAAM,MAAM,SAAS,CAAC,GAAG,IAAI;KAC3B,CAAC,IAAI,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,SAAS;QAAE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;KAAE,GAClE,CAAC,GACD,KAAK;CACR,CAAC,MAAM,GAAG,CAAC,GACX,MAAM,CAAC;AAER,4FAA4F;AAC5F,MAAM,WAAW,UAAW,SAAQ,aAAa;IAChD;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;IACvC,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CAC9C;AAED,oDAAoD;AACpD,MAAM,MAAM,UAAU,CACrB,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,CAAC,SAAS,MAAM,GAAG,IAChB,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC;AAE3C,uGAAuG;AACvG,MAAM,MAAM,iBAAiB,CAC5B,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,CAAC,SAAS,MAAM,GAAG,EACnB,OAAO,SAAS,OAAO,IACpB,GAAG,CAAC,CAAC,CAAC,SAAS;IAClB,QAAQ,CAAC,MAAM,EAAE;QAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;QAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;QAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;KAC1B,CAAC;CACF,GACE,IAAI,SAAS,KAAK,GACjB,WAAW,CAAC,OAAO,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,GAC/C,MAAM,CAAC,OAAO,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,GAC3C,KAAK,CAAC;AAET,+CAA+C;AAC/C,MAAM,MAAM,YAAY,CACvB,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,EACtB,OAAO,SAAS,OAAO,GAAG,KAAK,IAC5B,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,GAAG;IACzC;;;OAGG;IACH,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,4FAA4F;IAC5F,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC7B,CAAC;AAEF,4FAA4F;AAC5F,MAAM,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,MAAM,MAAM,SAAS,MAAM,KAAK,GAC7E,KAAK,SAAS,GAAG,CAAC,IAAI,MAAM,IAAI,EAAE,GACjC,IAAI,GACJ,KAAK,GACN,KAAK,CAAC;AAET,gFAAgF;AAChF,MAAM,MAAM,SAAS,CAAC,MAAM,IAAI,MAAM,MAAM,SAAS,MAAM,KAAK,GAC7D,KAAK,SAAS,GAAG,MAAM,CAAC,SAAS,MAAM,IAAI,MAAM,EAAE,GAClD,CAAC,GACD,KAAK,GACN,KAAK,CAAC;AAET,mDAAmD;AACnD,MAAM,MAAM,IAAI,CACf,GAAG,EACH,MAAM,EACN,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,IACb,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC;AAEnD,MAAM,MAAM,aAAa,CACxB,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,EACtB,OAAO,SAAS,OAAO,GAAG,KAAK,IAC5B;IACH,+CAA+C;IAC/C,EAAE,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAC9B,EAAE,EAAE,CAAC,EACL,GAAG,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,GACnB,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1D;;;;OAIG;IACH,MAAM,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,CAAC,EAC9B,EAAE,EAAE,CAAC,EACL,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,GACzB,iBAAiB,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;IACtC;;;OAGG;IACH,KAAK,IAAI,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;CACzC,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CACtB,GAAG,SAAS,eAAe,CAAC,GAAG,CAAC,EAChC,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,EACtB,OAAO,SAAS,OAAO,GAAG,KAAK,IAC5B;IACH,QAAQ,EAAE,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAC/D,IAAI,EAAE,CAAC,EACP,GAAG,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,KACvC,OAAO,CACX,YAAY,CAAC,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CACnE;CACD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createOpenApiClient } from './client/create-openapi-client';
+export type { Args, ClientOperation, IdOf, MethodsOf, OpenApiArgs, OpenApiClient, OpenApiGroup, OpenApiOptions, OperationInit, OperationReply, OperationStream, OperationStreamOf, OperationsShape, OperationTable, PathMethods, PathsOf, RoutesOf, RuntimeMedia, RuntimeOperation, RuntimeParameter, StreamArgs, StreamIds, StreamInit, } from './client/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,YAAY,EACX,IAAI,EACJ,eAAe,EACf,IAAI,EACJ,SAAS,EACT,WAAW,EACX,aAAa,EACb,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,WAAW,EACX,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,SAAS,EACT,UAAU,GACV,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,296 @@
+// src/client/create-openapi-client.ts
+import {
+  ValidationError
+} from "@nxgt/httpyz";
+import { METHODS } from "@nxgt/httpyz/integration";
+
+// src/request/check-request.ts
+import { absent, check, fields, text } from "@nxgt/httpyz/integration";
+async function checkRequest(operation, input) {
+  const issues = [];
+  const run = async (target, schema, value) => {
+    if (!schema)
+      return;
+    const result = await check(schema, value, target);
+    if (!result.ok)
+      issues.push(...result.issues);
+  };
+  const { param, query, header } = readParameters(operation, input);
+  await run("param", operation.param, param);
+  await run("query", operation.query, query);
+  await run("header", operation.header, header);
+  const content = Object.values(operation.body?.content ?? {});
+  const schemaOf = (kind) => content.find((media) => media.kind === kind)?.schema;
+  if (input?.json !== undefined) {
+    const sent = JSON.stringify(input.json);
+    await run("json", schemaOf("json"), sent === undefined ? undefined : JSON.parse(sent));
+  } else if (input?.form !== undefined) {
+    await run("form", schemaOf("form"), formFields(input.form));
+  } else if (input?.text !== undefined) {
+    await run("body", schemaOf("text"), input.text);
+  }
+  return issues;
+}
+function readParameters(operation, input) {
+  const read = { param: {}, query: {}, header: {} };
+  for (const parameter of operation.parameters) {
+    const { name, list } = parameter;
+    if (parameter.in === "path") {
+      const value = input?.param?.[name];
+      if (!absent(value))
+        read.param[name] = text(value);
+      continue;
+    }
+    const value = parameter.in === "query" ? input?.query?.[name] : input?.header?.[name.toLowerCase()];
+    if (absent(value))
+      continue;
+    const values = Array.isArray(value) ? value.map(text) : [text(value)];
+    if (parameter.in === "header") {
+      const sent = values.join(",").trim();
+      read.header[name.toLowerCase()] = list ? sent.split(",").map((item) => item.trim()) : sent;
+    } else if (list) {
+      read.query[name] = parameter.explode ? values : values.join(",").split(",");
+    } else
+      read.query[name] = values.join(",");
+  }
+  return read;
+}
+function formFields(form) {
+  const read = {};
+  for (const [name, value] of fields(form)) {
+    const item = value instanceof Blob && !(value instanceof File) ? new File([value], "blob", { type: value.type }) : value;
+    const held = read[name];
+    read[name] = held === undefined ? name.endsWith("[]") ? [item] : item : Array.isArray(held) ? [...held, item] : [held, item];
+  }
+  return read;
+}
+
+// src/request/to-request.ts
+import {
+  absent as absent2,
+  text as text2,
+  toFormData,
+  toSearchParams
+} from "@nxgt/httpyz/integration";
+var concrete = (type, fallback) => type === undefined || type.includes("*") ? fallback : type;
+function toRequest(operation, input, headers) {
+  const query = new URLSearchParams;
+  for (const param of operation.parameters) {
+    if (param.in === "query") {
+      appendQuery(query, param, input?.query?.[param.name]);
+    } else if (param.in === "header") {
+      const value = input?.header?.[param.name.toLowerCase()];
+      if (absent2(value))
+        continue;
+      headers.set(param.name, Array.isArray(value) ? value.map(text2).join(",") : text2(value));
+    }
+  }
+  return { query, body: toBody(operation, input, headers) };
+}
+function appendQuery(search, param, value) {
+  if (absent2(value))
+    return;
+  if (!Array.isArray(value))
+    search.append(param.name, text2(value));
+  else if (param.explode) {
+    for (const item of value)
+      search.append(param.name, text2(item));
+  } else
+    search.append(param.name, value.map(text2).join(","));
+}
+function toBody(operation, input, headers) {
+  if (input === undefined)
+    return {};
+  const content = Object.entries(operation.body?.content ?? {});
+  const declared = (kind) => content.find(([, media]) => media.kind === kind)?.[0];
+  if (input.json !== undefined) {
+    headers.set("content-type", concrete(declared("json"), "application/json"));
+    return { json: input.json };
+  }
+  if (input.form !== undefined) {
+    return {
+      form: declared("form") === "application/x-www-form-urlencoded" ? toSearchParams(input.form) : toFormData(input.form)
+    };
+  }
+  if (input.text !== undefined) {
+    headers.set("content-type", concrete(declared("text"), "text/plain"));
+    return { text: input.text };
+  }
+  if (input.body !== undefined) {
+    headers.set("content-type", concrete(declared("binary"), "application/octet-stream"));
+    return { body: input.body };
+  }
+  return {};
+}
+
+// src/client/create-openapi-client.ts
+var toResponses = (operation) => Object.fromEntries(Object.entries(operation.responses).map(([status, content]) => [
+  status,
+  Object.keys(content).length === 0 ? null : Object.fromEntries(Object.entries(content).map(([type, media]) => [
+    type,
+    media.schema ?? null
+  ]))
+]));
+function streamOf(operation) {
+  for (const [status, content] of Object.entries(operation.responses)) {
+    const code = Number(status);
+    if (code < 200 || code > 299)
+      continue;
+    for (const [type, media] of Object.entries(content)) {
+      if (media.kind === "sse" || media.kind === "jsonl")
+        return [type, media];
+    }
+  }
+  return;
+}
+function checkedFirst(open, check) {
+  let inner;
+  let closed = false;
+  return {
+    get lastEventId() {
+      return inner?.lastEventId;
+    },
+    close() {
+      closed = true;
+      inner?.close();
+    },
+    async* [Symbol.asyncIterator]() {
+      if (!inner) {
+        await check();
+        if (closed)
+          return;
+        inner = open();
+      }
+      yield* inner;
+    }
+  };
+}
+function createOpenApiClient(http, operations, given) {
+  return bind(http, operations, given ?? {}, () => {
+    return;
+  });
+}
+var joined = (given, scope) => scope === undefined ? given : given ? AbortSignal.any([given, scope]) : scope;
+function bind(http, operations, options, scope) {
+  const { validate = false } = options;
+  const decode = options.decode === true;
+  const checks = {
+    request: validate === true || typeof validate === "object" && validate.request === true,
+    response: decode || validate === true || typeof validate === "object" && validate.response === true
+  };
+  const table = operations;
+  const byRoute = new Map;
+  const responses = new Map;
+  for (const [id, operation] of Object.entries(table)) {
+    byRoute.set(`${operation.method} ${operation.path}`, id);
+    responses.set(id, toResponses(operation));
+  }
+  const read = (id, args) => {
+    const operation = table[id];
+    if (!operation)
+      throw new Error(`${id} is not an operationId of the spec`);
+    const takes = operation.parameters.length > 0 || Object.keys(operation.body?.content ?? {}).length > 0;
+    const input = takes ? args[0] : undefined;
+    const given = (takes ? args[1] : args[0]) ?? {};
+    const signal = joined(given.signal, scope());
+    const init = signal ? { ...given, signal } : given;
+    return { operation, input, init };
+  };
+  const check = async (id, operation, input) => {
+    if (!checks.request)
+      return;
+    const issues = await checkRequest(operation, input);
+    if (issues.length === 0)
+      return;
+    const context = {
+      operationId: id,
+      method: operation.method,
+      path: operation.path
+    };
+    throw new ValidationError(context, {
+      kind: "request",
+      ...context,
+      issues
+    });
+  };
+  const written = (id, operation, input, init) => {
+    const headers = new Headers(init.headers);
+    const { query, body } = toRequest(operation, input, headers);
+    return {
+      ...init,
+      ...body,
+      param: input?.param,
+      query,
+      headers,
+      operationId: id
+    };
+  };
+  const call = async (id, args) => {
+    const { operation, input, init } = read(id, args);
+    await check(id, operation, input);
+    const request = http.request;
+    return request(operation.method, operation.path, {
+      ...written(id, operation, input, init),
+      responses: responses.get(id),
+      validate: checks.response,
+      decode
+    });
+  };
+  const stream = (id, args) => {
+    const { operation, input, init } = read(id, args);
+    const found = streamOf(operation);
+    if (!found)
+      throw new Error(`${id} does not reply with a stream`);
+    const [type, media] = found;
+    const { reconnect, lastEventId, onUnknownEvent, ...rest } = init;
+    const open = () => {
+      const request = written(id, operation, input, rest);
+      if (!request.headers.has("accept"))
+        request.headers.set("accept", type);
+      const common = {
+        ...request,
+        method: operation.method,
+        validate: checks.response,
+        decode
+      };
+      const openStream = media.kind === "sse" ? http.events : http.lines;
+      return openStream(operation.path, media.kind === "sse" ? {
+        ...common,
+        events: media.events,
+        reconnect,
+        lastEventId,
+        onUnknownEvent
+      } : { ...common, item: media.item });
+    };
+    return checks.request ? checkedFirst(open, () => check(id, operation, input)) : open();
+  };
+  const client = {
+    operations,
+    op: (id, ...args) => call(id, args),
+    stream: (id, ...args) => stream(id, args),
+    group: () => {
+      const group = http.group();
+      const bound = bind(group, operations, options, () => group.signal);
+      return Object.defineProperties(bound, {
+        cancel: { enumerable: true, value: group.cancel },
+        signal: { enumerable: true, get: () => group.signal }
+      });
+    }
+  };
+  for (const method of METHODS) {
+    client[method] = (path, ...args) => {
+      const id = byRoute.get(`${method} ${path}`);
+      if (id === undefined) {
+        return Promise.reject(new Error(`The spec has no ${method.toUpperCase()} ${path} operation`));
+      }
+      return call(id, args);
+    };
+  }
+  return client;
+}
+export {
+  createOpenApiClient
+};
+
+//# debugId=D3AB5DC616E1E63964756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/client/create-openapi-client.ts", "../src/request/check-request.ts", "../src/request/to-request.ts"],
+  "sourcesContent": [
+    "/**\n * `createOpenApiClient`: the operations `@nxgt/openapi-codegen` generates,\n * bound onto a client of `createHttpClient`. The client sends; the binding\n * adds what the spec knows: how each parameter and body is written, the\n * replies each operation declares, and checks by the server's own schemas.\n */\nimport {\n\ttype EventStream,\n\ttype HttpClient,\n\ttype Responses,\n\tValidationError,\n} from '@nxgt/httpyz';\nimport { METHODS } from '@nxgt/httpyz/integration';\nimport { checkRequest } from '../request/check-request';\nimport { type Input, toRequest } from '../request/to-request';\nimport type {\n\tOpenApiArgs,\n\tOpenApiClient,\n\tOpenApiOptions,\n\tOperationsShape,\n\tOperationTable,\n\tRoutesOf,\n\tRuntimeMedia,\n\tRuntimeOperation,\n\tStreamInit,\n} from './types';\n\n/** An operation's replies as the core client declares them. */\nconst toResponses = (operation: RuntimeOperation): Responses =>\n\tObject.fromEntries(\n\t\tObject.entries(operation.responses).map(([status, content]) => [\n\t\t\tstatus,\n\t\t\tObject.keys(content).length === 0\n\t\t\t\t? null\n\t\t\t\t: Object.fromEntries(\n\t\t\t\t\t\tObject.entries(content).map(([type, media]) => [\n\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\tmedia.schema ?? null,\n\t\t\t\t\t\t]),\n\t\t\t\t\t),\n\t\t]),\n\t);\n\n/** The stream an operation replies with, and its media type: the first of its 2xx replies. */\nfunction streamOf(\n\toperation: RuntimeOperation,\n): [type: string, media: RuntimeMedia] | undefined {\n\tfor (const [status, content] of Object.entries(operation.responses)) {\n\t\tconst code = Number(status);\n\t\tif (code < 200 || code > 299) continue;\n\t\tfor (const [type, media] of Object.entries(content)) {\n\t\t\tif (media.kind === 'sse' || media.kind === 'jsonl') return [type, media];\n\t\t}\n\t}\n\treturn undefined;\n}\n\n/**\n * `open()`'s stream, opened once `check` passes on the first read: a request\n * the spec refuses is never sent, and throws where the stream is read.\n */\nfunction checkedFirst<T>(\n\topen: () => EventStream<T>,\n\tcheck: () => Promise<void>,\n): EventStream<T> {\n\tlet inner: EventStream<T> | undefined;\n\tlet closed = false;\n\treturn {\n\t\tget lastEventId() {\n\t\t\treturn inner?.lastEventId;\n\t\t},\n\t\tclose() {\n\t\t\tclosed = true;\n\t\t\tinner?.close();\n\t\t},\n\t\tasync *[Symbol.asyncIterator]() {\n\t\t\tif (!inner) {\n\t\t\t\tawait check();\n\t\t\t\tif (closed) return;\n\t\t\t\tinner = open();\n\t\t\t}\n\t\t\tyield* inner;\n\t\t},\n\t};\n}\n\n/**\n * A client for a spec, bound to the `operations` table of the generated\n * `operations.ts`, which carries the spec's types: nothing else to import.\n *\n * ```ts\n * const http = createHttpClient({ baseUrl: 'https://api.example.com' });\n * const api = createOpenApiClient(http, operations);\n * const reply = await api.get('/employees/{id}', { param: { id } });\n * if (reply.status === 200) reply.data.name;\n * ```\n *\n * With `decode: true`, each reply is returned as its schema outputs it, and\n * typed so. The types may also be given: `createOpenApiClient<ClientOperations,\n * OperationsByRoute, true>`, whose `true` then requires `decode: true`.\n */\nexport function createOpenApiClient<\n\tOps extends OperationsShape<Ops>,\n\tRoutes = RoutesOf<Ops>,\n>(\n\thttp: HttpClient,\n\toperations: OperationTable<Ops>,\n\toptions: OpenApiOptions & { readonly decode: true },\n): OpenApiClient<Ops, Routes, true>;\nexport function createOpenApiClient<\n\tOps extends OperationsShape<Ops>,\n\tRoutes = RoutesOf<Ops>,\n\tDecoded extends boolean = false,\n>(\n\thttp: HttpClient,\n\toperations: OperationTable<Ops>,\n\t...[given]: OpenApiArgs<Decoded>\n): OpenApiClient<Ops, Routes, Decoded>;\nexport function createOpenApiClient<\n\tOps extends OperationsShape<Ops>,\n\tRoutes,\n\tDecoded extends boolean,\n>(\n\thttp: HttpClient,\n\toperations: OperationTable<Ops>,\n\tgiven?: OpenApiOptions & { readonly decode?: boolean },\n): OpenApiClient<Ops, Routes, Decoded> {\n\treturn bind(http, operations, given ?? {}, () => undefined);\n}\n\n/** Both signals: a call ends on either. */\nconst joined = (\n\tgiven: AbortSignal | null | undefined,\n\tscope: AbortSignal | undefined,\n): AbortSignal | null | undefined =>\n\tscope === undefined ? given : given ? AbortSignal.any([given, scope]) : scope;\n\n/**\n * The client, whose calls also end on `scope()`'s signal, read as each call\n * is made: a call checked before it is sent reaches the core client later,\n * after a `cancel()` of its group may already have swapped the signal.\n */\nfunction bind<\n\tOps extends OperationsShape<Ops>,\n\tRoutes,\n\tDecoded extends boolean,\n>(\n\thttp: HttpClient,\n\toperations: OperationTable<Ops>,\n\toptions: OpenApiOptions & { readonly decode?: boolean },\n\tscope: () => AbortSignal | undefined,\n): OpenApiClient<Ops, Routes, Decoded> {\n\tconst { validate = false } = options;\n\tconst decode = options.decode === true;\n\tconst checks = {\n\t\trequest:\n\t\t\tvalidate === true ||\n\t\t\t(typeof validate === 'object' && validate.request === true),\n\t\tresponse:\n\t\t\tdecode ||\n\t\t\tvalidate === true ||\n\t\t\t(typeof validate === 'object' && validate.response === true),\n\t};\n\tconst table = operations as unknown as {\n\t\treadonly [id: string]: RuntimeOperation;\n\t};\n\tconst byRoute = new Map<string, string>();\n\tconst responses = new Map<string, Responses>();\n\tfor (const [id, operation] of Object.entries(table)) {\n\t\tbyRoute.set(`${operation.method} ${operation.path}`, id);\n\t\tresponses.set(id, toResponses(operation));\n\t}\n\n\t/** The operation, and its arguments: the input, then the init. */\n\tconst read = (id: string, args: readonly unknown[]) => {\n\t\tconst operation = table[id];\n\t\tif (!operation) throw new Error(`${id} is not an operationId of the spec`);\n\t\t// An operation that takes nothing has no input: its first argument is the init.\n\t\tconst takes =\n\t\t\toperation.parameters.length > 0 ||\n\t\t\tObject.keys(operation.body?.content ?? {}).length > 0;\n\t\tconst input = (takes ? args[0] : undefined) as Input | undefined;\n\t\tconst given = ((takes ? args[1] : args[0]) ?? {}) as StreamInit;\n\t\tconst signal = joined(given.signal, scope());\n\t\tconst init = signal ? { ...given, signal } : given;\n\t\treturn { operation, input, init };\n\t};\n\n\t/** Throws what the server would refuse, before anything is sent. */\n\tconst check = async (\n\t\tid: string,\n\t\toperation: RuntimeOperation,\n\t\tinput: Input | undefined,\n\t): Promise<void> => {\n\t\tif (!checks.request) return;\n\t\tconst issues = await checkRequest(operation, input);\n\t\tif (issues.length === 0) return;\n\t\tconst context = {\n\t\t\toperationId: id,\n\t\t\tmethod: operation.method,\n\t\t\tpath: operation.path,\n\t\t};\n\t\tthrow new ValidationError(context, {\n\t\t\tkind: 'request',\n\t\t\t...context,\n\t\t\tissues,\n\t\t});\n\t};\n\n\t/** The core client's options for the input, written as the server reads it. */\n\tconst written = (\n\t\tid: string,\n\t\toperation: RuntimeOperation,\n\t\tinput: Input | undefined,\n\t\tinit: object & { headers?: HeadersInit },\n\t) => {\n\t\tconst headers = new Headers(init.headers);\n\t\tconst { query, body } = toRequest(operation, input, headers);\n\t\treturn {\n\t\t\t...init,\n\t\t\t...body,\n\t\t\tparam: input?.param,\n\t\t\tquery,\n\t\t\theaders,\n\t\t\toperationId: id,\n\t\t};\n\t};\n\n\tconst call = async (\n\t\tid: string,\n\t\targs: readonly unknown[],\n\t): Promise<unknown> => {\n\t\tconst { operation, input, init } = read(id, args);\n\t\tawait check(id, operation, input);\n\t\tconst request = http.request as (\n\t\t\tmethod: string,\n\t\t\tpath: string,\n\t\t\toptions: object,\n\t\t) => Promise<unknown>;\n\t\treturn request(operation.method, operation.path, {\n\t\t\t...written(id, operation, input, init),\n\t\t\tresponses: responses.get(id),\n\t\t\tvalidate: checks.response,\n\t\t\tdecode,\n\t\t});\n\t};\n\n\tconst stream = (id: string, args: readonly unknown[]) => {\n\t\tconst { operation, input, init } = read(id, args);\n\t\tconst found = streamOf(operation);\n\t\tif (!found) throw new Error(`${id} does not reply with a stream`);\n\t\tconst [type, media] = found;\n\t\tconst { reconnect, lastEventId, onUnknownEvent, ...rest } = init;\n\t\tconst open = () => {\n\t\t\tconst request = written(id, operation, input, rest);\n\t\t\t// The media type the spec declares, which may not be the core client's default.\n\t\t\tif (!request.headers.has('accept')) request.headers.set('accept', type);\n\t\t\tconst common = {\n\t\t\t\t...request,\n\t\t\t\tmethod: operation.method,\n\t\t\t\tvalidate: checks.response,\n\t\t\t\tdecode,\n\t\t\t};\n\t\t\tconst openStream = (media.kind === 'sse' ? http.events : http.lines) as (\n\t\t\t\tpath: string,\n\t\t\t\toptions: object,\n\t\t\t) => EventStream<unknown>;\n\t\t\treturn openStream(\n\t\t\t\toperation.path,\n\t\t\t\tmedia.kind === 'sse'\n\t\t\t\t\t? {\n\t\t\t\t\t\t\t...common,\n\t\t\t\t\t\t\tevents: media.events,\n\t\t\t\t\t\t\treconnect,\n\t\t\t\t\t\t\tlastEventId,\n\t\t\t\t\t\t\tonUnknownEvent,\n\t\t\t\t\t\t}\n\t\t\t\t\t: { ...common, item: media.item },\n\t\t\t);\n\t\t};\n\t\treturn checks.request\n\t\t\t? checkedFirst(open, () => check(id, operation, input))\n\t\t\t: open();\n\t};\n\n\tconst client: Record<string, unknown> = {\n\t\toperations,\n\t\top: (id: string, ...args: unknown[]) => call(id, args),\n\t\tstream: (id: string, ...args: unknown[]) => stream(id, args),\n\t\tgroup: () => {\n\t\t\tconst group = http.group();\n\t\t\tconst bound = bind<Ops, Routes, Decoded>(\n\t\t\t\tgroup,\n\t\t\t\toperations,\n\t\t\t\toptions,\n\t\t\t\t() => group.signal,\n\t\t\t);\n\t\t\treturn Object.defineProperties(bound, {\n\t\t\t\tcancel: { enumerable: true, value: group.cancel },\n\t\t\t\tsignal: { enumerable: true, get: () => group.signal },\n\t\t\t});\n\t\t},\n\t};\n\tfor (const method of METHODS) {\n\t\tclient[method] = (path: string, ...args: unknown[]) => {\n\t\t\tconst id = byRoute.get(`${method} ${path}`);\n\t\t\tif (id === undefined) {\n\t\t\t\treturn Promise.reject(\n\t\t\t\t\tnew Error(\n\t\t\t\t\t\t`The spec has no ${method.toUpperCase()} ${path} operation`,\n\t\t\t\t\t),\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn call(id, args);\n\t\t};\n\t}\n\treturn client as unknown as OpenApiClient<Ops, Routes, Decoded>;\n}\n",
+    "/**\n * A request checked before it is sent, by the validators the server runs, on\n * what `@nxgt/openapi-hono` will read from it: each parameter as the\n * text it travels as, the JSON as it parses, a form as its fields. What the\n * server would refuse is refused here with the same issues, and nothing is\n * sent.\n */\nimport type { StandardSchemaV1, ValidationIssue } from '@nxgt/httpyz';\nimport { absent, check, fields, text } from '@nxgt/httpyz/integration';\nimport type { RuntimeMedia, RuntimeOperation } from '../client/types';\nimport type { Input } from './to-request';\n\nexport async function checkRequest(\n\toperation: RuntimeOperation,\n\tinput: Input | undefined,\n): Promise<ValidationIssue[]> {\n\tconst issues: ValidationIssue[] = [];\n\tconst run = async (\n\t\ttarget: ValidationIssue['target'],\n\t\tschema: StandardSchemaV1 | undefined,\n\t\tvalue: unknown,\n\t): Promise<void> => {\n\t\tif (!schema) return;\n\t\tconst result = await check(schema, value, target);\n\t\tif (!result.ok) issues.push(...result.issues);\n\t};\n\tconst { param, query, header } = readParameters(operation, input);\n\t// In the server's order, so the issues come out in the same one.\n\tawait run('param', operation.param, param);\n\tawait run('query', operation.query, query);\n\tawait run('header', operation.header, header);\n\tconst content = Object.values(operation.body?.content ?? {});\n\tconst schemaOf = (kind: RuntimeMedia['kind']) =>\n\t\tcontent.find((media) => media.kind === kind)?.schema;\n\tif (input?.json !== undefined) {\n\t\tconst sent = JSON.stringify(input.json);\n\t\tawait run(\n\t\t\t'json',\n\t\t\tschemaOf('json'),\n\t\t\tsent === undefined ? undefined : JSON.parse(sent),\n\t\t);\n\t} else if (input?.form !== undefined) {\n\t\tawait run('form', schemaOf('form'), formFields(input.form));\n\t} else if (input?.text !== undefined) {\n\t\tawait run('body', schemaOf('text'), input.text);\n\t}\n\treturn issues;\n}\n\n/** The parameters as the engine reads them: strings, a list as every value. */\nfunction readParameters(\n\toperation: RuntimeOperation,\n\tinput: Input | undefined,\n): Record<'param' | 'query' | 'header', Record<string, unknown>> {\n\tconst read = { param: {}, query: {}, header: {} } as Record<\n\t\t'param' | 'query' | 'header',\n\t\tRecord<string, unknown>\n\t>;\n\tfor (const parameter of operation.parameters) {\n\t\tconst { name, list } = parameter;\n\t\tif (parameter.in === 'path') {\n\t\t\tconst value = input?.param?.[name];\n\t\t\tif (!absent(value)) read.param[name] = text(value);\n\t\t\tcontinue;\n\t\t}\n\t\tconst value =\n\t\t\tparameter.in === 'query'\n\t\t\t\t? input?.query?.[name]\n\t\t\t\t: input?.header?.[name.toLowerCase()];\n\t\tif (absent(value)) continue;\n\t\tconst values = Array.isArray(value) ? value.map(text) : [text(value)];\n\t\tif (parameter.in === 'header') {\n\t\t\t// Headers trims what it holds.\n\t\t\tconst sent = values.join(',').trim();\n\t\t\tread.header[name.toLowerCase()] = list\n\t\t\t\t? sent.split(',').map((item) => item.trim())\n\t\t\t\t: sent;\n\t\t} else if (list) {\n\t\t\tread.query[name] = parameter.explode\n\t\t\t\t? values\n\t\t\t\t: values.join(',').split(',');\n\t\t} else read.query[name] = values.join(',');\n\t}\n\treturn read;\n}\n\n/**\n * A form as Hono's `parseBody({ all: true })` reads it: a field sent once is\n * its value, one sent again or named `x[]` a list, and a `Blob` a `File`.\n */\nfunction formFields(\n\tform: Readonly<Record<string, unknown>>,\n): Record<string, unknown> {\n\tconst read: Record<string, unknown> = {};\n\tfor (const [name, value] of fields(form)) {\n\t\tconst item =\n\t\t\tvalue instanceof Blob && !(value instanceof File)\n\t\t\t\t? new File([value], 'blob', { type: value.type })\n\t\t\t\t: value;\n\t\tconst held = read[name];\n\t\tread[name] =\n\t\t\theld === undefined\n\t\t\t\t? name.endsWith('[]')\n\t\t\t\t\t? [item]\n\t\t\t\t\t: item\n\t\t\t\t: Array.isArray(held)\n\t\t\t\t\t? [...held, item]\n\t\t\t\t\t: [held, item];\n\t}\n\treturn read;\n}\n",
+    "/**\n * An operation's input as a call of the core client, written the way\n * `@nxgt/openapi-hono` reads it back: a query list as a repeated key,\n * or joined with commas when the spec says `explode: false`; a header list\n * joined with commas; the body as the media type the spec declares for its\n * kind.\n */\nimport type { BodyInput } from '@nxgt/httpyz';\nimport {\n\tabsent,\n\ttext,\n\ttoFormData,\n\ttoSearchParams,\n} from '@nxgt/httpyz/integration';\nimport type {\n\tRuntimeMedia,\n\tRuntimeOperation,\n\tRuntimeParameter,\n} from '../client/types';\n\n/** What an input may hold, as `ClientOperations` types it. */\nexport interface Input {\n\treadonly param?: Readonly<Record<string, unknown>>;\n\treadonly query?: Readonly<Record<string, unknown>>;\n\t/** Keyed by lowercased name. */\n\treadonly header?: Readonly<Record<string, unknown>>;\n\treadonly json?: unknown;\n\treadonly form?: Readonly<Record<string, unknown>>;\n\treadonly text?: string;\n\treadonly body?: Blob | ArrayBuffer | Uint8Array;\n}\n\n/** What to send as `Content-Type` for a declared media type, which may be a range. */\nconst concrete = (type: string | undefined, fallback: string): string =>\n\ttype === undefined || type.includes('*') ? fallback : type;\n\n/** The query and the body; the header parameters and the body's type go onto `headers`. */\nexport function toRequest(\n\toperation: RuntimeOperation,\n\tinput: Input | undefined,\n\theaders: Headers,\n): { query: URLSearchParams; body: BodyInput } {\n\tconst query = new URLSearchParams();\n\tfor (const param of operation.parameters) {\n\t\tif (param.in === 'query') {\n\t\t\tappendQuery(query, param, input?.query?.[param.name]);\n\t\t} else if (param.in === 'header') {\n\t\t\tconst value = input?.header?.[param.name.toLowerCase()];\n\t\t\tif (absent(value)) continue;\n\t\t\theaders.set(\n\t\t\t\tparam.name,\n\t\t\t\tArray.isArray(value) ? value.map(text).join(',') : text(value),\n\t\t\t);\n\t\t}\n\t}\n\treturn { query, body: toBody(operation, input, headers) };\n}\n\nfunction appendQuery(\n\tsearch: URLSearchParams,\n\tparam: RuntimeParameter,\n\tvalue: unknown,\n): void {\n\tif (absent(value)) return;\n\tif (!Array.isArray(value)) search.append(param.name, text(value));\n\telse if (param.explode) {\n\t\tfor (const item of value) search.append(param.name, text(item));\n\t} else search.append(param.name, value.map(text).join(','));\n}\n\nfunction toBody(\n\toperation: RuntimeOperation,\n\tinput: Input | undefined,\n\theaders: Headers,\n): BodyInput {\n\tif (input === undefined) return {};\n\tconst content = Object.entries(operation.body?.content ?? {});\n\tconst declared = (kind: RuntimeMedia['kind']): string | undefined =>\n\t\tcontent.find(([, media]) => media.kind === kind)?.[0];\n\tif (input.json !== undefined) {\n\t\theaders.set('content-type', concrete(declared('json'), 'application/json'));\n\t\treturn { json: input.json };\n\t}\n\tif (input.form !== undefined) {\n\t\treturn {\n\t\t\tform:\n\t\t\t\tdeclared('form') === 'application/x-www-form-urlencoded'\n\t\t\t\t\t? toSearchParams(input.form)\n\t\t\t\t\t: toFormData(input.form),\n\t\t};\n\t}\n\tif (input.text !== undefined) {\n\t\theaders.set('content-type', concrete(declared('text'), 'text/plain'));\n\t\treturn { text: input.text };\n\t}\n\tif (input.body !== undefined) {\n\t\theaders.set(\n\t\t\t'content-type',\n\t\t\tconcrete(declared('binary'), 'application/octet-stream'),\n\t\t);\n\t\treturn { body: input.body };\n\t}\n\treturn {};\n}\n"
+  ],
+  "mappings": ";AAMA;AAAA;AAAA;AAMA;;;ACJA;AAIA,eAAsB,YAAY,CACjC,WACA,OAC6B;AAAA,EAC7B,MAAM,SAA4B,CAAC;AAAA,EACnC,MAAM,MAAM,OACX,QACA,QACA,UACmB;AAAA,IACnB,IAAI,CAAC;AAAA,MAAQ;AAAA,IACb,MAAM,SAAS,MAAM,MAAM,QAAQ,OAAO,MAAM;AAAA,IAChD,IAAI,CAAC,OAAO;AAAA,MAAI,OAAO,KAAK,GAAG,OAAO,MAAM;AAAA;AAAA,EAE7C,QAAQ,OAAO,OAAO,WAAW,eAAe,WAAW,KAAK;AAAA,EAEhE,MAAM,IAAI,SAAS,UAAU,OAAO,KAAK;AAAA,EACzC,MAAM,IAAI,SAAS,UAAU,OAAO,KAAK;AAAA,EACzC,MAAM,IAAI,UAAU,UAAU,QAAQ,MAAM;AAAA,EAC5C,MAAM,UAAU,OAAO,OAAO,UAAU,MAAM,WAAW,CAAC,CAAC;AAAA,EAC3D,MAAM,WAAW,CAAC,SACjB,QAAQ,KAAK,CAAC,UAAU,MAAM,SAAS,IAAI,GAAG;AAAA,EAC/C,IAAI,OAAO,SAAS,WAAW;AAAA,IAC9B,MAAM,OAAO,KAAK,UAAU,MAAM,IAAI;AAAA,IACtC,MAAM,IACL,QACA,SAAS,MAAM,GACf,SAAS,YAAY,YAAY,KAAK,MAAM,IAAI,CACjD;AAAA,EACD,EAAO,SAAI,OAAO,SAAS,WAAW;AAAA,IACrC,MAAM,IAAI,QAAQ,SAAS,MAAM,GAAG,WAAW,MAAM,IAAI,CAAC;AAAA,EAC3D,EAAO,SAAI,OAAO,SAAS,WAAW;AAAA,IACrC,MAAM,IAAI,QAAQ,SAAS,MAAM,GAAG,MAAM,IAAI;AAAA,EAC/C;AAAA,EACA,OAAO;AAAA;AAIR,SAAS,cAAc,CACtB,WACA,OACgE;AAAA,EAChE,MAAM,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,QAAQ,CAAC,EAAE;AAAA,EAIhD,WAAW,aAAa,UAAU,YAAY;AAAA,IAC7C,QAAQ,MAAM,SAAS;AAAA,IACvB,IAAI,UAAU,OAAO,QAAQ;AAAA,MAC5B,MAAM,QAAQ,OAAO,QAAQ;AAAA,MAC7B,IAAI,CAAC,OAAO,KAAK;AAAA,QAAG,KAAK,MAAM,QAAQ,KAAK,KAAK;AAAA,MACjD;AAAA,IACD;AAAA,IACA,MAAM,QACL,UAAU,OAAO,UACd,OAAO,QAAQ,QACf,OAAO,SAAS,KAAK,YAAY;AAAA,IACrC,IAAI,OAAO,KAAK;AAAA,MAAG;AAAA,IACnB,MAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC;AAAA,IACpE,IAAI,UAAU,OAAO,UAAU;AAAA,MAE9B,MAAM,OAAO,OAAO,KAAK,GAAG,EAAE,KAAK;AAAA,MACnC,KAAK,OAAO,KAAK,YAAY,KAAK,OAC/B,KAAK,MAAM,GAAG,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,IACzC;AAAA,IACJ,EAAO,SAAI,MAAM;AAAA,MAChB,KAAK,MAAM,QAAQ,UAAU,UAC1B,SACA,OAAO,KAAK,GAAG,EAAE,MAAM,GAAG;AAAA,IAC9B,EAAO;AAAA,WAAK,MAAM,QAAQ,OAAO,KAAK,GAAG;AAAA,EAC1C;AAAA,EACA,OAAO;AAAA;AAOR,SAAS,UAAU,CAClB,MAC0B;AAAA,EAC1B,MAAM,OAAgC,CAAC;AAAA,EACvC,YAAY,MAAM,UAAU,OAAO,IAAI,GAAG;AAAA,IACzC,MAAM,OACL,iBAAiB,QAAQ,EAAE,iBAAiB,QACzC,IAAI,KAAK,CAAC,KAAK,GAAG,QAAQ,EAAE,MAAM,MAAM,KAAK,CAAC,IAC9C;AAAA,IACJ,MAAM,OAAO,KAAK;AAAA,IAClB,KAAK,QACJ,SAAS,YACN,KAAK,SAAS,IAAI,IACjB,CAAC,IAAI,IACL,OACD,MAAM,QAAQ,IAAI,IACjB,CAAC,GAAG,MAAM,IAAI,IACd,CAAC,MAAM,IAAI;AAAA,EACjB;AAAA,EACA,OAAO;AAAA;;;ACrGR;AAAA,YACC;AAAA,UACA;AAAA;AAAA;AAAA;AAuBD,IAAM,WAAW,CAAC,MAA0B,aAC3C,SAAS,aAAa,KAAK,SAAS,GAAG,IAAI,WAAW;AAGhD,SAAS,SAAS,CACxB,WACA,OACA,SAC8C;AAAA,EAC9C,MAAM,QAAQ,IAAI;AAAA,EAClB,WAAW,SAAS,UAAU,YAAY;AAAA,IACzC,IAAI,MAAM,OAAO,SAAS;AAAA,MACzB,YAAY,OAAO,OAAO,OAAO,QAAQ,MAAM,KAAK;AAAA,IACrD,EAAO,SAAI,MAAM,OAAO,UAAU;AAAA,MACjC,MAAM,QAAQ,OAAO,SAAS,MAAM,KAAK,YAAY;AAAA,MACrD,IAAI,QAAO,KAAK;AAAA,QAAG;AAAA,MACnB,QAAQ,IACP,MAAM,MACN,MAAM,QAAQ,KAAK,IAAI,MAAM,IAAI,KAAI,EAAE,KAAK,GAAG,IAAI,MAAK,KAAK,CAC9D;AAAA,IACD;AAAA,EACD;AAAA,EACA,OAAO,EAAE,OAAO,MAAM,OAAO,WAAW,OAAO,OAAO,EAAE;AAAA;AAGzD,SAAS,WAAW,CACnB,QACA,OACA,OACO;AAAA,EACP,IAAI,QAAO,KAAK;AAAA,IAAG;AAAA,EACnB,IAAI,CAAC,MAAM,QAAQ,KAAK;AAAA,IAAG,OAAO,OAAO,MAAM,MAAM,MAAK,KAAK,CAAC;AAAA,EAC3D,SAAI,MAAM,SAAS;AAAA,IACvB,WAAW,QAAQ;AAAA,MAAO,OAAO,OAAO,MAAM,MAAM,MAAK,IAAI,CAAC;AAAA,EAC/D,EAAO;AAAA,WAAO,OAAO,MAAM,MAAM,MAAM,IAAI,KAAI,EAAE,KAAK,GAAG,CAAC;AAAA;AAG3D,SAAS,MAAM,CACd,WACA,OACA,SACY;AAAA,EACZ,IAAI,UAAU;AAAA,IAAW,OAAO,CAAC;AAAA,EACjC,MAAM,UAAU,OAAO,QAAQ,UAAU,MAAM,WAAW,CAAC,CAAC;AAAA,EAC5D,MAAM,WAAW,CAAC,SACjB,QAAQ,KAAK,IAAI,WAAW,MAAM,SAAS,IAAI,IAAI;AAAA,EACpD,IAAI,MAAM,SAAS,WAAW;AAAA,IAC7B,QAAQ,IAAI,gBAAgB,SAAS,SAAS,MAAM,GAAG,kBAAkB,CAAC;AAAA,IAC1E,OAAO,EAAE,MAAM,MAAM,KAAK;AAAA,EAC3B;AAAA,EACA,IAAI,MAAM,SAAS,WAAW;AAAA,IAC7B,OAAO;AAAA,MACN,MACC,SAAS,MAAM,MAAM,sCAClB,eAAe,MAAM,IAAI,IACzB,WAAW,MAAM,IAAI;AAAA,IAC1B;AAAA,EACD;AAAA,EACA,IAAI,MAAM,SAAS,WAAW;AAAA,IAC7B,QAAQ,IAAI,gBAAgB,SAAS,SAAS,MAAM,GAAG,YAAY,CAAC;AAAA,IACpE,OAAO,EAAE,MAAM,MAAM,KAAK;AAAA,EAC3B;AAAA,EACA,IAAI,MAAM,SAAS,WAAW;AAAA,IAC7B,QAAQ,IACP,gBACA,SAAS,SAAS,QAAQ,GAAG,0BAA0B,CACxD;AAAA,IACA,OAAO,EAAE,MAAM,MAAM,KAAK;AAAA,EAC3B;AAAA,EACA,OAAO,CAAC;AAAA;;;AF1ET,IAAM,cAAc,CAAC,cACpB,OAAO,YACN,OAAO,QAAQ,UAAU,SAAS,EAAE,IAAI,EAAE,QAAQ,aAAa;AAAA,EAC9D;AAAA,EACA,OAAO,KAAK,OAAO,EAAE,WAAW,IAC7B,OACA,OAAO,YACP,OAAO,QAAQ,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW;AAAA,IAC9C;AAAA,IACA,MAAM,UAAU;AAAA,EACjB,CAAC,CACF;AACH,CAAC,CACF;AAGD,SAAS,QAAQ,CAChB,WACkD;AAAA,EAClD,YAAY,QAAQ,YAAY,OAAO,QAAQ,UAAU,SAAS,GAAG;AAAA,IACpE,MAAM,OAAO,OAAO,MAAM;AAAA,IAC1B,IAAI,OAAO,OAAO,OAAO;AAAA,MAAK;AAAA,IAC9B,YAAY,MAAM,UAAU,OAAO,QAAQ,OAAO,GAAG;AAAA,MACpD,IAAI,MAAM,SAAS,SAAS,MAAM,SAAS;AAAA,QAAS,OAAO,CAAC,MAAM,KAAK;AAAA,IACxE;AAAA,EACD;AAAA,EACA;AAAA;AAOD,SAAS,YAAe,CACvB,MACA,OACiB;AAAA,EACjB,IAAI;AAAA,EACJ,IAAI,SAAS;AAAA,EACb,OAAO;AAAA,QACF,WAAW,GAAG;AAAA,MACjB,OAAO,OAAO;AAAA;AAAA,IAEf,KAAK,GAAG;AAAA,MACP,SAAS;AAAA,MACT,OAAO,MAAM;AAAA;AAAA,YAEN,OAAO,cAAc,GAAG;AAAA,MAC/B,IAAI,CAAC,OAAO;AAAA,QACX,MAAM,MAAM;AAAA,QACZ,IAAI;AAAA,UAAQ;AAAA,QACZ,QAAQ,KAAK;AAAA,MACd;AAAA,MACA,OAAO;AAAA;AAAA,EAET;AAAA;AAmCM,SAAS,mBAIf,CACA,MACA,YACA,OACsC;AAAA,EACtC,OAAO,KAAK,MAAM,YAAY,SAAS,CAAC,GAAG,MAAG;AAAA,IAAG;AAAA,GAAS;AAAA;AAI3D,IAAM,SAAS,CACd,OACA,UAEA,UAAU,YAAY,QAAQ,QAAQ,YAAY,IAAI,CAAC,OAAO,KAAK,CAAC,IAAI;AAOzE,SAAS,IAIR,CACA,MACA,YACA,SACA,OACsC;AAAA,EACtC,QAAQ,WAAW,UAAU;AAAA,EAC7B,MAAM,SAAS,QAAQ,WAAW;AAAA,EAClC,MAAM,SAAS;AAAA,IACd,SACC,aAAa,QACZ,OAAO,aAAa,YAAY,SAAS,YAAY;AAAA,IACvD,UACC,UACA,aAAa,QACZ,OAAO,aAAa,YAAY,SAAS,aAAa;AAAA,EACzD;AAAA,EACA,MAAM,QAAQ;AAAA,EAGd,MAAM,UAAU,IAAI;AAAA,EACpB,MAAM,YAAY,IAAI;AAAA,EACtB,YAAY,IAAI,cAAc,OAAO,QAAQ,KAAK,GAAG;AAAA,IACpD,QAAQ,IAAI,GAAG,UAAU,UAAU,UAAU,QAAQ,EAAE;AAAA,IACvD,UAAU,IAAI,IAAI,YAAY,SAAS,CAAC;AAAA,EACzC;AAAA,EAGA,MAAM,OAAO,CAAC,IAAY,SAA6B;AAAA,IACtD,MAAM,YAAY,MAAM;AAAA,IACxB,IAAI,CAAC;AAAA,MAAW,MAAM,IAAI,MAAM,GAAG,sCAAsC;AAAA,IAEzE,MAAM,QACL,UAAU,WAAW,SAAS,KAC9B,OAAO,KAAK,UAAU,MAAM,WAAW,CAAC,CAAC,EAAE,SAAS;AAAA,IACrD,MAAM,QAAS,QAAQ,KAAK,KAAK;AAAA,IACjC,MAAM,SAAU,QAAQ,KAAK,KAAK,KAAK,OAAO,CAAC;AAAA,IAC/C,MAAM,SAAS,OAAO,MAAM,QAAQ,MAAM,CAAC;AAAA,IAC3C,MAAM,OAAO,SAAS,KAAK,OAAO,OAAO,IAAI;AAAA,IAC7C,OAAO,EAAE,WAAW,OAAO,KAAK;AAAA;AAAA,EAIjC,MAAM,QAAQ,OACb,IACA,WACA,UACmB;AAAA,IACnB,IAAI,CAAC,OAAO;AAAA,MAAS;AAAA,IACrB,MAAM,SAAS,MAAM,aAAa,WAAW,KAAK;AAAA,IAClD,IAAI,OAAO,WAAW;AAAA,MAAG;AAAA,IACzB,MAAM,UAAU;AAAA,MACf,aAAa;AAAA,MACb,QAAQ,UAAU;AAAA,MAClB,MAAM,UAAU;AAAA,IACjB;AAAA,IACA,MAAM,IAAI,gBAAgB,SAAS;AAAA,MAClC,MAAM;AAAA,SACH;AAAA,MACH;AAAA,IACD,CAAC;AAAA;AAAA,EAIF,MAAM,UAAU,CACf,IACA,WACA,OACA,SACI;AAAA,IACJ,MAAM,UAAU,IAAI,QAAQ,KAAK,OAAO;AAAA,IACxC,QAAQ,OAAO,SAAS,UAAU,WAAW,OAAO,OAAO;AAAA,IAC3D,OAAO;AAAA,SACH;AAAA,SACA;AAAA,MACH,OAAO,OAAO;AAAA,MACd;AAAA,MACA;AAAA,MACA,aAAa;AAAA,IACd;AAAA;AAAA,EAGD,MAAM,OAAO,OACZ,IACA,SACsB;AAAA,IACtB,QAAQ,WAAW,OAAO,SAAS,KAAK,IAAI,IAAI;AAAA,IAChD,MAAM,MAAM,IAAI,WAAW,KAAK;AAAA,IAChC,MAAM,UAAU,KAAK;AAAA,IAKrB,OAAO,QAAQ,UAAU,QAAQ,UAAU,MAAM;AAAA,SAC7C,QAAQ,IAAI,WAAW,OAAO,IAAI;AAAA,MACrC,WAAW,UAAU,IAAI,EAAE;AAAA,MAC3B,UAAU,OAAO;AAAA,MACjB;AAAA,IACD,CAAC;AAAA;AAAA,EAGF,MAAM,SAAS,CAAC,IAAY,SAA6B;AAAA,IACxD,QAAQ,WAAW,OAAO,SAAS,KAAK,IAAI,IAAI;AAAA,IAChD,MAAM,QAAQ,SAAS,SAAS;AAAA,IAChC,IAAI,CAAC;AAAA,MAAO,MAAM,IAAI,MAAM,GAAG,iCAAiC;AAAA,IAChE,OAAO,MAAM,SAAS;AAAA,IACtB,QAAQ,WAAW,aAAa,mBAAmB,SAAS;AAAA,IAC5D,MAAM,OAAO,MAAM;AAAA,MAClB,MAAM,UAAU,QAAQ,IAAI,WAAW,OAAO,IAAI;AAAA,MAElD,IAAI,CAAC,QAAQ,QAAQ,IAAI,QAAQ;AAAA,QAAG,QAAQ,QAAQ,IAAI,UAAU,IAAI;AAAA,MACtE,MAAM,SAAS;AAAA,WACX;AAAA,QACH,QAAQ,UAAU;AAAA,QAClB,UAAU,OAAO;AAAA,QACjB;AAAA,MACD;AAAA,MACA,MAAM,aAAc,MAAM,SAAS,QAAQ,KAAK,SAAS,KAAK;AAAA,MAI9D,OAAO,WACN,UAAU,MACV,MAAM,SAAS,QACZ;AAAA,WACG;AAAA,QACH,QAAQ,MAAM;AAAA,QACd;AAAA,QACA;AAAA,QACA;AAAA,MACD,IACC,KAAK,QAAQ,MAAM,MAAM,KAAK,CAClC;AAAA;AAAA,IAED,OAAO,OAAO,UACX,aAAa,MAAM,MAAM,MAAM,IAAI,WAAW,KAAK,CAAC,IACpD,KAAK;AAAA;AAAA,EAGT,MAAM,SAAkC;AAAA,IACvC;AAAA,IACA,IAAI,CAAC,OAAe,SAAoB,KAAK,IAAI,IAAI;AAAA,IACrD,QAAQ,CAAC,OAAe,SAAoB,OAAO,IAAI,IAAI;AAAA,IAC3D,OAAO,MAAM;AAAA,MACZ,MAAM,QAAQ,KAAK,MAAM;AAAA,MACzB,MAAM,QAAQ,KACb,OACA,YACA,SACA,MAAM,MAAM,MACb;AAAA,MACA,OAAO,OAAO,iBAAiB,OAAO;AAAA,QACrC,QAAQ,EAAE,YAAY,MAAM,OAAO,MAAM,OAAO;AAAA,QAChD,QAAQ,EAAE,YAAY,MAAM,KAAK,MAAM,MAAM,OAAO;AAAA,MACrD,CAAC;AAAA;AAAA,EAEH;AAAA,EACA,WAAW,UAAU,SAAS;AAAA,IAC7B,OAAO,UAAU,CAAC,SAAiB,SAAoB;AAAA,MACtD,MAAM,KAAK,QAAQ,IAAI,GAAG,UAAU,MAAM;AAAA,MAC1C,IAAI,OAAO,WAAW;AAAA,QACrB,OAAO,QAAQ,OACd,IAAI,MACH,mBAAmB,OAAO,YAAY,KAAK,gBAC5C,CACD;AAAA,MACD;AAAA,MACA,OAAO,KAAK,IAAI,IAAI;AAAA;AAAA,EAEtB;AAAA,EACA,OAAO;AAAA;",
+  "debugId": "D3AB5DC616E1E63964756E2164756E21",
+  "names": []
+}

package/dist/request/check-request.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A request checked before it is sent, by the validators the server runs, on
+ * what `@nxgt/openapi-hono` will read from it: each parameter as the
+ * text it travels as, the JSON as it parses, a form as its fields. What the
+ * server would refuse is refused here with the same issues, and nothing is
+ * sent.
+ */
+import type { ValidationIssue } from '@nxgt/httpyz';
+import type { RuntimeOperation } from '../client/types';
+import type { Input } from './to-request';
+export declare function checkRequest(operation: RuntimeOperation, input: Input | undefined): Promise<ValidationIssue[]>;
+//# sourceMappingURL=check-request.d.ts.map

package/dist/request/check-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-request.d.ts","sourceRoot":"","sources":["../../src/request/check-request.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAoB,eAAe,EAAE,MAAM,cAAc,CAAC;AAEtE,OAAO,KAAK,EAAgB,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,wBAAsB,YAAY,CACjC,SAAS,EAAE,gBAAgB,EAC3B,KAAK,EAAE,KAAK,GAAG,SAAS,GACtB,OAAO,CAAC,eAAe,EAAE,CAAC,CAgC5B"}

package/dist/request/to-request.d.ts

@@ -0,0 +1,26 @@
+/**
+ * An operation's input as a call of the core client, written the way
+ * `@nxgt/openapi-hono` reads it back: a query list as a repeated key,
+ * or joined with commas when the spec says `explode: false`; a header list
+ * joined with commas; the body as the media type the spec declares for its
+ * kind.
+ */
+import type { BodyInput } from '@nxgt/httpyz';
+import type { RuntimeOperation } from '../client/types';
+/** What an input may hold, as `ClientOperations` types it. */
+export interface Input {
+    readonly param?: Readonly<Record<string, unknown>>;
+    readonly query?: Readonly<Record<string, unknown>>;
+    /** Keyed by lowercased name. */
+    readonly header?: Readonly<Record<string, unknown>>;
+    readonly json?: unknown;
+    readonly form?: Readonly<Record<string, unknown>>;
+    readonly text?: string;
+    readonly body?: Blob | ArrayBuffer | Uint8Array;
+}
+/** The query and the body; the header parameters and the body's type go onto `headers`. */
+export declare function toRequest(operation: RuntimeOperation, input: Input | undefined, headers: Headers): {
+    query: URLSearchParams;
+    body: BodyInput;
+};
+//# sourceMappingURL=to-request.d.ts.map

package/dist/request/to-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-request.d.ts","sourceRoot":"","sources":["../../src/request/to-request.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAO9C,OAAO,KAAK,EAEX,gBAAgB,EAEhB,MAAM,iBAAiB,CAAC;AAEzB,8DAA8D;AAC9D,MAAM,WAAW,KAAK;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,gCAAgC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,WAAW,GAAG,UAAU,CAAC;CAChD;AAMD,2FAA2F;AAC3F,wBAAgB,SAAS,CACxB,SAAS,EAAE,gBAAgB,EAC3B,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,OAAO,EAAE,OAAO,GACd;IAAE,KAAK,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAe7C"}

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@nxgt/openapi-httpyz",
+	"version": "0.1.0",
+	"license": "UNLICENSED",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist",
+		"README.md",
+		"package.json"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/softistx/nxgt-http.git",
+		"directory": "packages/openapi-httpyz"
+	},
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org",
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bun run ../../build.ts",
+		"fixtures": "bun run test/generate.ts",
+		"test": "bun run fixtures && bun test src",
+		"typecheck": "bun run fixtures && tsc --noEmit"
+	},
+	"devDependencies": {
+		"@nxgt/httpyz": "^0.0.0",
+		"@nxgt/openapi-codegen": "^0.1.0",
+		"@nxgt/openapi-hono": "^0.0.0",
+		"@types/bun": "^1.4.0",
+		"hono": "^4.13.4",
+		"zod": "^4.5.4"
+	},
+	"peerDependencies": {
+		"@nxgt/httpyz": "^0.0.0",
+		"typescript": "^6.0.3"
+	}
+}