@codewithagents/api-errors 1.1.0 → 1.2.1

package/README.md

@@ -5,15 +5,19 @@
 [![codecov](https://codecov.io/gh/codewithagents/openapi-zod-ts/graph/badge.svg?flag=api-errors)](https://codecov.io/gh/codewithagents/openapi-zod-ts)
 [![CodeQL](https://github.com/codewithagents/openapi-zod-ts/actions/workflows/codeql.yml/badge.svg)](https://github.com/codewithagents/openapi-zod-ts/actions/workflows/codeql.yml)
 
-📖 **[Full documentation](https://openapi.codewithagents.de/api-errors)**
+**[Full documentation](https://openapi.codewithagents.de/api-errors)**
 
-Backend API errors don't automatically map to form field errors. Every project writes the same boilerplate from scratch: catch the error, inspect its shape, figure out which field each message belongs to, then call your form library's error setter. This package does that for you: a framework-agnostic core with a first-class React Hook Form adapter.
+`@codewithagents/api-errors` maps backend API error responses to form field errors in one call: it auto-detects RFC 9457 Problem Details, Spring Boot, Laravel, Zod, JSON:API, and ten other error shapes, then wires the result to React Hook Form, Formik, or TanStack Form with zero runtime dependencies.
 
-- **Framework-agnostic core**: `extractFieldErrors(error)` returns normalized `{ field, message }` pairs from any error shape. Works with any form library or plain JavaScript.
-- **React Hook Form adapter**: `mapApiErrors(error, setError)` wires directly to RHF's `setError`. One call at the catch site, no mapping loop.
-- **Multiple error formats**: RFC 7807 Problem Details, Spring Boot validation format, flat `{ field, message }` arrays, and more.
-- **Response unwrapping**: detects `error.response.data` (Axios), `{ status, body }` (generated client's `ApiError`), and nested `{ data }` wrappers automatically.
-- **Zero runtime dependencies**: pure TypeScript, nothing added to your bundle.
+It is the runtime helper in the [openapi-zod-ts toolchain](#ecosystem): the four generators emit your types, client, hooks, and mocks, and `api-errors` maps the error responses those servers return back onto your form fields at runtime.
+
+- **Framework-agnostic core.** `extractFieldErrors(error)` returns normalized `{ field, message }` pairs from any supported error shape. `extractErrors(error)` returns the richer `{ fieldErrors, formErrors, format }` result with a separate channel for global (non-field) messages.
+- **Form adapters.** React Hook Form (`mapApiErrors`), Formik (`mapApiErrorsFormik`), TanStack Form v1 (`mapApiErrorsTanstack`), and a plain record (`mapApiErrorsToRecord`). Each is one call at the catch site, no mapping loop. The adapters use structural typing, so no form-library import or peer dependency is required.
+- **Ten built-in parsers.** RFC 7807 / RFC 9457 Problem Details (`errors` map, `violations`, `invalid-params`, top-level `detail`), JSON:API, GraphQL `extensions`, Spring Boot validation, Laravel / DRF field maps, Zod `.flatten()`, and flat object / array shapes. The format is detected automatically. Register your own with the `parsers` option.
+- **Response unwrapping.** Detects `{ status, body }` (`ApiError` from `openapi-zod-ts`), `error.response.data` (Axios), and generic `{ data }` wrappers automatically.
+- **i18n and status filtering.** `resolveMessage` translates every message before it is returned; `statusCodes` restricts parsing to specific HTTP status codes.
+- **Never throws.** All functions return empty results for unrecognized or null input.
+- **Zero runtime dependencies.** Pure TypeScript, full type declarations, nothing third-party added to your bundle.
 
 ## Installation
 
@@ -21,6 +25,19 @@ Backend API errors don't automatically map to form field errors. Every project w
 npm install @codewithagents/api-errors
 ```
 
+## Public API
+
+Six functions cover every use case. The core pair parses any error shape; the adapters wrap it for a specific form library.
+
+| Function | What it does |
+| --- | --- |
+| `extractErrors(error, options?)` | Parses any error shape. Returns `{ fieldErrors, formErrors, format }`. Keeps global errors in a dedicated `formErrors` channel and reports the matched `format`. Recommended for new code. |
+| `extractFieldErrors(error, options?)` | Parses any error shape. Returns normalized `FieldError[]`. Global errors fall back to `fallbackField`. Framework-agnostic. |
+| `mapApiErrors(error, setError, options?)` | React Hook Form adapter. Calls `setError` once per field with `type: 'server'`. |
+| `mapApiErrorsToRecord(error, options?)` | Vanilla adapter. Returns a `Record<field, message>` of each field's first message. |
+| `mapApiErrorsFormik(error, setErrors, options?)` | Formik adapter. Calls `setErrors` with the record from `mapApiErrorsToRecord`. |
+| `mapApiErrorsTanstack(error, form, options?)` | TanStack Form v1 adapter. Calls `form.setFieldMeta` per field to inject server errors. |
+
 ## Usage
 
 ### With React Hook Form
@@ -51,9 +68,7 @@ function SignupForm() {
 }
 ```
 
-### With typed React Hook Form forms
-
-`mapApiErrors` accepts any function matching `(field: string, error: { type: string; message: string }) => void`, which is compatible with RHF's `UseFormSetError<T>`. No casting needed:
+`mapApiErrors` accepts any function matching `(field: string, error: { type: string; message: string }) => void`, which is compatible with RHF's `UseFormSetError<T>`. No casting needed for typed forms:
 
 ```tsx
 type FormValues = { email: string; name: string }
@@ -64,6 +79,40 @@ const { setError } = useForm<FormValues>()
 mapApiErrors(error, setError)
 ```
 
+### With Formik
+
+No Formik import is required. The `setErrors` parameter is typed by shape only.
+
+```tsx
+import { useFormik } from 'formik'
+import { mapApiErrorsFormik } from '@codewithagents/api-errors'
+
+const formik = useFormik({
+  initialValues: { email: '', name: '' },
+  onSubmit: async (values, { setErrors }) => {
+    try {
+      await createUser(values)
+    } catch (error) {
+      mapApiErrorsFormik(error, setErrors)
+    }
+  },
+})
+```
+
+### With TanStack Form v1
+
+No TanStack Form import is required. The `form` parameter is typed by shape only.
+
+```ts
+import { mapApiErrorsTanstack } from '@codewithagents/api-errors'
+
+try {
+  await form.handleSubmit()
+} catch (error) {
+  mapApiErrorsTanstack(error, form)
+}
+```
+
 ### With native `fetch` (no Axios)
 
 Pass the parsed response body directly to `extractFieldErrors`:
@@ -83,7 +132,7 @@ if (!res.ok) {
 
 ### Standalone with `extractFieldErrors`
 
-Use `extractFieldErrors` when you need the normalized error list without a form library:
+Use `extractFieldErrors` when you need the normalized list without a form library:
 
 ```ts
 import { extractFieldErrors } from '@codewithagents/api-errors'
@@ -99,69 +148,167 @@ try {
 }
 ```
 
-### Options
+### Separating global errors with `extractErrors`
+
+`extractFieldErrors` folds non-field messages into `fallbackField`. When you want to render global errors (for example "You do not have permission") in their own banner, use `extractErrors`. It keeps them in a separate `formErrors` channel and reports the matched `format`, so you can distinguish an unrecognized body (`format` is `null`) from a recognized body with no errors.
+
+```ts
+import { extractErrors } from '@codewithagents/api-errors'
+
+try {
+  await createUser(data)
+} catch (error) {
+  const { fieldErrors, formErrors, format } = extractErrors(error)
+
+  if (format === null) {
+    // Unrecognized shape: show a generic banner
+    showBanner('An unexpected error occurred.')
+    return
+  }
+
+  for (const { field, message } of fieldErrors) {
+    setError(field, { type: 'server', message })
+  }
+
+  if (formErrors.length > 0) {
+    setFormBanner(formErrors.join(' '))
+  }
+}
+```
+
+`ExtractResult` is the shape returned by `extractErrors`:
+
+```ts
+interface ExtractResult {
+  fieldErrors: FieldError[]
+  formErrors: string[]
+  format: ErrorFormat | null
+}
+```
+
+## Options
+
+Every function accepts a `MapApiErrorsOptions` object.
 
-Both `extractFieldErrors` and `mapApiErrors` accept an options object:
+| Option | Type | Behaviour |
+| --- | --- | --- |
+| `fallbackField` | `string` | Field name used when no field can be determined. Defaults to `'root'`. |
+| `transformField` | `(field: string) => string` | Applied to every resolved field name, and to `fallbackField`. Maps backend camelCase to nested RHF dot-paths. |
+| `statusCodes` | `number[]` | Restricts parsing to these HTTP status codes. If a detectable status is not in the list, the call returns empty immediately. If no status is detectable, parsing proceeds normally. |
+| `resolveMessage` | `(message: string, field: string \| null) => string` | i18n / message reformat hook. Called for every field and form error before it is returned. `field` is `null` for global errors. |
+| `parsers` | `ReadonlyArray<CustomParser>` | Custom parsers tried before the built-in ones, in order. The first non-null result wins. They receive the already-unwrapped body. |
 
 ```ts
 const fieldErrors = extractFieldErrors(error, {
   // Field name used when no field can be determined (default: 'root')
   fallbackField: 'serverError',
 
-  // Transform field names, e.g. camelCase backend → dot.path for nested RHF fields
+  // Transform field names, e.g. camelCase backend to dot.path for nested RHF fields
   transformField: (f) => f.replace(/([A-Z])/g, '.$1').toLowerCase(),
 })
 
-// Options work on mapApiErrors too
-mapApiErrors(error, setError, { fallbackField: 'root' })
+// Options work on every function
+mapApiErrors(error, setError, { statusCodes: [422] })
+```
+
+> **Note:** `transformField` is also applied to `fallbackField`. If you transform `emailAddress` to `email.address`, the fallback field name is transformed the same way.
+
+### Localizing messages with `resolveMessage`
+
+```ts
+import { extractErrors } from '@codewithagents/api-errors'
+
+extractErrors(error, {
+  resolveMessage: (msg, field) => t(`errors.${msg}`, { defaultValue: msg }),
+})
 ```
 
-> **Note:** `transformField` is also applied to `fallbackField`. If you transform `emailAddress` → `email.address`, the fallback field name is transformed the same way.
+### Custom parsers
 
-## Supported Error Formats
+Register parsers for application-specific shapes. They run before the built-in parsers; return `null` to let the next one try.
 
-See the [full format reference](https://openapi.codewithagents.de/api-errors#supported-error-formats) in the docs for the complete parser-precedence rules and all edge cases.
+```ts
+import { extractErrors } from '@codewithagents/api-errors'
+import type { CustomParser, ParsedErrors } from '@codewithagents/api-errors'
+
+const myParser: CustomParser = (body): ParsedErrors | null => {
+  if (typeof body !== 'object' || body === null || !('myErrors' in body)) return null
+  const fieldErrors = (body as any).myErrors.map((e: any) => ({ field: e.key, message: e.text }))
+  return { fieldErrors, formErrors: [] }
+}
+
+extractErrors(error, { parsers: [myParser] })
+```
 
-**RFC 7807 Problem Details** (Spring Boot 3+, standard):
+## Supported error formats
+
+The format is detected automatically. Custom parsers run first; if the body is an array, the flat-array parser runs; otherwise the built-in object parsers are tried in order until the first match. See the [full format reference](https://openapi.codewithagents.de/api-errors#supported-error-formats) for the complete precedence rules and edge cases.
+
+| Format | Recognized by |
+| --- | --- |
+| RFC 7807 / RFC 9457 Problem Details | `errors` object map of `field -> string \| string[]` (Spring Boot 3+, standard Problem Details) |
+| RFC 9457 `violations` | `violations: [{ field, message }]` array |
+| RFC 9457 `invalid-params` | `"invalid-params": [{ name, reason }]` array |
+| RFC 9457 `detail` | top-level `detail` string (last-resort fallback) |
+| JSON:API | `errors: [{ source: { pointer }, detail }]` array |
+| GraphQL | `errors: [{ message, extensions: { field \| path } }]` array |
+| Spring Boot (pre-3) | `errors: [{ field, defaultMessage }]` array |
+| Laravel / DRF | top-level field map `{ field: string \| string[] }` |
+| Zod `.flatten()` | `{ fieldErrors: { field: string[] }, formErrors: string[] }` |
+| Flat object / array | `{ field, message }` or `[{ field, message }]` |
+
+**RFC 7807 / RFC 9457 Problem Details with an `errors` map:**
 ```json
 {
-  "type": "...",
+  "type": "https://example.com/errors/validation",
   "title": "Validation failed",
   "status": 400,
   "errors": {
     "email": ["must not be blank"],
-    "name": ["too short"]
+    "name": ["too short", "must not contain numbers"]
   }
 }
 ```
 
-**Spring Boot default validation format** (older):
+**RFC 9457 `violations` array:**
+```json
+{
+  "status": 422,
+  "violations": [{ "field": "email", "message": "must not be blank" }]
+}
+```
+
+**Spring Boot default validation format (pre-3):**
 ```json
 {
   "status": 400,
-  "errors": [
-    { "field": "email", "defaultMessage": "must not be blank" }
-  ]
+  "errors": [{ "field": "email", "defaultMessage": "must not be blank" }]
 }
 ```
 
-**Simple flat format** (custom APIs):
+**Zod `.flatten()` output:**
 ```json
-{ "field": "email", "message": "Invalid email" }
+{
+  "fieldErrors": { "email": ["Invalid email"] },
+  "formErrors": ["At least one field must be provided."]
+}
 ```
 
-**Array of flat objects:**
+**Simple flat formats (custom APIs):**
+```json
+{ "field": "email", "message": "Invalid email" }
+```
 ```json
 [{ "field": "email", "message": "Invalid email" }]
 ```
 
-Response wrappers are automatically unwrapped: Axios-style `error.response.data` and generic `{ data: { ... } }` shapes are both handled.
+Response wrappers are unwrapped before parsing: `{ status, body }` (`ApiError` from `openapi-zod-ts`), Axios-style `error.response.data`, and generic `{ data: { ... } }` shapes (only when `data` is a plain object).
 
 ## Known behaviour: multiple errors for the same field
 
 See the [multiple errors per field](https://openapi.codewithagents.de/api-errors#multiple-errors-per-field) section in the docs for a full example including grouping with `Map.groupBy`.
 
-When a backend returns multiple errors for the same field (e.g. in the flat array format), `extractFieldErrors` returns all of them. If you pass them all to React Hook Form's `setError`, the **last call wins**; only the last message is displayed. If you need to show all messages, collect them before calling `setError`:
+When a backend returns multiple errors for the same field, `extractFieldErrors` returns all of them. If you pass them all to React Hook Form's `setError`, the **last call wins**; only the last message is displayed. To show all messages, group them before calling `setError`:
 
 ```ts
 const fieldErrors = extractFieldErrors(error)
@@ -172,10 +319,32 @@ for (const [field, errs] of grouped) {
 }
 ```
 
+`mapApiErrorsToRecord` (and therefore the Formik and TanStack adapters) keeps each field's **first** message instead.
+
+## Ecosystem
+
+`api-errors` is the runtime helper in the [openapi-zod-ts](https://github.com/codewithagents/openapi-zod-ts) toolchain. The four generators turn one OpenAPI 3.1 spec into the types, client, hooks, and mocks your app uses; `api-errors` maps the error envelopes those servers return back onto your form fields.
+
+| Package | Role |
+| --- | --- |
+| [`openapi-zod-ts`](https://www.npmjs.com/package/openapi-zod-ts) | Generator: TypeScript models, native fetch client, and Zod schemas. Emits the `ApiError` class that `api-errors` unwraps automatically. |
+| [`@codewithagents/openapi-server`](https://www.npmjs.com/package/@codewithagents/openapi-server) | Generator: framework-agnostic service interface plus optional `hono \| express \| fastify \| none` router. Emits the RFC 7807 / RFC 9457 envelopes `api-errors` parses. |
+| [`@codewithagents/openapi-react-query`](https://www.npmjs.com/package/@codewithagents/openapi-react-query) | Generator: typed React Query v5 hooks. Call `mapApiErrors` in a `useMutation` `onError` to wire server validation to form fields. |
+| [`@codewithagents/openapi-msw`](https://www.npmjs.com/package/@codewithagents/openapi-msw) | Generator: MSW v2 handlers with seeded Faker mock data, including error responses to exercise this package against. |
+| **`@codewithagents/api-errors`** | Runtime helper (this package): maps server error envelopes to form-field errors. |
+
+See the [petstore-fastify demo](https://github.com/codewithagents/openapi-zod-ts/tree/main/packages/petstore-fastify) for the canonical full-stack example that wires these together, including a cross-field validation error round-tripped from the server onto a form field.
+
 ## TypeScript
 
 This package is written in TypeScript and ships full type declarations. No `@types` package needed.
 
 ```ts
-import type { FieldError, MapApiErrorsOptions } from '@codewithagents/api-errors'
+import type {
+  FieldError,
+  MapApiErrorsOptions,
+  ExtractResult,
+  ErrorFormat,
+  CustomParser,
+} from '@codewithagents/api-errors'
 ```

package/dist/index.d.ts

@@ -1,25 +1,5 @@
-/**
- * Normalized representation of a single field-level error.
- */
-export interface FieldError {
-    field: string;
-    message: string;
-}
-/**
- * The format/shape that was recognized when parsing an error body.
- *
- * - `'rfc7807-map'`    - RFC 7807 / RFC 9457 `errors` map: `{ errors: { field: [...] } }`
- * - `'spring-array'`   - Spring Boot array: `{ errors: [{ field, defaultMessage }] }`
- * - `'violations'`     - RFC 9457 / Spring `violations` array: `{ violations: [{ field, message }] }`
- * - `'invalid-params'` - RFC 9457 `invalid-params` array: `{ "invalid-params": [{ name, reason }] }`
- * - `'json-api'`       - JSON:API errors array: `{ errors: [{ source: { pointer }, detail }] }`
- * - `'laravel-drf'`    - Laravel / DRF top-level field map: `{ field: ["msg1", ...] }`
- * - `'flat-object'`    - Simple flat object: `{ field, message }`
- * - `'flat-array'`     - Array of flat objects: `[{ field, message }]`
- * - `'rfc9457-detail'` - RFC 9457 top-level `detail` string (last-resort fallback)
- * - `'custom'`         - Matched a caller-provided custom parser
- */
-export type ErrorFormat = 'rfc7807-map' | 'spring-array' | 'violations' | 'invalid-params' | 'json-api' | 'laravel-drf' | 'flat-object' | 'flat-array' | 'rfc9457-detail' | 'custom';
+export type { FieldError, ParsedErrors, ErrorFormat, CustomParser } from './parsers/types.js';
+import type { FieldError, ErrorFormat, CustomParser } from './parsers/types.js';
 /**
  * Rich result returned by `extractErrors`.
  */
@@ -43,25 +23,6 @@ export interface ExtractResult {
      */
     format: ErrorFormat | null;
 }
-/**
- * A custom parser that callers can register to handle application-specific
- * error shapes not covered by the built-in parsers.
- *
- * Return `null` to indicate "not recognized" and let the next parser try.
- * Return a `ParsedErrors` object (even if both arrays are empty) to signal
- * that this shape was recognized.
- */
-export interface CustomParser {
-    (body: unknown): ParsedErrors | null;
-}
-/**
- * Raw parse result used internally and returned by custom parsers.
- * Both arrays may be empty if the shape was recognized but contained no errors.
- */
-export interface ParsedErrors {
-    fieldErrors: FieldError[];
-    formErrors: string[];
-}
 /**
  * Options for mapApiErrors and extractFieldErrors.
  */
@@ -174,4 +135,63 @@ export declare function mapApiErrors(error: unknown, setError: (field: string, e
     type: string;
     message: string;
 }) => void, options?: MapApiErrorsOptions): void;
+/**
+ * Vanilla (framework-agnostic) adapter.
+ *
+ * Extracts field errors from an unknown API error response and returns a plain
+ * `Record<string, string>` mapping field names to their first error message.
+ * Useful for any custom form library or imperative error handling.
+ *
+ * Only fieldErrors are included. For form-level (global) errors use `extractErrors`.
+ *
+ * @example
+ * ```ts
+ * const record = mapApiErrorsToRecord(error)
+ * // { email: "must not be blank", name: "required" }
+ * ```
+ */
+export declare function mapApiErrorsToRecord(error: unknown, options?: MapApiErrorsOptions): Record<string, string>;
+/**
+ * Formik adapter.
+ *
+ * Extracts field errors from an unknown API error response and calls Formik's
+ * `setErrors` with a `Record<string, string>` of field -> first error message.
+ *
+ * No Formik import is required. The `setErrors` parameter is typed by its
+ * shape only (structural typing).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await submitForm(values)
+ * } catch (error) {
+ *   mapApiErrorsFormik(error, setErrors)
+ * }
+ * ```
+ */
+export declare function mapApiErrorsFormik(error: unknown, setErrors: (errors: Record<string, string>) => void, options?: MapApiErrorsOptions): void;
+/**
+ * TanStack Form v1 adapter.
+ *
+ * Extracts field errors from an unknown API error response and calls
+ * `form.setFieldMeta` for each field to inject server-side errors into the
+ * form state. The updater function merges errors and errorMap onto the
+ * existing field meta.
+ *
+ * No TanStack Form import is required. The `form` parameter is typed by its
+ * shape only (structural typing), so this adapter works without adding
+ * `@tanstack/form-core` as a dependency.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await form.handleSubmit()
+ * } catch (error) {
+ *   mapApiErrorsTanstack(error, form)
+ * }
+ * ```
+ */
+export declare function mapApiErrorsTanstack(error: unknown, form: {
+    setFieldMeta: (field: string, updater: (meta: any) => any) => void;
+}, options?: MapApiErrorsOptions): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,WAAW,GACnB,aAAa,GACb,cAAc,GACd,YAAY,GACZ,gBAAgB,GAChB,UAAU,GACV,aAAa,GACb,aAAa,GACb,YAAY,GACZ,gBAAgB,GAChB,QAAQ,CAAA;AAEZ;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB;;;;;OAKG;IACH,MAAM,EAAE,WAAW,GAAG,IAAI,CAAA;CAC3B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CAAA;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAC1C;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAA;IAClE;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;CACtC;AA6gBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,aAAa,CA2B1F;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,UAAU,EAAE,CAqB9F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,EAC3E,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI,CAKN"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAC7F,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAM/E;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB;;;;;OAKG;IACH,MAAM,EAAE,WAAW,GAAG,IAAI,CAAA;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAC1C;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAA;IAClE;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;CACtC;AA4BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,aAAa,CA2B1F;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,UAAU,EAAE,CAqB9F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,EAC3E,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI,CAKN;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASxB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,EACnD,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE;IAAE,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,KAAK,IAAI,CAAA;CAAE,EAC5E,OAAO,CAAC,EAAE,mBAAmB,GAC5B,IAAI,CASN"}