@aeye/core 0.3.8 → 0.3.9

package/dist/schema.d.ts

@@ -1,17 +1,326 @@
 import z from 'zod';
 /**
-* Recursively transforms a Zod schema to support strict mode.
-*
-* @param schema - input Zod schema
-* @returns transformed Zod schema
-*/
-export declare function strictify<S extends z.ZodType>(schema: S): S;
+ * Provider family for a `FormatDescriptor`. The three known wire dialects
+ * (`'openai'`, `'anthropic'`, `'google'`) are autocomplete hints; any string
+ * is accepted so users can register custom descriptors via
+ * `registerDescriptor` and reference them by family name in
+ * `ModelInfo.strictFormat`. `'lenient'` is the no-rewrite catch-all and is
+ * not registerable as a custom family.
+ *
+ * Use this type wherever you need to talk about a descriptor family —
+ * registry functions, model declarations, etc.
+ */
+export type DescriptorFamily = 'openai' | 'anthropic' | 'google' | (string & {});
+/**
+ * Format descriptor — describes the JSON Schema dialect of a target.
+ *
+ * Each provider/strict combination is represented by one descriptor. The
+ * descriptor controls both how `strictify` rewrites a Zod schema (preprocesses
+ * for record-as-array, tuple-as-object, etc.) and how `toJSONSchema` emits the
+ * matching JSON Schema. Every `if (strict)` decision in the conversion
+ * pipeline dispatches off a descriptor field, so adding a new dialect is a
+ * matter of declaring a new `FormatDescriptor` and registering it.
+ */
+export interface FormatDescriptor {
+    /** Stable id used as the cache key inside `strictify`. */
+    readonly id: string;
+    /**
+     * Provider family for this descriptor. The three built-in wire dialects
+     * are `'openai'` / `'anthropic'` / `'google'`; `'lenient'` is the
+     * no-rewrite catch-all. Custom descriptors registered via
+     * `registerDescriptor` may use any string here — the family is the
+     * lookup key used by `getDescriptor(family, strict)`.
+     */
+    readonly family: DescriptorFamily | 'lenient';
+    /** True if this descriptor represents the strict variant for its family. */
+    readonly strict: boolean;
+    /** When true, every object field appears in `required[]` (OpenAI strict). */
+    readonly objectAllFieldsRequired: boolean;
+    /** When true, every object emits `additionalProperties: false`. */
+    readonly objectClosedByDefault: boolean;
+    /** How to encode `z.record(K, V)`. */
+    readonly recordEncoding: 'array-of-pairs' | 'open-record';
+    /**
+     * How to encode `z.tuple([...])`.
+     * - `object-numeric-keys`: OpenAI-strict workaround (`{ "0": A, "1": B, ... }`)
+     * - `prefix-items`: standard JSON Schema `prefixItems` (Anthropic / Google)
+     * - `items-union`: collapse to homogeneous `items: { anyOf: [...] }` (last-resort)
+     */
+    readonly tupleEncoding: 'object-numeric-keys' | 'prefix-items' | 'items-union';
+    readonly allowAllOf: boolean;
+    readonly allowAnyOf: boolean;
+    readonly allowOneOf: boolean;
+    /** Whether `{ $ref: '#' }` self-reference is permitted. */
+    readonly allowRootRef: boolean;
+    readonly allowDefsRef: boolean;
+    /** Reserved: emit Google-style `propertyOrdering` hints. */
+    readonly emitPropertyOrdering: boolean;
+    /** Whitelist of `format:` values to emit, or `'all'` to pass through. */
+    readonly supportedStringFormats: ReadonlySet<string> | 'all';
+    readonly allowPattern: boolean;
+    readonly allowMultiplePatterns: boolean;
+    readonly allowMinMaxLength: boolean;
+    readonly allowMinMaxItems: boolean;
+    readonly allowMinimumMaximum: boolean;
+    /** When true, `optional` becomes `T|null` (because every prop must be required). */
+    readonly optionalAsNullable: boolean;
+    /**
+     * How `z.any()` / `z.unknown()` is encoded.
+     * - `recursive-strict`: self-referencing $defs/Any with array-of-pairs records
+     *   (OpenAI strict has no open-object support)
+     * - `recursive-open`: $defs/Any with `additionalProperties: <self>` records
+     * - `flat`: a non-recursive `anyOf` over the JSON value types
+     *   (`string`/`number`/`boolean`/`null`/`array`/open-`object`). Used by
+     *   descriptors that reject recursive `$defs/Any` definitions (Anthropic
+     *   strict). Equivalent to TypeScript `any` — accepts every JSON value
+     *   without imposing any structural constraints.
+     */
+    readonly anyEncoding: 'recursive-strict' | 'recursive-open' | 'flat';
+    /** Maximum number of tools that can carry `strict: true` in one request. */
+    readonly maxStrictTools?: number;
+    /** Maximum total optional parameters across all strict schemas in one request. */
+    readonly maxStrictOptionalParams?: number;
+    /** Maximum total union-type parameters across all strict schemas in one request. */
+    readonly maxStrictUnionTypes?: number;
+    /**
+     * Whether the descriptor can express recursive `$ref` schemas (`$ref: '#'`
+     * to root, or any `$ref: '#/$defs/X'` whose target transitively references
+     * itself). OpenAI / Google strict / Lenient: true. Anthropic strict: false
+     * — Anthropic's tool `input_schema` validator explicitly rejects circular
+     * `$defs` graphs.
+     *
+     * When `false`, the JSON-Schema emitter detects cycles in the source
+     * schema and replaces the offending back-edge with the descriptor's flat
+     * "any" shape (see `anyEncoding`) carrying a description that names the
+     * `$defs` entry it would otherwise have referenced. Non-cyclic shared
+     * `$ref` reuse is unaffected — those still emit as a `$ref` to a `$defs`
+     * entry.
+     */
+    readonly supportsRecursion: boolean;
+    /**
+     * Instruction appended after the schema text when a Prompt's/Tool's schema
+     * can't be expressed as this descriptor's structured output and is instead
+     * delivered to the model as PROMPT TEXT (see `canExpress` and the ai-layer
+     * `applySchemaDeliveryFallback`). Steers the model to emit a single raw JSON
+     * object rather than echoing the schema or wrapping it in prose/fences.
+     *
+     * Optional — descriptors that omit it fall back to
+     * `DEFAULT_JSON_FALLBACK_INSTRUCTION` via `getJsonFallbackInstruction`.
+     */
+    readonly jsonFallbackInstruction?: string;
+}
+/**
+ * Default instruction used when a `FormatDescriptor` omits
+ * `jsonFallbackInstruction`. Appended after the schema text when a schema is
+ * delivered as prompt text instead of as structured output.
+ */
+export declare const DEFAULT_JSON_FALLBACK_INSTRUCTION = "Return ONLY a single raw JSON object conforming to the schema above \u2014 no markdown code fences, no prose, and do NOT echo the schema itself.";
+/**
+ * Resolve the prompt-text fallback instruction for a descriptor, falling back
+ * to `DEFAULT_JSON_FALLBACK_INSTRUCTION` when the descriptor doesn't declare
+ * one of its own.
+ */
+export declare function getJsonFallbackInstruction(descriptor: FormatDescriptor): string;
+/** Lenient descriptor — no rewrites, no closure, formats pass through. Default for unsupported models. */
+export declare const LENIENT: FormatDescriptor;
+/**
+ * OpenAI strict — current behavior verbatim. Records→pairs,
+ * tuples→numeric-keys, optional→nullable.
+ *
+ * No documented per-request slot limit (max strict tools / optional params /
+ * union types). The SchemaBudget treats those caps as `undefined` (no limit)
+ * for OpenAI; OpenAI's own ~5000-property and ~5-level-depth schema caps
+ * aren't enforced here either — they're rare in practice and produce a
+ * server-side rejection that the user can react to.
+ */
+export declare const OPENAI_STRICT: FormatDescriptor;
+/** OpenAI non-strict — alias of LENIENT but tagged with the openai family. */
+export declare const OPENAI_NON_STRICT: FormatDescriptor;
+/**
+ * Anthropic strict — Claude 4.5+ only (Opus 4.7/4.6/4.5, Sonnet 4.6/4.5,
+ * Haiku 4.5). Per Anthropic's structured-outputs docs:
+ *
+ * - `additionalProperties` may **only** be `false` (no schema-valued open
+ *   records), so `z.record(...)` falls back to the OpenAI-style
+ *   array-of-pairs workaround.
+ * - Non-cyclic `$ref` / `$defs` reuse is supported and used freely — only
+ *   *circular* `$defs` graphs are rejected by the API
+ *   (`Circular reference detected in schema definitions: …`). The emitter
+ *   sets `supportsRecursion: false` so the cycle-breaker replaces the
+ *   offending back-edge with the flat "any" shape (see `anyEncoding`) and
+ *   leaves shared non-cyclic `$ref`s alone. Root self-reference (`$ref: '#'`)
+ *   is always cyclic by definition, so `allowRootRef` stays `false`.
+ * - Numerical (`minimum`/`maximum`/`multipleOf`) and string-length
+ *   (`minLength`/`maxLength`) constraints are not supported and are dropped.
+ * - `prefixItems` and other positional tuple keywords are not in the
+ *   supported list, so tuples collapse to a homogeneous `items: anyOf`.
+ * - Supported formats include `uri` (unlike OpenAI strict). We pass all
+ *   formats through and let Anthropic ignore unknowns.
+ */
+export declare const ANTHROPIC_STRICT: FormatDescriptor;
+export declare const ANTHROPIC_NON_STRICT: FormatDescriptor;
+/**
+ * Google Gemini strict — per `ai.google.dev/gemini-api/docs/structured-output`:
+ *
+ * - Supported keywords: types, `properties`, `required`, `additionalProperties`,
+ *   `enum`, `format` (date-time/date/time only), `minimum`, `maximum`, `items`,
+ *   `prefixItems`, `minItems`, `maxItems`, `title`, `description`,
+ *   `propertyOrdering`. Recursion via `$ref: "#"` (root self-ref).
+ * - Combinators (`allOf`, `anyOf`, `oneOf`) are NOT in the supported list;
+ *   we conservatively flag them off so unions degrade to a representable form
+ *   rather than emit something Gemini ignores.
+ * - String constraints (`minLength`, `maxLength`, `pattern` formats beyond the
+ *   three documented) are not supported.
+ * - `propertyOrdering` is REQUIRED for Gemini 2.0 strict; we always emit it
+ *   on object schemas under this descriptor.
+ */
+export declare const GOOGLE_STRICT: FormatDescriptor;
+export declare const GOOGLE_NON_STRICT: FormatDescriptor;
+/**
+ * Register a custom `FormatDescriptor` so it can be looked up by `id` or
+ * by `(family, strict)`. Useful for adding support for a new provider
+ * dialect or for registering a tweaked variant of an existing family.
+ *
+ * The descriptor's `id` and `family` become the lookup keys. If a
+ * descriptor with the same id is already registered, the new one
+ * replaces it. The family slot tracks one strict and one lenient
+ * variant; registering a third variant overwrites the matching slot.
+ *
+ * Built-in descriptors (`OPENAI_STRICT`, `LENIENT`, etc.) are seeded at
+ * module load — you don't need to register them manually. They CAN be
+ * overridden by registering a same-id descriptor afterwards, but doing
+ * so is generally a sign that you should pick a different id.
+ *
+ * @example
+ * ```ts
+ * import { registerDescriptor, OPENAI_STRICT } from '@aeye/core';
+ *
+ * // A tighter OpenAI-flavored descriptor: same wire shape but with
+ * // pattern support disabled (some downstream tools choke on regex).
+ * registerDescriptor({
+ *   ...OPENAI_STRICT,
+ *   id: 'openai-no-regex',
+ *   family: 'openai-no-regex',
+ *   allowPattern: false,
+ *   allowMultiplePatterns: false,
+ * });
+ *
+ * // Now resolvable:
+ * getDescriptor('openai-no-regex', true);   // → the registered descriptor
+ * getDescriptorById('openai-no-regex');     // → same
+ * ```
+ */
+export declare function registerDescriptor(descriptor: FormatDescriptor): void;
+/**
+ * Resolve a descriptor by family + strictness.
+ *
+ * Built-in families (`'openai'`, `'anthropic'`, `'google'`) always
+ * resolve. Custom families registered via `registerDescriptor` resolve
+ * once they're registered. Unknown families fall back to `LENIENT`
+ * (safe default — strict mode silently degrades for unrecognized models).
+ *
+ * @param family - provider family (built-in or registered)
+ * @param strict - whether the strict variant is wanted
+ */
+export declare function getDescriptor(family: DescriptorFamily, strict: boolean): FormatDescriptor;
+/**
+ * Look up a descriptor by id. Returns LENIENT for unknown ids (safe default).
+ * Custom descriptors registered via `registerDescriptor` are reachable here
+ * by their `id`.
+ */
+export declare function getDescriptorById(id: string | undefined): FormatDescriptor;
+/**
+ * True if `family` has at least one registered descriptor (strict or
+ * lenient). Used by `@aeye/ai`'s `resolveStrictFormat` fallback chain to
+ * decide whether a model id prefix or provider name is a recognized
+ * dialect.
+ */
+export declare function hasDescriptorFamily(family: string | undefined): boolean;
+/**
+ * Resolve descriptor from various input shapes (boolean, options object, or descriptor).
+ * Used by `toJSONSchema` to support its overloaded signature.
+ */
+export declare function resolveDescriptor(input: FormatDescriptor | ToJSONSchemaOptions | boolean | undefined): FormatDescriptor;
+/**
+ * Decide whether `schema` can be expressed as structured output under
+ * `descriptor`'s JSON-Schema dialect. Returns `false` when the schema uses a
+ * construct the descriptor forbids, so the caller can DROP the wire schema and
+ * deliver it as prompt text instead (see the ai-layer
+ * `applySchemaDeliveryFallback`).
+ *
+ * Walks the Zod schema in the same style as `strictify`/`convert`, honoring:
+ * - **unions** (`z.union` / `z.discriminatedUnion` → `anyOf`) when
+ *   `!descriptor.allowAnyOf` (e.g. Gemini strict rejects `anyOf`);
+ * - **intersections** (`z.intersection` → `allOf`) when `!descriptor.allowAllOf`;
+ * - **recursion** (a self-referential `z.lazy` cycle → `$ref`): a cycle back to
+ *   the ROOT is fine when `descriptor.allowRootRef && descriptor.supportsRecursion`
+ *   (Gemini supports `$ref: '#'`); a non-root cycle needs
+ *   `descriptor.allowDefsRef && descriptor.supportsRecursion`.
+ *
+ * `ZodNullable` / `ZodOptional` are transparent wrappers here (nullability is
+ * NOT treated as a union), so only genuine `z.union(...)` trips `allowAnyOf`.
+ * Non-combinator, non-recursive schemas (plain objects, arrays, primitives)
+ * are always expressible. The structure mirrors the descriptor flags so more
+ * feasibility checks are easy to add.
+ */
+export declare function canExpress(schema: z.ZodType, descriptor: FormatDescriptor): boolean;
+/**
+ * Recursively transforms a Zod schema to a target dialect.
+ *
+ * For LENIENT, returns the input schema unchanged (no rewrites). For strict
+ * descriptors, installs preprocesses that accept the dialect's wire shape
+ * (e.g. array-of-pairs records, numeric-key tuple objects) and normalize them
+ * back to the natural Zod shape before validation.
+ *
+ * Repeated calls with the same `(schema, descriptor)` return the cached
+ * transformed schema. Different descriptors share the same outer entry but
+ * map to different inner values — bounded by the small descriptor count.
+ *
+ * @param schema - input Zod schema
+ * @param descriptor - target dialect descriptor (defaults to OPENAI_STRICT)
+ */
+export declare function strictify<S extends z.ZodType>(schema: S, descriptor?: FormatDescriptor): S;
+/**
+ * Produce a NON-FAILING variant of `schema` that keeps every transform
+ * (`preprocess`, `codec`, `pipe`, `transform`) but drops validation. Parsing
+ * a wire value through the result runs the decode preprocesses installed by
+ * `strictify` (array-of-pairs → record, numeric-key object → tuple, null →
+ * undefined) and yields the conceptual value, without ever rejecting.
+ *
+ * Recursion (`z.lazy` self-reference) is handled with a per-call memo map: an
+ * in-flight node is recorded as a thunk and re-encounters resolve to
+ * `z.lazy(thunk)`, so a self-referential schema relaxes in finite time and
+ * never infinite-loops.
+ */
+export declare function relaxValidation(schema: z.ZodType): z.ZodType;
+/**
+ * DECODE a model's wire `value` back to the conceptual shape a custom parser
+ * expects — symmetric with how `strictify` ENCODEs the request for the wire.
+ *
+ * Runs the descriptor's decode transforms (via `relaxValidation(strictify(...))`)
+ * without imposing validation, so array-of-pairs records, numeric-key tuples,
+ * and null-for-optional fields are normalized before a provider-agnostic
+ * custom parser sees them. Best-effort: NEVER throws — if the relaxed decoder
+ * can't parse the value it is returned unchanged.
+ *
+ * @param schema - the PRE-strictify conceptual schema (strictify runs internally)
+ * @param value - the model's raw wire value (already `JSON.parse`d)
+ * @param descriptor - the wire dialect the request was encoded with
+ */
+export declare function decodeWire(schema: z.ZodType, value: unknown, descriptor: FormatDescriptor): unknown;
 /**
  * Format specification for JSON Schema generation
  */
-export type JSONSchemaFormat = 'openai';
 /**
- * Options for toJSONSchemaV2
+ * Family name for `ToJSONSchemaOptions.format`. Alias of `DescriptorFamily`
+ * — the three built-in dialects (`'openai'`, `'anthropic'`, `'google'`)
+ * plus any string registered via `registerDescriptor`.
+ *
+ * @deprecated Prefer `DescriptorFamily`. Both refer to the same widened type.
+ */
+export type JSONSchemaFormat = DescriptorFamily;
+/**
+ * Options for toJSONSchema
  */
 export interface ToJSONSchemaOptions {
     /**
@@ -19,10 +328,11 @@ export interface ToJSONSchemaOptions {
      */
     strict: boolean;
     /**
-     * The target format for the JSON Schema. Currently only 'openai' is supported.
-     * Different formats may have different constraints and supported features.
+     * The target format for the JSON Schema. Resolves to a named FormatDescriptor.
+     * Built-in (`'openai'` / `'anthropic'` / `'google'`) or any string
+     * registered via `registerDescriptor`.
      */
-    format?: JSONSchemaFormat;
+    format?: DescriptorFamily;
 }
 export type JSONSchemaType = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'null' | 'integer';
 /**
@@ -56,17 +366,19 @@ export interface JSONSchema {
     const?: any;
     title?: string;
     $defs?: Record<string, JSONSchema>;
+    /** Gemini-specific: deterministic property emission order for strict mode. */
+    propertyOrdering?: string[];
     [metadata: string]: unknown;
 }
 /**
- * Converts a Zod schema to JSON Schema V2 with support for different provider formats.
+ * Converts a Zod schema to JSON Schema with support for different provider dialects.
  *
- * This is a custom implementation that recursively inspects Zod schemas and converts them
- * to JSON Schema following the pattern of strictify/strictifySimple.
+ * Accepts either a boolean (legacy: true = OPENAI_STRICT, false = LENIENT),
+ * an options object `{ strict, format? }`, or a `FormatDescriptor` directly.
  *
  * @param schema - The Zod schema to convert
  * @param options - Configuration options for the conversion
- * @returns JSON Schema object compatible with the specified format
+ * @returns JSON Schema object compatible with the resolved dialect
  *
  * @example
  * ```typescript
@@ -76,9 +388,111 @@ export interface JSONSchema {
  * });
  *
  * // For OpenAI strict mode
- * const strictSchema = strictify(schema);
- * const jsonSchema = toJSONSchemaV2(strictSchema, { strict: true, format: 'openai' });
+ * const jsonSchema = toJSONSchema(schema, { strict: true, format: 'openai' });
+ *
+ * // For Anthropic strict mode
+ * const anthropic = toJSONSchema(schema, ANTHROPIC_STRICT);
  * ```
  */
-export declare function toJSONSchema(schema: z.ZodType, options: ToJSONSchemaOptions | boolean): JSONSchema;
+export declare function toJSONSchema(schema: z.ZodType, options: ToJSONSchemaOptions | boolean | FormatDescriptor): JSONSchema;
+/**
+ * Structural feature counts for a Zod schema, used by the SchemaBudget to
+ * decide whether an item fits a descriptor's per-request budget and whether
+ * the descriptor can express it at all.
+ */
+export interface SchemaFeatures {
+    /** True if the schema (or any subschema) uses `z.lazy` / self-recursion. */
+    hasRecursion: boolean;
+    /** Count of `z.optional()` leaves anywhere in the schema. */
+    optionalParameterCount: number;
+    /**
+     * Count of union-shaped nodes — `z.union`, `z.discriminatedUnion`, plus
+     * `z.nullable` (which on the wire under OpenAI strict becomes a type
+     * array `[T, "null"]`, also counts toward Anthropic's union-type budget).
+     */
+    unionTypeCount: number;
+    /** Count of `z.record` nodes. */
+    recordCount: number;
+    /** Count of `z.tuple` nodes. */
+    tupleCount: number;
+}
+/**
+ * Walk a Zod schema once and count its structural features. Result is
+ * cached per schema in a WeakMap — second-and-subsequent calls are O(1) and
+ * the entry is GC'd with the schema (same OOM-safe pattern as `strictify`).
+ */
+export declare function analyzeSchema(schema: z.ZodType | z.core.$ZodType): SchemaFeatures;
+/**
+ * Per-request strict-mode allocator.
+ *
+ * Constructed once per outgoing request with the chosen model's strictest
+ * descriptor. Tracks remaining slots (strict tools, optional parameters,
+ * union types) against the descriptor's documented per-request limits and
+ * decides per-tool / per-output whether to emit strict or fall back to
+ * LENIENT.
+ *
+ * Selection guarantees that any tool with `strict: true` (hard requirement)
+ * has a model that supports the family — `allocate` therefore always grants
+ * strict for `requested === true` (subject only to feasibility, not budget;
+ * if `true` items overflow the budget the API call will fail, which is the
+ * correct behavior for hard requirements).
+ *
+ * Numeric `strict: <priority>` items are allocated greedily after `true`
+ * items have consumed their share of the budget. Caller is expected to
+ * pre-sort by descending priority before iterating.
+ */
+export declare class SchemaBudget {
+    private readonly descriptor;
+    private remainingTools;
+    private remainingOptionalParams;
+    private remainingUnionTypes;
+    constructor(descriptor: FormatDescriptor);
+    /**
+     * Decide the effective descriptor for a tool's parameter schema given the
+     * dev's strict request, the schema's features, and the remaining budget.
+     *
+     * Returns `LENIENT` when:
+     * - `requested === false`
+     * - the schema uses a feature the descriptor can't represent
+     * - the descriptor has slot limits and the budget is exhausted (only
+     *   applies to `requested` being a positive number; `true` always wins
+     *   subject to feasibility)
+     *
+     * Returns the strict descriptor (and decrements the budget) otherwise.
+     */
+    allocateTool(schema: z.ZodType | z.core.$ZodType, requested: boolean | number | undefined): FormatDescriptor;
+    /**
+     * Same as `allocateTool` but for the request's structured-output schema.
+     * The output schema doesn't consume a tool slot but it does count toward
+     * the optional-parameter and union-type budgets — descriptors document
+     * those limits as "across all strict schemas in one request".
+     */
+    allocateOutput(schema: z.ZodType | z.core.$ZodType, requested: boolean | number | undefined): FormatDescriptor;
+    /** Snapshot of remaining budget. Useful for telemetry / debug logs. */
+    remaining(): {
+        strictTools: number;
+        optionalParams: number;
+        unionTypes: number;
+    };
+    private allocate;
+}
+/**
+ * Compare two descriptors and return the one with the tighter per-request
+ * budget. Used by providers to pick a single descriptor for a SchemaBudget
+ * shared between `convertTools` and `convertResponseFormat` — Anthropic's
+ * documented limits apply across the whole request, so the strictest
+ * descriptor wins.
+ */
+export declare function strictestOf(a: FormatDescriptor, b: FormatDescriptor): FormatDescriptor;
+/**
+ * Convert a `boolean | number | undefined` strict request into a numeric
+ * priority for sorting. Used by providers to allocate strict slots in
+ * descending priority order.
+ *
+ * - `true` → `+Infinity` (hard requirement; always first in line)
+ * - `false` → `-Infinity` (always lenient; never wants strict)
+ * - `number > 0` → the number itself
+ * - `number <= 0` or `undefined` → `0` (no preference)
+ */
+export declare function strictPriority(requested: boolean | number | undefined): number;
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB;;;;;EAKE;AACF,wBAAgB,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAoB3D;AAmND;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAEvG;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,cAAc,GAAG,cAAc,EAAE,CAAC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IAC5C,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IACvC,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B;AAeD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,CAAC,CAAC,OAAO,EACjB,OAAO,EAAE,mBAAmB,GAAG,OAAO,GACrC,UAAU,CA2BZ"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}