Update app and tooling

2026-01-29 17:36:26 -08:00 · 2026-01-29 17:36:26 -08:00 · e620ec7349
commit e620ec7349
parent 3046531bdd
4950 changed files with 2975120 additions and 10 deletions
--- a/node_modules/json-schema-to-ts/LICENSE
+++ b/node_modules/json-schema-to-ts/LICENSE
@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Thomas Aribart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/node_modules/json-schema-to-ts/README.md
+++ b/node_modules/json-schema-to-ts/README.md
@ -0,0 +1,589 @@
+<img src="assets/header-round-medium.png" width="100%" align="center" />
+
+<p align="right">
+  <i>If you use this repo, star it ✨</i>
+</p>
+
+# Stop typing twice 🙅‍♂️
+
+A lot of projects use JSON schemas for runtime data validation along with TypeScript for static type checking.
+
+Their code may look like this:
+
+```typescript
+const dogSchema = {
+  type: "object",
+  properties: {
+    name: { type: "string" },
+    age: { type: "integer" },
+    hobbies: { type: "array", items: { type: "string" } },
+    favoriteFood: { enum: ["pizza", "taco", "fries"] },
+  },
+  required: ["name", "age"],
+};
+
+type Dog = {
+  name: string;
+  age: number;
+  hobbies?: string[];
+  favoriteFood?: "pizza" | "taco" | "fries";
+};
+```
+
+Both objects carry similar if not exactly the same information. This is a code duplication that can annoy developers and introduce bugs if not properly maintained.
+
+That's when `json-schema-to-ts` comes to the rescue 💪
+
+## FromSchema
+
+The `FromSchema` method lets you infer TS types directly from JSON schemas:
+
+```typescript
+import { FromSchema } from "json-schema-to-ts";
+
+const dogSchema = {
+  type: "object",
+  properties: {
+    name: { type: "string" },
+    age: { type: "integer" },
+    hobbies: { type: "array", items: { type: "string" } },
+    favoriteFood: { enum: ["pizza", "taco", "fries"] },
+  },
+  required: ["name", "age"],
+} as const;
+
+type Dog = FromSchema<typeof dogSchema>;
+// => Will infer the same type as above
+```
+
+Schemas can even be nested, as long as you don't forget the `as const` statement:
+
+```typescript
+const catSchema = { ... } as const;
+
+const petSchema = {
+  anyOf: [dogSchema, catSchema],
+} as const;
+
+type Pet = FromSchema<typeof petSchema>;
+// => Will work 🙌
+```
+
+> The `as const` statement is used so that TypeScript takes the schema definition to the word (e.g. _true_ is interpreted as the _true_ constant and not widened as _boolean_). It is pure TypeScript and has zero impact on the compiled code.
+
+## Why use `json-schema-to-ts`?
+
+If you're looking for runtime validation with added types, libraries like [yup](https://github.com/jquense/yup), [zod](https://github.com/vriad/zod) or [runtypes](https://github.com/pelotom/runtypes) may suit your needs while being easier to use!
+
+On the other hand, JSON schemas have the benefit of being widely used, more versatile and reusable (swaggers, APIaaS...).
+
+If you prefer to stick to them and can define your schemas in TS instead of JSON (importing JSONs `as const` is not available yet), then `json-schema-to-ts` is made for you:
+
+- ✅ **Schema validation** `FromSchema` raises TS errors on invalid schemas, based on [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/json-schema)'s definitions
+- ✨ **No impact on compiled code**: `json-schema-to-ts` only operates in type space. And after all, what's lighter than a dev-dependency?
+- 🍸 **DRYness**: Less code means less embarrassing typos
+- 🤝 **Consistency**: See that `string` that you used instead of an `enum`? Or this `additionalProperties` you confused with `additionalItems`? Or forgot entirely? Well, `json-schema-to-ts` does!
+- 🔧 **Reliability**: `FromSchema` is extensively tested against [AJV](https://github.com/ajv-validator/ajv), and covers all the use cases that can be handled by TS for now\*
+- 🏋️‍♂️ **Help on complex schemas**: Get complex schemas right first time with instantaneous typing feedbacks! For instance, it's not obvious the following schema can never be validated:
+
+```typescript
+const addressSchema = {
+  type: "object",
+  allOf: [
+    {
+      properties: {
+        street: { type: "string" },
+        city: { type: "string" },
+        state: { type: "string" },
+      },
+      required: ["street", "city", "state"],
+    },
+    {
+      properties: {
+        type: { enum: ["residential", "business"] },
+      },
+    },
+  ],
+  additionalProperties: false,
+} as const;
+```
+
+But it is with `FromSchema`!
+
+```typescript
+type Address = FromSchema<typeof addressSchema>;
+// => never 🙌
+```
+
+> \*If `json-schema-to-ts` misses one of your use case, feel free to [open an issue](https://github.com/ThomasAribart/json-schema-to-ts/issues) 🤗
+
+## Table of content
+
+- [Installation](#installation)
+- [Use cases](#use-cases)
+  - [Const](#const)
+  - [Enums](#enums)
+  - [Primitive types](#primitive-types)
+  - [Arrays](#arrays)
+  - [Tuples](#tuples)
+  - [Objects](#objects)
+- [Combining schemas](#combining-schemas)
+  - [AnyOf](#anyof)
+  - [AllOf](#allof)
+  - [OneOf](#oneof)
+  - [Not](#not)
+  - [If/Then/Else](#ifthenelse)
+- [Definitions](#definitions)
+
+## Installation
+
+```bash
+# npm
+npm install --save-dev json-schema-to-ts
+
+# yarn
+yarn add --dev json-schema-to-ts
+```
+
+> `json-schema-to-ts` requires TypeScript 3.3+. Activating `strictNullChecks` or using `strict` mode is recommended.
+
+## Use cases
+
+### Const
+
+```typescript
+const fooSchema = {
+  const: "foo",
+} as const;
+
+type Foo = FromSchema<typeof fooSchema>;
+// => "foo"
+```
+
+### Enums
+
+```typescript
+const enumSchema = {
+  enum: [true, 42, { foo: "bar" }],
+} as const;
+
+type Enum = FromSchema<typeof enumSchema>;
+// => true | 42 | { foo: "bar"}
+```
+
+You can also go full circle with typescript `enums`.
+
+```typescript
+enum Food {
+  Pizza = "pizza",
+  Taco = "taco",
+  Fries = "fries",
+}
+
+const enumSchema = {
+  enum: Object.values(Food),
+} as const;
+
+type Enum = FromSchema<typeof enumSchema>;
+// => Food
+```
+
+### Primitive types
+
+```typescript
+const primitiveTypeSchema = {
+  type: "null", // "boolean", "string", "integer", "number"
+} as const;
+
+type PrimitiveType = FromSchema<typeof primitiveTypeSchema>;
+// => null, boolean, string or number
+```
+
+```typescript
+const primitiveTypesSchema = {
+  type: ["null", "string"],
+} as const;
+
+type PrimitiveTypes = FromSchema<typeof primitiveTypesSchema>;
+// => null | string
+```
+
+> For more complex types, refinment keywords like `required` or `additionalItems` will apply 🙌
+
+### Arrays
+
+```typescript
+const arraySchema = {
+  type: "array",
+  items: { type: "string" },
+} as const;
+
+type Array = FromSchema<typeof arraySchema>;
+// => string[]
+```
+
+### Tuples
+
+```typescript
+const tupleSchema = {
+  type: "array",
+  items: [{ type: "boolean" }, { type: "string" }],
+} as const;
+
+type Tuple = FromSchema<typeof tupleSchema>;
+// => [] | [boolean] | [boolean, string] | [boolean, string, ...unknown[]]
+```
+
+`FromSchema` supports the `additionalItems` keyword:
+
+```typescript
+const tupleSchema = {
+  type: "array",
+  items: [{ type: "boolean" }, { type: "string" }],
+  additionalItems: false,
+} as const;
+
+type Tuple = FromSchema<typeof tupleSchema>;
+// => [] | [boolean] | [boolean, string]
+```
+
+```typescript
+const tupleSchema = {
+  type: "array",
+  items: [{ type: "boolean" }, { type: "string" }],
+  additionalItems: { type: "number" },
+} as const;
+
+type Tuple = FromSchema<typeof tupleSchema>;
+// => [] | [boolean] | [boolean, string] | [boolean, string, ...number[]]
+```
+
+...as well as the `minItems` and `maxItems` keywords:
+
+```typescript
+const tupleSchema = {
+  type: "array",
+  items: [{ type: "boolean" }, { type: "string" }],
+  minItems: 1,
+  maxItems: 2,
+} as const;
+
+type Tuple = FromSchema<typeof tupleSchema>;
+// => [boolean] | [boolean, string]
+```
+
+> Additional items will only work if Typescript's `strictNullChecks` option is activated
+
+### Objects
+
+```typescript
+const objectSchema = {
+  type: "object",
+  properties: {
+    foo: { type: "string" },
+    bar: { type: "number" },
+  },
+  required: ["foo"],
+} as const;
+
+type Object = FromSchema<typeof objectSchema>;
+// => { [x: string]: unknown; foo: string; bar?: number; }
+```
+
+`FromSchema` partially supports the `additionalProperties` and `patternProperties` keywords:
+
+- `additionalProperties` can be used to deny additional properties.
+
+```typescript
+const closedObjectSchema = {
+  ...objectSchema,
+  additionalProperties: false,
+} as const;
+
+type Object = FromSchema<typeof closedObjectSchema>;
+// => { foo: string; bar?: number; }
+```
+
+- Used on their own, `additionalProperties` and/or `patternProperties` can be used to type unnamed properties.
+
+```typescript
+const openObjectSchema = {
+  type: "object",
+  additionalProperties: {
+    type: "boolean",
+  },
+  patternProperties: {
+    "^S": { type: "string" },
+    "^I": { type: "integer" },
+  },
+} as const;
+
+type Object = FromSchema<typeof openObjectSchema>;
+// => { [x: string]: string | number | boolean }
+```
+
+- However, when used in combination with the `properties` keyword, extra properties will always be typed as `unknown` to avoid conflicts.
+
+## Combining schemas
+
+### AnyOf
+
+```typescript
+const anyOfSchema = {
+  anyOf: [
+    { type: "string" },
+    {
+      type: "array",
+      items: { type: "string" },
+    },
+  ],
+} as const;
+
+type AnyOf = FromSchema<typeof anyOfSchema>;
+// => string | string[]
+```
+
+`FromSchema` will correctly infer factored schemas:
+
+```typescript
+const factoredSchema = {
+  type: "object",
+  properties: {
+    bool: { type: "boolean" },
+  },
+  required: ["bool"],
+  anyOf: [
+    {
+      properties: {
+        str: { type: "string" },
+      },
+      required: ["str"],
+    },
+    {
+      properties: {
+        num: { type: "number" },
+      },
+    },
+  ],
+} as const;
+
+type Factored = FromSchema<typeof factoredSchema>;
+// => {
+//  [x:string]: unknown;
+//  bool: boolean;
+//  str: string;
+// } | {
+//  [x:string]: unknown;
+//  bool: boolean;
+//  num?: number;
+// }
+```
+
+### OneOf
+
+For the moment, `FromSchema` will use the `oneOf` keyword in the same way as `anyOf`:
+
+```typescript
+const catSchema = {
+  type: "object",
+  oneOf: [
+    {
+      properties: {
+        name: { type: "string" },
+      },
+      required: ["name"],
+    },
+    {
+      properties: {
+        color: { enum: ["black", "brown", "white"] },
+      },
+    },
+  ],
+} as const;
+
+type Cat = FromSchema<typeof catSchema>;
+// => {
+//  [x: string]: unknown;
+//  name: string;
+// } | {
+//  [x: string]: unknown;
+//  color?: "black" | "brown" | "white";
+// }
+
+// => Error will NOT be raised 😱
+const invalidCat: Cat = { name: "Garfield" };
+```
+
+> This may be revised soon now that `not` exclusions are now possible
+
+### AllOf
+
+```typescript
+const addressSchema = {
+  type: "object",
+  allOf: [
+    {
+      properties: {
+        address: { type: "string" },
+        city: { type: "string" },
+        state: { type: "string" },
+      },
+      required: ["address", "city", "state"],
+    },
+    {
+      properties: {
+        type: { enum: ["residential", "business"] },
+      },
+    },
+  ],
+} as const;
+
+type Address = FromSchema<typeof addressSchema>;
+// => {
+//   [x: string]: unknown;
+//   address: string;
+//   city: string;
+//   state: string;
+//   type?: "residential" | "business";
+// }
+```
+
+### Not
+
+```typescript
+const tupleSchema = {
+  type: "array",
+  items: [{ const: 1 }, { const: 2 }],
+  additionalItems: false,
+  not: {
+    const: [1],
+  },
+} as const;
+
+type Tuple = FromSchema<typeof tupleSchema>;
+// => [] | [1, 2]
+```
+
+```typescript
+const primitiveTypeSchema = {
+  not: {
+    type: ["array", "object"],
+  },
+} as const;
+
+type PrimitiveType = FromSchema<typeof primitiveTypeSchema>;
+// => null | boolean | number | string
+```
+
+In objects and tuples, the exclusion will propagate to properties/items if it can collapse on a single one.
+
+```typescript
+// 👍 Can be propagated on "animal" property
+const petSchema = {
+  type: "object",
+  properties: {
+    animal: { enum: ["cat", "dog", "boat"] },
+  },
+  not: {
+    properties: { animal: { const: "boat" } },
+  },
+  required: ["animal"],
+  additionalProperties: false,
+} as const;
+
+type Pet = FromSchema<typeof petSchema>;
+// => { animal: "cat" | "dog" }
+```
+
+```typescript
+// ❌ Cannot be propagated
+const petSchema = {
+  type: "object",
+  properties: {
+    animal: { enum: ["cat", "dog"] },
+    color: { enum: ["black", "brown", "white"] },
+  },
+  not: {
+    const: { animal: "cat", color: "white" },
+  },
+  required: ["animal", "color"],
+  additionalProperties: false,
+} as const;
+
+type Pet = FromSchema<typeof petSchema>;
+// => { animal: "cat" | "dog", color: "black" | "brown" | "white" }
+```
+
+As some actionable keywords are not yet parsed, exclusions that resolve to `never` are granted the benefit of the doubt and omitted. For the moment, `FromSchema` assumes that you are not crafting unvalidatable exclusions.
+
+```typescript
+const oddNumberSchema = {
+  type: "number",
+  not: { multipleOf: 2 },
+} as const;
+
+type OddNumber = FromSchema<typeof oddNumberSchema>;
+// => should and will resolve to "number"
+
+const incorrectSchema = {
+  type: "number",
+  not: { bogus: "option" },
+} as const;
+
+type Incorrect = FromSchema<typeof incorrectSchema>;
+// => should resolve to "never" but will still resolve to "number"
+```
+
+Also, keep in mind that TypeScript misses [refinment types](https://en.wikipedia.org/wiki/Refinement_type):
+
+```typescript
+const goodLanguageSchema = {
+  type: "string",
+  not: {
+    enum: ["Bummer", "Silly", "Lazy sod !"],
+  },
+} as const;
+
+type GoodLanguage = FromSchema<typeof goodLanguageSchema>;
+// => string
+```
+
+### If/Then/Else
+
+```typescript
+const petSchema = {
+  type: "object",
+  properties: {
+    animal: { enum: ["cat", "dog"] },
+    dogBreed: { enum: Object.values(DogBreed) },
+    catBreed: { enum: Object.values(CatBreed) },
+  },
+  required: ["animal"],
+  additionalProperties: false,
+  if: {
+    properties: {
+      animal: { const: "dog" },
+    },
+  },
+  then: {
+    required: ["dogBreed"],
+    not: { required: ["catBreed"] },
+  },
+  else: {
+    required: ["catBreed"],
+    not: { required: ["dogBreed"] },
+  },
+} as const;
+
+type Pet = FromSchema<typeof petSchema>;
+// => { animal: "dog"; dogBreed: DogBreed }
+// | { animal: "cat"; catBreed: CatBreed }
+```
+
+> `FromSchema` computes the resulting type as `(If ∩ Then) ∪ (¬If ∩ Else)`. While correct in theory, remember that the `not` keyword is not perfectly assimilated, which may become an issue in some complex schemas.
+
+## Definitions
+
+Since the introduction of [template literal types](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html) with Typescript 4.1, the `definitions` keyword seems implementable in `json-schema-to-ts`.
+
+I'll soon be looking into it. Meanwhile, feel free to [open an issue](https://github.com/ThomasAribart/json-schema-to-ts/issues) 🤗
--- a/node_modules/json-schema-to-ts/lib/definitions/index.d.ts
+++ b/node_modules/json-schema-to-ts/lib/definitions/index.d.ts
@ -0,0 +1 @@
+export { JSONSchema6DefinitionWithoutInterface } from "./jsonSchema6";
--- a/node_modules/json-schema-to-ts/lib/definitions/jsonSchema6.d.ts
+++ b/node_modules/json-schema-to-ts/lib/definitions/jsonSchema6.d.ts
@ -0,0 +1,3 @@
+import { JSONSchema6Definition, JSONSchema6 } from "json-schema";
+import { Replace } from "../utils";
+export declare type JSONSchema6DefinitionWithoutInterface = JSONSchema6Definition extends infer S ? S extends JSONSchema6 ? Replace<S, "const" | "enum" | "not", unknown> : S : never;
--- a/node_modules/json-schema-to-ts/lib/index.d.ts
+++ b/node_modules/json-schema-to-ts/lib/index.d.ts
@ -0,0 +1,15 @@
+import { JSONSchema6Definition } from "json-schema";
+import { JSONSchema6DefinitionWithoutInterface } from "./definitions";
+import { Resolve } from "./meta-types";
+import { ParseSchema } from "./parse-schema";
+import { DeepWriteable, DeepReadonly } from "./utils";
+/**
+ * Unwided JSON schema (e.g. defined with the `as const` statement)
+ */
+export declare type JSONSchema = JSONSchema6Definition | DeepReadonly<JSONSchema6DefinitionWithoutInterface>;
+/**
+ * Given a JSON schema defined with the `as const` statement, infers the type of valid instances
+ *
+ * @param S JSON schema
+ */
+export declare type FromSchema<S extends JSONSchema> = Resolve<ParseSchema<DeepWriteable<S>>>;
--- a/node_modules/json-schema-to-ts/lib/meta-types/any.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/any.d.ts
@ -0,0 +1,5 @@
+export declare type AnyType = "any";
+export declare type Any = {
+    type: AnyType;
+};
+export declare type ResolveAny = unknown;
--- a/node_modules/json-schema-to-ts/lib/meta-types/array.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/array.d.ts
@ -0,0 +1,9 @@
+import { Get, Prettify } from "../utils";
+import { Resolve, Any } from ".";
+export declare type ArrType = "array";
+export declare type Arr<V = Any> = {
+    type: ArrType;
+    values: V;
+};
+export declare type Values<A> = Get<A, "values">;
+export declare type ResolveArr<T> = Prettify<Resolve<Values<T>>[]>;
--- a/node_modules/json-schema-to-ts/lib/meta-types/const.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/const.d.ts
@ -0,0 +1,8 @@
+import { Get } from "../utils";
+export declare type ConstType = "const";
+export declare type Const<V> = {
+    type: ConstType;
+    value: V;
+};
+export declare type Value<C> = Get<C, "value">;
+export declare type ResolveConst<T> = Value<T>;
--- a/node_modules/json-schema-to-ts/lib/meta-types/enum.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/enum.d.ts
@ -0,0 +1,10 @@
+import { A, B } from "ts-toolbelt";
+import { Get } from "../utils";
+export declare type EnumType = "enum";
+export declare type Enum<V> = {
+    type: EnumType;
+    values: V;
+};
+export declare type Values<E> = Get<E, "values">;
+export declare type ResolveEnum<T> = Values<T>;
+export declare type IsEnumRepresentable<E> = A.Equals<Values<E>, never> extends B.True ? false : true;
--- a/node_modules/json-schema-to-ts/lib/meta-types/error.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/error.d.ts
@ -0,0 +1,7 @@
+import { Get } from "../utils";
+export declare type ErrorType = "error";
+export declare type Error<M = "Unknown error"> = {
+    type: ErrorType;
+    message: M;
+};
+export declare type Message<E> = Get<E, "message">;
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/any.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/any.d.ts
@ -0,0 +1,20 @@
+import { Get } from "../../utils";
+import { MetaType, Never, Error } from "..";
+import { ExcludeUnion } from "./union";
+import { ExcludeIntersection } from "./intersection";
+import { ExcludeExclusion } from "./exclusion";
+export declare type ExcludeFromAny<Source, Excluded> = {
+    any: Never;
+    never: Source;
+    const: Source;
+    enum: Source;
+    primitive: Source;
+    array: Source;
+    tuple: Source;
+    object: Source;
+    union: ExcludeUnion<Source, Excluded>;
+    intersection: ExcludeIntersection<Source, Excluded>;
+    exclusion: ExcludeExclusion<Source, Excluded>;
+    error: Excluded;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<Excluded, "type"> extends MetaType ? Get<Excluded, "type"> : "errorTypeProperty"];
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/array.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/array.d.ts
@ -0,0 +1,27 @@
+import { A, B } from "ts-toolbelt";
+import { Get, And, DoesExtend } from "../../utils";
+import { MetaType, Never, Const, Error } from "..";
+import { Arr, Values } from "../array";
+import { Values as TupleValues, IsOpen, OpenProps } from "../tuple";
+import { Exclude } from ".";
+import { ExcludeUnion } from "./union";
+import { ExcludeIntersection } from "./intersection";
+import { ExcludeExclusion } from "./exclusion";
+import { IsRepresentable } from "../utils";
+export declare type ExcludeFromArray<Source, Excluded> = {
+    any: Never;
+    never: Source;
+    const: Source;
+    enum: Source;
+    primitive: Source;
+    array: ExcludeArrs<Source, Excluded>;
+    tuple: And<DoesExtend<A.Equals<TupleValues<Excluded>, []>, B.True>, IsOpen<Excluded>> extends true ? ExcludeArrs<Source, Arr<OpenProps<Excluded>>> : Source;
+    object: Source;
+    union: ExcludeUnion<Source, Excluded>;
+    intersection: ExcludeIntersection<Source, Excluded>;
+    exclusion: ExcludeExclusion<Source, Excluded>;
+    error: Excluded;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<Excluded, "type"> extends MetaType ? Get<Excluded, "type"> : "errorTypeProperty"];
+declare type ExcludeArrs<Source, Excluded, ExcludedValues = Exclude<Values<Source>, Values<Excluded>>> = IsRepresentable<ExcludedValues> extends true ? Source : Const<[]>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/const.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/const.d.ts
@ -0,0 +1,34 @@
+import { Get, IsObject } from "../../utils";
+import { Resolve, MetaType, Never, Error } from "..";
+import { Const, Value } from "../const";
+import { Values, Required, IsOpen, OpenProps } from "../object";
+import { IsRepresentable } from "../utils";
+import { Exclude } from ".";
+import { ExcludeUnion } from "./union";
+import { ExcludeIntersection } from "./intersection";
+import { ExcludeExclusion } from "./exclusion";
+export declare type ExcludeFromConst<Source, Excluded> = {
+    any: Never;
+    never: Source;
+    const: CheckNotExtendsResolved<Source, Excluded>;
+    enum: CheckNotExtendsResolved<Source, Excluded>;
+    primitive: CheckNotExtendsResolved<Source, Excluded>;
+    array: CheckNotExtendsResolved<Source, Excluded>;
+    tuple: CheckNotExtendsResolved<Source, Excluded>;
+    object: ExcludeObject<Source, Excluded>;
+    union: ExcludeUnion<Source, Excluded>;
+    intersection: ExcludeIntersection<Source, Excluded>;
+    exclusion: ExcludeExclusion<Source, Excluded>;
+    error: Excluded;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<Excluded, "type"> extends MetaType ? Get<Excluded, "type"> : "errorTypeProperty"];
+declare type CheckNotExtendsResolved<Source, Excluded> = Value<Source> extends Resolve<Excluded> ? Never : Source;
+declare type ExcludeObject<Source, Excluded> = IsObject<Value<Source>> extends true ? Required<Source> extends keyof Value<Source> ? ExcludeObjectFromConst<Source, Excluded> : Source : Source;
+declare type ExcludeObjectFromConst<Source, Excluded, ExcludedValues = ExcludeConstValues<Value<Source>, Excluded>> = RepresentableKeys<ExcludedValues> extends never ? Never : Source;
+declare type ExcludeConstValues<SourceValue, Excluded> = {
+    [key in keyof SourceValue]: key extends keyof Values<Excluded> ? Exclude<Const<SourceValue[key]>, Values<Excluded>[key]> : IsOpen<Excluded> extends true ? Exclude<Const<SourceValue[key]>, OpenProps<Excluded>> : SourceValue[key];
+};
+declare type RepresentableKeys<O> = {
+    [key in keyof O]: IsRepresentable<O[key]> extends true ? key : never;
+}[keyof O];
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/enum.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/enum.d.ts
@ -0,0 +1,30 @@
+import { A, B, U } from "ts-toolbelt";
+import { Get } from "../../utils";
+import { MetaType, Never, Const, Error } from "..";
+import { Enum, Values } from "../enum";
+import { Intersect } from "../intersection";
+import { IsRepresentable } from "../utils";
+import { Exclude } from ".";
+import { ExcludeUnion } from "./union";
+import { ExcludeIntersection } from "./intersection";
+import { ExcludeExclusion } from "./exclusion";
+export declare type ExcludeFromEnum<Source, Excluded> = {
+    any: Never;
+    never: Source;
+    const: FilterExcluded<Source, Excluded>;
+    enum: FilterExcluded<Source, Excluded>;
+    primitive: FilterExcluded<Source, Excluded>;
+    array: FilterExcluded<Source, Excluded>;
+    tuple: FilterExcluded<Source, Excluded>;
+    object: FilterExcluded<Source, Excluded>;
+    union: ExcludeUnion<Source, Excluded>;
+    intersection: ExcludeIntersection<Source, Excluded>;
+    exclusion: ExcludeExclusion<Source, Excluded>;
+    error: Excluded;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<Excluded, "type"> extends MetaType ? Get<Excluded, "type"> : "errorTypeProperty"];
+declare type FilterExcluded<SourceEnum, Excluded> = Enum<RecurseOnEnumValues<Values<SourceEnum>, Excluded>>;
+declare type RecurseOnEnumValues<EnumValues, Excluded> = EnumValues extends infer EnumValue ? IsRepresentable<Exclude<Const<EnumValue>, Excluded>> extends false ? never : EnumValue : never;
+export declare type ExcludeEnum<Source, ExcludedEnum, ExcludedEnumValues = Values<ExcludedEnum>> = A.Equals<ExcludedEnumValues, never> extends B.True ? Source : ExcludeEnumValue<Source, U.Last<ExcludedEnumValues>, ExcludedEnumValues>;
+declare type ExcludeEnumValue<Source, LastEnumValue, ExcludedEnumValues> = Intersect<Exclude<Source, Const<LastEnumValue>>, Exclude<Source, Enum<U.Exclude<ExcludedEnumValues, LastEnumValue>>>>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/exclusion.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/exclusion.d.ts
@ -0,0 +1,2 @@
+import { Exclude, Value, Excluded } from ".";
+export declare type ExcludeExclusion<Source, ExcludedExclusion> = Exclude<Source, Exclude<Value<ExcludedExclusion>, Excluded<ExcludedExclusion>>>;
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/index.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/index.d.ts
@ -0,0 +1,37 @@
+import { Get } from "../../utils";
+import { Resolve, MetaType, Never, Error } from "..";
+import { ClearIntersections } from "../intersection";
+import { ExcludeFromAny } from "./any";
+import { ExcludeFromConst } from "./const";
+import { ExcludeFromEnum } from "./enum";
+import { ExcludeFromPrimitive } from "./primitive";
+import { ExcludeFromArray } from "./array";
+import { ExcludeFromTuple } from "./tuple";
+import { ExcludeFromObject } from "./object";
+import { DistributeUnion } from "./union";
+import { IsRepresentable } from "../utils";
+export declare type ExclusionType = "exclusion";
+export declare type Exclusion<V, E> = {
+    type: ExclusionType;
+    value: V;
+    excluded: E;
+};
+export declare type Value<E> = Get<E, "value">;
+export declare type Excluded<E> = Get<E, "excluded">;
+export declare type ResolveExclusion<E> = Resolve<Exclude<Value<E>, Excluded<E>>>;
+export declare type Exclude<A, B> = {
+    any: ExcludeFromAny<A, B>;
+    never: Never;
+    const: ExcludeFromConst<A, B>;
+    enum: ExcludeFromEnum<A, B>;
+    primitive: ExcludeFromPrimitive<A, B>;
+    array: ExcludeFromArray<A, B>;
+    tuple: ExcludeFromTuple<A, B>;
+    object: ExcludeFromObject<A, B>;
+    union: DistributeUnion<A, B>;
+    intersection: Exclude<ClearIntersections<A>, B>;
+    exclusion: Exclude<Exclude<Value<A>, Excluded<A>>, B>;
+    error: A;
+    errorMissingType: Error<"Missing type property in Exclusion source value">;
+}[Get<A, "type"> extends MetaType ? Get<A, "type"> : "errorMissingType"];
+export declare type IsExclusionRepresentable<E> = IsRepresentable<Exclude<Value<E>, Excluded<E>>>;
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/intersection.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/intersection.d.ts
@ -0,0 +1,3 @@
+import { Exclude } from ".";
+import { ClearIntersections } from "../intersection";
+export declare type ExcludeIntersection<Source, ExcludedIntersection> = Exclude<Source, ClearIntersections<ExcludedIntersection>>;
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/object.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/object.d.ts
@ -0,0 +1,65 @@
+import { A, B, U } from "ts-toolbelt";
+import { Get, And, Or, Not, DoesExtend, IsObject } from "../../utils";
+import { MetaType, Never, Error } from "..";
+import { Const, Value as ConstValue } from "../const";
+import { Object, Values, Value, Required, IsOpen, OpenProps } from "../object";
+import { IsRepresentable } from "../utils";
+import { Exclude } from ".";
+import { ExcludeEnum } from "./enum";
+import { ExcludeUnion } from "./union";
+import { ExcludeIntersection } from "./intersection";
+import { ExcludeExclusion } from "./exclusion";
+import { CrossValue, SourceValue, IsExclusionValueRepresentable, IsOutsideOfSourceScope, IsOutsideOfExcludedScope, Propagate, IsOmittable } from "./utils";
+export declare type ExcludeFromObject<S, E> = {
+    any: Never;
+    never: S;
+    const: ExcludeConst<S, E>;
+    enum: ExcludeEnum<S, E>;
+    primitive: S;
+    array: S;
+    tuple: S;
+    object: ExcludeObjects<S, E>;
+    union: ExcludeUnion<S, E>;
+    intersection: ExcludeIntersection<S, E>;
+    exclusion: ExcludeExclusion<S, E>;
+    error: E;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<E, "type"> extends MetaType ? Get<E, "type"> : "errorTypeProperty"];
+declare type ExcludeObjects<S, E, C = CrossObjectValues<S, E>, R = RepresentableKeys<C>, P = Exclude<OpenProps<S>, OpenProps<E>>> = DoesObjectSizesMatch<S, E, C> extends true ? {
+    moreThanTwo: S;
+    onlyOne: PropagateExclusion<S, C>;
+    none: OmitOmittableKeys<S, C>;
+}[And<IsOpen<S>, IsRepresentable<P>> extends true ? "moreThanTwo" : GetUnionLength<R>] : S;
+declare type CrossObjectValues<S, E> = {
+    [key in keyof Values<S> | keyof Values<E> | Required<S> | Required<E>]: CrossValue<Value<S, key>, IsPossibleIn<S, key>, IsRequiredIn<S, key>, Value<E, key>, IsPossibleIn<E, key>, IsRequiredIn<E, key>>;
+};
+declare type GetUnionLength<Union> = A.Equals<Union, never> extends B.True ? "none" : A.Equals<U.Pop<Union>, never> extends B.True ? "onlyOne" : "moreThanTwo";
+declare type IsPossibleIn<O, K> = Or<DoesExtend<K, keyof Values<O>>, IsOpen<O>>;
+declare type IsRequiredIn<O, K> = DoesExtend<K, Required<O>>;
+declare type DoesObjectSizesMatch<S, E, C> = And<IsOpen<S>, Not<IsOpen<E>>> extends true ? false : And<IsExcludedSmallEnough<C>, IsExcludedBigEnough<C>>;
+declare type IsExcludedSmallEnough<C> = Not<DoesExtend<true, {
+    [key in keyof C]: IsOutsideOfSourceScope<C[key]>;
+}[keyof C]>>;
+declare type IsExcludedBigEnough<C> = Not<DoesExtend<true, {
+    [key in keyof C]: IsOutsideOfExcludedScope<C[key]>;
+}[keyof C]>>;
+declare type RepresentableKeys<C> = {
+    [key in keyof C]: IsExclusionValueRepresentable<C[key]> extends true ? key : never;
+}[keyof C];
+declare type PropagateExclusion<S, C> = Object<{
+    [key in keyof C]: Propagate<C[key]>;
+}, Required<S>, IsOpen<S>, OpenProps<S>>;
+declare type OmitOmittableKeys<S, C, K = OmittableKeys<C>> = {
+    moreThanTwo: S;
+    onlyOne: Object<{
+        [key in keyof C]: key extends K ? Never : SourceValue<C[key]>;
+    }, Required<S>, IsOpen<S>, OpenProps<S>>;
+    none: Never;
+}[GetUnionLength<K>];
+declare type OmittableKeys<C> = {
+    [key in keyof C]: IsOmittable<C[key]> extends true ? key : never;
+}[keyof C];
+declare type ExcludeConst<S, E, V = ConstValue<E>> = IsObject<V> extends true ? Exclude<S, Object<{
+    [key in keyof V]: Const<V[key]>;
+}, keyof V, false, Never>> : S;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/primitive.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/primitive.d.ts
@ -0,0 +1,21 @@
+import { Get } from "../../utils";
+import { MetaType, Never, Error } from "..";
+import { Value } from "../primitive";
+import { ExcludeUnion } from "./union";
+import { ExcludeIntersection } from "./intersection";
+import { ExcludeExclusion } from "./exclusion";
+export declare type ExcludeFromPrimitive<A, B> = {
+    any: Never;
+    never: A;
+    const: A;
+    enum: A;
+    primitive: Value<A> extends Value<B> ? Never : A;
+    array: A;
+    tuple: A;
+    object: A;
+    union: ExcludeUnion<A, B>;
+    intersection: ExcludeIntersection<A, B>;
+    exclusion: ExcludeExclusion<A, B>;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/tuple.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/tuple.d.ts
@ -0,0 +1,77 @@
+import { A, B } from "ts-toolbelt";
+import { Get, And, Not, IsArray, Head, Tail, Prepend, Reverse } from "../../utils";
+import { MetaType, Never, Error } from "..";
+import { Const, Value as ConstValue } from "../const";
+import { Values as ArrayValues } from "../array";
+import { Tuple, Values, IsOpen, OpenProps } from "../tuple";
+import { IsRepresentable } from "../utils";
+import { Exclude } from ".";
+import { ExcludeEnum } from "./enum";
+import { ExcludeUnion } from "./union";
+import { ExcludeIntersection } from "./intersection";
+import { ExcludeExclusion } from "./exclusion";
+import { CrossValue, SourceValue, IsExclusionValueRepresentable, IsOutsideOfSourceScope, IsOutsideOfExcludedScope, Propagate, IsOmittable } from "./utils";
+export declare type ExcludeFromTuple<S, E> = {
+    any: Never;
+    never: S;
+    const: ExcludeConst<S, E>;
+    enum: ExcludeEnum<S, E>;
+    primitive: S;
+    array: ExcludeArray<S, E>;
+    tuple: ExcludeTuples<S, E>;
+    object: S;
+    union: ExcludeUnion<S, E>;
+    intersection: ExcludeIntersection<S, E>;
+    exclusion: ExcludeExclusion<S, E>;
+    error: E;
+    errorMissingType: Error<"Missing type property in Exclusion excluded value">;
+}[Get<E, "type"> extends MetaType ? Get<E, "type"> : "errorMissingType"];
+declare type ExcludeArray<S, E> = ExcludeTuples<S, Tuple<[], true, ArrayValues<E>>>;
+declare type ExcludeTuples<S, E, C = CrossTupleValues<Values<S>, Values<E>, IsOpen<S>, IsOpen<E>, OpenProps<S>, OpenProps<E>>, R = RepresentableItems<C>, P = Exclude<OpenProps<S>, OpenProps<E>>, I = IsRepresentable<P>> = DoesTupleSizesMatch<S, E, C> extends true ? {
+    moreThanTwo: S;
+    onlyOne: Tuple<PropagateExclusion<C>, I extends true ? IsOpen<S> : false, P>;
+    none: OmitOmittableItems<S, C>;
+}[And<IsOpen<S>, I> extends true ? "moreThanTwo" : GetTupleLength<R>] : S;
+declare type CrossTupleValues<V1, V2, O1, O2, P1, P2, R extends any[] = []> = {
+    stop: Reverse<R>;
+    continue1: CrossTupleValues<Tail<V1>, [], O1, O2, P1, P2, Prepend<CrossValue<Head<V1>, true, true, P2, O2, false>, R>>;
+    continue2: CrossTupleValues<[], Tail<V2>, O1, O2, P1, P2, Prepend<CrossValue<P1, O1, false, Head<V2>, true, true>, R>>;
+    continueBoth: CrossTupleValues<Tail<V1>, Tail<V2>, O1, O2, P1, P2, Prepend<CrossValue<Head<V1>, true, true, Head<V2>, true, true>, R>>;
+}[V1 extends [any, ...any[]] ? V2 extends [any, ...any[]] ? "continueBoth" : "continue1" : V2 extends [any, ...any[]] ? "continue2" : "stop"];
+declare type GetTupleLength<T> = A.Equals<T, []> extends B.True ? "none" : A.Equals<Tail<T>, []> extends B.True ? "onlyOne" : "moreThanTwo";
+declare type DoesTupleSizesMatch<S, E, C> = And<IsOpen<S>, Not<IsOpen<E>>> extends true ? false : And<IsExcludedSmallEnough<C>, IsExcludedBigEnough<C>>;
+declare type IsExcludedSmallEnough<C> = {
+    stop: true;
+    continue: IsOutsideOfSourceScope<Head<C>> extends true ? false : IsExcludedSmallEnough<Tail<C>>;
+}[C extends [any, ...any[]] ? "continue" : "stop"];
+declare type IsExcludedBigEnough<C> = {
+    stop: true;
+    continue: IsOutsideOfExcludedScope<Head<C>> extends true ? false : IsExcludedBigEnough<Tail<C>>;
+}[C extends [any, ...any[]] ? "continue" : "stop"];
+declare type RepresentableItems<C, R extends any[] = []> = {
+    stop: R;
+    continue: IsExclusionValueRepresentable<Head<C>> extends true ? RepresentableItems<Tail<C>, Prepend<Head<C>, R>> : RepresentableItems<Tail<C>, R>;
+}[C extends [any, ...any[]] ? "continue" : "stop"];
+declare type PropagateExclusion<C, R extends any[] = []> = {
+    stop: Reverse<R>;
+    continue: PropagateExclusion<Tail<C>, Prepend<Propagate<Head<C>>, R>>;
+}[C extends [any, ...any[]] ? "continue" : "stop"];
+declare type OmitOmittableItems<S, C, I = OmittableItems<C>> = {
+    moreThanTwo: S;
+    onlyOne: Tuple<RequiredTupleValues<S, C>, false, OpenProps<S>>;
+    none: Never;
+}[GetTupleLength<I>];
+declare type OmittableItems<C, R extends any[] = []> = {
+    stop: R;
+    continue: IsOmittable<Head<C>> extends true ? OmittableItems<Tail<C>, Prepend<Head<C>, R>> : OmittableItems<Tail<C>, R>;
+}[C extends [any, ...any[]] ? "continue" : "stop"];
+declare type RequiredTupleValues<S, C, R extends any[] = []> = {
+    stop: Reverse<R>;
+    continue: IsOmittable<Head<C>> extends true ? Reverse<R> : RequiredTupleValues<Tail<S>, Tail<C>, Prepend<SourceValue<Head<C>>, R>>;
+}[C extends [any, ...any[]] ? "continue" : "stop"];
+declare type ExcludeConst<S, E, V = ConstValue<E>> = IsArray<V> extends true ? Exclude<S, Tuple<ExtractConstValues<V>, false, Never>> : S;
+declare type ExtractConstValues<V, R extends any[] = []> = {
+    stop: Reverse<R>;
+    continue: ExtractConstValues<Tail<V>, Prepend<Const<Head<V>>, R>>;
+}[V extends [any, ...any[]] ? "continue" : "stop"];
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/union.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/union.d.ts
@ -0,0 +1,9 @@
+import { A, B, U } from "ts-toolbelt";
+import { Union, Values } from "../union";
+import { Intersect } from "../intersection";
+import { Exclude } from ".";
+export declare type DistributeUnion<U, E> = Union<RecurseOnUnion<Values<U>, E>>;
+declare type RecurseOnUnion<V, E> = V extends infer T ? Exclude<T, E> : never;
+export declare type ExcludeUnion<V, U> = A.Equals<Values<U>, never> extends B.True ? V : ExcludeUnionValue<V, U.Last<Values<U>>, U>;
+declare type ExcludeUnionValue<V, L, U> = Intersect<Exclude<V, L>, Exclude<V, Union<U.Exclude<Values<U>, L>>>>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/exclusion/utils.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/exclusion/utils.d.ts
@ -0,0 +1,24 @@
+import { Get, And, Not } from "../../utils";
+import { IsRepresentable } from "../utils";
+import { Exclude } from ".";
+export declare type CrossValue<V1, P1, R1, V2, P2, R2, X = Exclude<V1, V2>> = {
+    sourceValue: V1;
+    isPossibleInSource: P1;
+    isRequiredInSource: R1;
+    isPossibleInExcluded: P2;
+    isRequiredInExcluded: R2;
+    exclusionValue: X;
+    isExclusionValueRepresentable: IsRepresentable<X>;
+};
+export declare type SourceValue<C> = Get<C, "sourceValue">;
+declare type IsPossibleInSource<C> = Get<C, "isPossibleInSource">;
+declare type IsRequiredInSource<C> = Get<C, "isRequiredInSource">;
+declare type IsPossibleInExcluded<C> = Get<C, "isPossibleInExcluded">;
+declare type IsRequiredInExcluded<C> = Get<C, "isRequiredInExcluded">;
+export declare type ExclusionValue<C> = Get<C, "exclusionValue">;
+export declare type IsExclusionValueRepresentable<C> = Get<C, "isExclusionValueRepresentable">;
+export declare type IsOutsideOfSourceScope<C> = And<IsRequiredInExcluded<C>, Not<IsPossibleInSource<C>>>;
+export declare type IsOutsideOfExcludedScope<C> = And<IsRequiredInSource<C>, Not<IsPossibleInExcluded<C>>>;
+export declare type Propagate<C> = IsExclusionValueRepresentable<C> extends true ? ExclusionValue<C> : SourceValue<C>;
+export declare type IsOmittable<C> = And<Not<IsRequiredInSource<C>>, IsRequiredInExcluded<C>>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/index.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/index.d.ts
@ -0,0 +1,29 @@
+import { Get } from "../utils";
+import { Any, AnyType, ResolveAny } from "./any";
+import { Never, NeverType, ResolveNever } from "./never";
+import { Const, ConstType, ResolveConst } from "./const";
+import { Enum, EnumType, ResolveEnum } from "./enum";
+import { Primitive, PrimitiveType, ResolvePrimitive } from "./primitive";
+import { Arr, ArrType, ResolveArr } from "./array";
+import { Tuple, TupleType, ResolveTuple } from "./tuple";
+import { Object, ObjectType, ResolveObject } from "./object";
+import { Union, UnionType, ResolveUnion } from "./union";
+import { Intersection, IntersectionType, ResolveIntersection } from "./intersection";
+import { Error, ErrorType } from "./error";
+import { Exclusion, ExclusionType, ResolveExclusion } from "./exclusion";
+export declare type MetaType = AnyType | NeverType | ConstType | EnumType | PrimitiveType | ArrType | TupleType | ObjectType | UnionType | IntersectionType | ExclusionType | ErrorType;
+export declare type Resolve<T, D = Exclude<T, undefined>> = {
+    any: ResolveAny;
+    never: ResolveNever;
+    const: ResolveConst<D>;
+    enum: ResolveEnum<D>;
+    primitive: ResolvePrimitive<D>;
+    array: ResolveArr<D>;
+    tuple: ResolveTuple<D>;
+    object: ResolveObject<D>;
+    union: ResolveUnion<D>;
+    intersection: ResolveIntersection<D>;
+    exclusion: ResolveExclusion<D>;
+    error: never;
+}[Get<D, "type"> extends MetaType ? Get<D, "type"> : "error"];
+export { Any, Never, Const, Enum, Primitive, Arr, Tuple, Object, Union, Intersection, Exclusion, Error, };
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/array.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/array.d.ts
@ -0,0 +1,27 @@
+import { Get } from "../../utils";
+import { MetaType, Never, Arr, Error } from "..";
+import { Values } from "../array";
+import { IntersectConst } from "./const";
+import { IntersectEnum } from "./enum";
+import { IntersectTuple } from "./tuple";
+import { IntersectUnion } from "./union";
+import { IntersectExclusion } from "./exclusion";
+import { ClearIntersections, Intersect } from "./index";
+export declare type ClearArrIntersections<A> = Arr<ClearIntersections<Values<A>>>;
+export declare type IntersectArr<A, B> = {
+    any: A;
+    never: Never;
+    const: IntersectConst<B, A>;
+    enum: IntersectEnum<B, A>;
+    primitive: Never;
+    array: IntersectArrs<A, B>;
+    tuple: IntersectTuple<B, A>;
+    object: Never;
+    union: IntersectUnion<B, A>;
+    exclusion: IntersectExclusion<B, A>;
+    intersection: Error<"Cannot intersect intersection">;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
+declare type IntersectArrs<A, B, I = Intersect<Values<A>, Values<B>>> = I extends Never ? Never : Arr<I>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/const.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/const.d.ts
@ -0,0 +1,32 @@
+import { Get, IsObject } from "../../utils";
+import { Resolve, MetaType, Never, Error } from "..";
+import { Const, Value } from "../const";
+import { Values, Required, IsOpen, OpenProps } from "../object";
+import { IntersectUnion } from "./union";
+import { IntersectExclusion } from "./exclusion";
+import { Intersect } from "./index";
+export declare type IntersectConst<A, B> = {
+    any: A;
+    never: Never;
+    const: CheckExtendsResolved<A, B>;
+    enum: CheckExtendsResolved<A, B>;
+    primitive: CheckExtendsResolved<A, B>;
+    array: CheckExtendsResolved<A, B>;
+    tuple: CheckExtendsResolved<A, B>;
+    object: ToObject<A, B>;
+    union: IntersectUnion<B, A>;
+    exclusion: IntersectExclusion<B, A>;
+    intersection: Error<"Cannot intersect intersection">;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
+declare type CheckExtendsResolved<A, B> = Value<A> extends Resolve<B> ? A : Never;
+declare type ToObject<A, B> = IsObject<Value<A>> extends true ? IntersectConstToObject<A, B> : Never;
+declare type IntersectConstToObject<A, B, V = IntersectConstValues<Value<A>, B>> = NeverKeys<V> extends never ? A : Never;
+declare type IntersectConstValues<V, B> = {
+    [key in keyof V | Required<B>]: key extends keyof V ? key extends keyof Values<B> ? Intersect<Const<V[key]>, Values<B>[key]> : IsOpen<B> extends true ? Intersect<Const<V[key]>, OpenProps<B>> : Never : Never;
+};
+declare type NeverKeys<O> = {
+    [key in keyof O]: O[key] extends Never ? key : never;
+}[keyof O];
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/enum.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/enum.d.ts
@ -0,0 +1,25 @@
+import { Get } from "../../utils";
+import { MetaType, Never, Const, Error } from "..";
+import { Enum, Values } from "../enum";
+import { IntersectConst } from "./const";
+import { IntersectUnion } from "./union";
+import { IntersectExclusion } from "./exclusion";
+import { Intersect } from "./index";
+export declare type IntersectEnum<A, B> = {
+    any: A;
+    never: Never;
+    const: IntersectConst<B, A>;
+    enum: FilterUnintersecting<A, B>;
+    primitive: FilterUnintersecting<A, B>;
+    array: FilterUnintersecting<A, B>;
+    tuple: FilterUnintersecting<A, B>;
+    object: FilterUnintersecting<A, B>;
+    union: IntersectUnion<B, A>;
+    exclusion: IntersectExclusion<B, A>;
+    intersection: Error<"Cannot intersect intersection">;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
+declare type FilterUnintersecting<A, B> = Enum<RecurseOnEnumValues<Values<A>, B>>;
+declare type RecurseOnEnumValues<V, B> = V extends infer T ? Intersect<Const<T>, B> extends Never ? never : T : never;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/exclusion.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/exclusion.d.ts
@ -0,0 +1,21 @@
+import { Get } from "../../utils";
+import { MetaType, Never, Error, Union } from "..";
+import { Exclusion, Value, Excluded } from "../exclusion";
+import { IntersectUnion } from "./union";
+import { ClearIntersections, Intersect } from "./index";
+export declare type ClearExclusionIntersections<A> = Exclusion<ClearIntersections<Value<A>>, ClearIntersections<Excluded<A>>>;
+export declare type IntersectExclusion<A, B> = {
+    any: A;
+    never: Never;
+    const: Exclusion<Intersect<Value<A>, B>, Excluded<A>>;
+    enum: Exclusion<Intersect<Value<A>, B>, Excluded<A>>;
+    primitive: Exclusion<Intersect<Value<A>, B>, Excluded<A>>;
+    array: Exclusion<Intersect<Value<A>, B>, Excluded<A>>;
+    tuple: Exclusion<Intersect<Value<A>, B>, Excluded<A>>;
+    object: Exclusion<Intersect<Value<A>, B>, Excluded<A>>;
+    union: IntersectUnion<B, A>;
+    intersection: Error<"Cannot intersect intersection">;
+    exclusion: Exclusion<Intersect<Value<A>, Value<B>>, Union<Excluded<A> | Excluded<B>>>;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/index.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/index.d.ts
@ -0,0 +1,53 @@
+import { DoesExtend, Get } from "../../utils";
+import { Resolve, MetaType, Never, Error } from "..";
+import { ErrorType } from "../error";
+import { IntersectConst } from "./const";
+import { IntersectEnum } from "./enum";
+import { IntersectPrimitive } from "./primitive";
+import { ClearArrIntersections, IntersectArr } from "./array";
+import { ClearTupleIntersections, IntersectTuple } from "./tuple";
+import { ClearObjectIntersections, IntersectObject } from "./object";
+import { ClearUnionIntersections, IntersectUnion } from "./union";
+import { ClearExclusionIntersections, IntersectExclusion } from "./exclusion";
+import { IsRepresentable } from "../utils";
+export declare type IntersectionType = "intersection";
+export declare type Intersection<L, R> = {
+    type: IntersectionType;
+    left: L;
+    right: R;
+};
+export declare type IsIntersection<I> = DoesExtend<Get<I, "type">, IntersectionType>;
+export declare type Left<I> = Get<I, "left">;
+export declare type Right<I> = Get<I, "right">;
+export declare type ResolveIntersection<T> = Resolve<ClearIntersections<T>>;
+export declare type ClearIntersections<T> = {
+    any: T;
+    never: T;
+    const: T;
+    enum: T;
+    primitive: T;
+    array: ClearArrIntersections<T>;
+    tuple: ClearTupleIntersections<T>;
+    object: ClearObjectIntersections<T>;
+    union: ClearUnionIntersections<T>;
+    intersection: Intersect<ClearIntersections<Left<T>>, ClearIntersections<Right<T>>>;
+    exclusion: ClearExclusionIntersections<T>;
+    error: T;
+    errorMissingType: Error<"Missing type property">;
+}[Get<T, "type"> extends MetaType ? Get<T, "type"> : "errorMissingType"];
+export declare type Intersect<A, B> = {
+    any: B;
+    never: Get<B, "type"> extends ErrorType ? B : Never;
+    const: IntersectConst<A, B>;
+    enum: IntersectEnum<A, B>;
+    primitive: IntersectPrimitive<A, B>;
+    array: IntersectArr<A, B>;
+    tuple: IntersectTuple<A, B>;
+    object: IntersectObject<A, B>;
+    union: IntersectUnion<A, B>;
+    intersection: Error<"Cannot intersect intersection">;
+    exclusion: IntersectExclusion<A, B>;
+    error: A;
+    errorMissingType: Error<"Missing type property">;
+}[Get<A, "type"> extends MetaType ? Get<A, "type"> : "errorMissingType"];
+export declare type IsIntersectionRepresentable<A> = IsRepresentable<ClearIntersections<A>>;
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/object.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/object.d.ts
@ -0,0 +1,40 @@
+import { Get, And } from "../../utils";
+import { MetaType, Never, Error } from "..";
+import { Object, Values, Required, IsOpen, OpenProps } from "../object";
+import { IntersectConst } from "./const";
+import { IntersectEnum } from "./enum";
+import { DistributeIntersection } from "./union";
+import { IntersectExclusion } from "./exclusion";
+import { ClearIntersections, Intersect } from "./index";
+export declare type ClearObjectIntersections<A, V = ClearObjectValuesIntersections<Values<A>>, N = NeverKeys<V>, O = ClearIntersections<OpenProps<A>>> = Required<A> extends Exclude<Required<A>, N> ? Object<{
+    [key in Exclude<keyof V, N>]: V[key];
+}, Required<A>, O extends Never ? false : IsOpen<A>, O> : Never;
+declare type ClearObjectValuesIntersections<V> = {
+    [key in keyof V]: ClearIntersections<V[key]>;
+};
+export declare type IntersectObject<A, B> = {
+    any: A;
+    never: Never;
+    const: IntersectConst<B, A>;
+    enum: IntersectEnum<B, A>;
+    primitive: Never;
+    array: Never;
+    tuple: Never;
+    object: IntersectObjects<A, B>;
+    union: DistributeIntersection<B, A>;
+    intersection: Error<"Cannot intersect intersection">;
+    exclusion: IntersectExclusion<B, A>;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
+declare type IntersectObjects<A, B, V = IntersectValues<A, B>, N = NeverKeys<V>, O = IntersectOpenProps<A, B>> = Required<A> | Required<B> extends Exclude<Required<A> | Required<B>, N> ? Object<{
+    [key in Exclude<keyof V, N>]: V[key];
+}, Required<A> | Required<B>, O extends Never ? false : And<IsOpen<A>, IsOpen<B>>, O> : Never;
+declare type IntersectValues<A, B> = {
+    [key in keyof Values<A> | keyof Values<B>]: key extends keyof Values<A> ? key extends keyof Values<B> ? Intersect<Values<A>[key], Values<B>[key]> : IsOpen<B> extends true ? Intersect<Values<A>[key], OpenProps<B>> : Never : key extends keyof Values<B> ? IsOpen<A> extends true ? Intersect<OpenProps<A>, Values<B>[key]> : Never : Never;
+};
+declare type NeverKeys<O> = {
+    [key in keyof O]: O[key] extends Never ? key : never;
+}[keyof O];
+declare type IntersectOpenProps<A, B> = Intersect<OpenProps<A>, OpenProps<B>>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/primitive.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/primitive.d.ts
@ -0,0 +1,22 @@
+import { Get } from "../../utils";
+import { MetaType, Never, Error } from "..";
+import { Value } from "../primitive";
+import { IntersectConst } from "./const";
+import { IntersectEnum } from "./enum";
+import { IntersectExclusion } from "./exclusion";
+import { Intersect } from ".";
+export declare type IntersectPrimitive<A, B> = {
+    any: A;
+    never: Never;
+    const: IntersectConst<B, A>;
+    enum: IntersectEnum<B, A>;
+    primitive: Value<A> extends Value<B> ? A : Value<B> extends Value<A> ? B : Never;
+    array: Never;
+    tuple: Never;
+    object: Never;
+    union: Intersect<B, A>;
+    intersection: Error<"Cannot intersect intersection">;
+    exclusion: IntersectExclusion<B, A>;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/tuple.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/tuple.d.ts
@ -0,0 +1,46 @@
+import { Get, Head, Tail, Prepend, Reverse, And } from "../../utils";
+import { MetaType, Never, Tuple, Error } from "..";
+import { Values as ArrValues } from "../array";
+import { Values, IsOpen, OpenProps } from "../tuple";
+import { IntersectConst } from "./const";
+import { IntersectEnum } from "./enum";
+import { DistributeIntersection } from "./union";
+import { IntersectExclusion } from "./exclusion";
+import { ClearIntersections, Intersect } from ".";
+export declare type ClearTupleIntersections<T, O = ClearIntersections<OpenProps<T>>> = Tuple<ClearTupleValuesIntersections<Values<T>>, O extends Never ? false : IsOpen<T>, O>;
+declare type ClearTupleValuesIntersections<V, R extends any[] = []> = {
+    stop: Reverse<R>;
+    continue: ClearTupleValuesIntersections<Tail<V>, Prepend<ClearIntersections<Head<V>>, R>>;
+}[V extends [any, ...any[]] ? "continue" : "stop"];
+export declare type IntersectTuple<A, B> = {
+    any: A;
+    never: Never;
+    const: IntersectConst<B, A>;
+    enum: IntersectEnum<B, A>;
+    primitive: Never;
+    array: IntersectTupleToArray<A, B>;
+    tuple: IntersectTuples<A, B>;
+    object: Never;
+    union: DistributeIntersection<B, A>;
+    intersection: Error<"Cannot intersect intersection">;
+    exclusion: IntersectExclusion<B, A>;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
+declare type IntersectTupleToArray<T, A, V = IntersectTupleToArrValues<Values<T>, ArrValues<A>>, N = HasNeverValue<V>, O = Intersect<OpenProps<T>, ArrValues<A>>> = N extends true ? Never : Tuple<V, IsOpen<T> extends true ? (O extends Never ? false : true) : false, O>;
+declare type IntersectTupleToArrValues<V, T, R = []> = {
+    stop: Reverse<R>;
+    continue: R extends any[] ? IntersectTupleToArrValues<Tail<V>, T, Prepend<Intersect<Head<V>, T>, R>> : never;
+}[V extends [any, ...any[]] ? "continue" : "stop"];
+declare type HasNeverValue<V, R = false> = {
+    stop: R;
+    continue: Head<V> extends Never ? true : HasNeverValue<Tail<V>>;
+}[V extends [any, ...any[]] ? "continue" : "stop"];
+declare type IntersectTuples<A, B, V = IntersectTupleValues<Values<A>, Values<B>, IsOpen<A>, IsOpen<B>, OpenProps<A>, OpenProps<B>>, N = HasNeverValue<V>, O = Intersect<OpenProps<A>, OpenProps<B>>> = N extends true ? Never : Tuple<V, O extends Never ? false : And<IsOpen<A>, IsOpen<B>>, O>;
+declare type IntersectTupleValues<V1, V2, O1, O2, P1, P2, R extends any[] = []> = {
+    stop: Reverse<R>;
+    continue1: IntersectTupleValues<Tail<V1>, V2, O1, O2, P1, P2, Prepend<O2 extends true ? Intersect<Head<V1>, P2> : Never, R>>;
+    continue2: IntersectTupleValues<V1, Tail<V2>, O1, O2, P1, P2, Prepend<O1 extends true ? Intersect<Head<V2>, P1> : Never, R>>;
+    continueBoth: IntersectTupleValues<Tail<V1>, Tail<V2>, O1, O2, P1, P2, Prepend<Intersect<Head<V1>, Head<V2>>, R>>;
+}[V1 extends [any, ...any[]] ? V2 extends [any, ...any[]] ? "continueBoth" : "continue1" : V2 extends [any, ...any[]] ? "continue2" : "stop"];
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/intersection/union.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/intersection/union.d.ts
@ -0,0 +1,24 @@
+import { Get } from "../../utils";
+import { MetaType, Never, Error } from "..";
+import { Union, Values } from "../union";
+import { ClearIntersections, Intersect } from "./index";
+export declare type ClearUnionIntersections<A> = Union<ClearUnionValuesIntersections<Values<A>>>;
+declare type ClearUnionValuesIntersections<V> = V extends infer T ? ClearIntersections<T> : never;
+export declare type IntersectUnion<A, B> = {
+    any: A;
+    never: Never;
+    const: DistributeIntersection<A, B>;
+    enum: DistributeIntersection<A, B>;
+    primitive: DistributeIntersection<A, B>;
+    array: DistributeIntersection<A, B>;
+    tuple: DistributeIntersection<A, B>;
+    object: DistributeIntersection<A, B>;
+    union: DistributeIntersection<A, B>;
+    exclusion: DistributeIntersection<A, B>;
+    intersection: Error<"Cannot intersect intersection">;
+    error: B;
+    errorTypeProperty: Error<"Missing type property">;
+}[Get<B, "type"> extends MetaType ? Get<B, "type"> : "errorTypeProperty"];
+export declare type DistributeIntersection<A, B> = Union<RecurseOnUnion<Values<A>, B>>;
+declare type RecurseOnUnion<V, B> = V extends infer T ? Intersect<T, B> : never;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/never.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/never.d.ts
@ -0,0 +1,5 @@
+export declare type NeverType = "never";
+export declare type Never = {
+    type: NeverType;
+};
+export declare type ResolveNever = never;
--- a/node_modules/json-schema-to-ts/lib/meta-types/object.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/object.d.ts
@ -0,0 +1,34 @@
+import { A, B } from "ts-toolbelt";
+import { DoesExtend, Or, Not, Get, DeepMergeUnsafe } from "../utils";
+import { Resolve, Any, Never } from ".";
+import { IsRepresentable } from "./utils";
+export declare type ObjectType = "object";
+export declare type Object<V = {}, R = never, O = true, P = Any> = {
+    type: ObjectType;
+    values: V;
+    required: R;
+    isOpen: O;
+    openProps: P;
+};
+export declare type Values<O> = Get<O, "values">;
+export declare type Value<O, K> = K extends keyof Values<O> ? Values<O>[K] : IsOpen<O> extends true ? OpenProps<O> : Never;
+export declare type Required<O> = Get<O, "required"> extends string ? Get<O, "required"> : never;
+export declare type IsOpen<O> = Get<O, "isOpen">;
+export declare type OpenProps<O> = Get<O, "openProps">;
+declare type IsEmpty<O> = DoesExtend<Extract<keyof Values<O>, keyof Values<O>>, never>;
+export declare type ResolveObject<O> = IsObjectValid<O> extends true ? ResolveValidObject<O> : never;
+declare type IsObjectValid<O> = IsOpen<O> extends false ? Required<O> extends keyof Values<O> ? true : false : true;
+declare type ResolveValidObject<O> = DeepMergeUnsafe<IsOpen<O> extends true ? IsEmpty<O> extends true ? {
+    [key: string]: Resolve<Get<O, "openProps">>;
+} : {
+    [key: string]: Resolve<Any>;
+} : {}, DeepMergeUnsafe<{
+    [key in Exclude<keyof Values<O>, Required<O>>]?: Resolve<Values<O>[key]>;
+}, {
+    [key in Required<O>]: key extends keyof Values<O> ? Resolve<Values<O>[key]> : Resolve<Any>;
+}>>;
+declare type IsObjectValueRepresentable<O, K> = K extends keyof Values<O> ? IsRepresentable<Values<O>[K]> : IsOpen<O> extends true ? IsRepresentable<OpenProps<O>> : false;
+export declare type IsObjectRepresentable<O> = Or<DoesExtend<A.Equals<Required<O>, never>, B.True>, Not<DoesExtend<false, {
+    [key in Required<O>]: IsObjectValueRepresentable<O, key>;
+}[Required<O>]>>>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/primitive.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/primitive.d.ts
@ -0,0 +1,8 @@
+import { Get } from "../utils";
+export declare type PrimitiveType = "primitive";
+export declare type Primitive<L> = {
+    type: PrimitiveType;
+    value: L;
+};
+export declare type Value<L> = Get<L, "value">;
+export declare type ResolvePrimitive<T> = Get<T, "value">;
--- a/node_modules/json-schema-to-ts/lib/meta-types/tuple.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/tuple.d.ts
@ -0,0 +1,24 @@
+import { Get, Head, Tail, Prepend, Concat, Reverse } from "../utils";
+import { Resolve, Any } from ".";
+import { IsRepresentable } from "./utils";
+export declare type TupleType = "tuple";
+export declare type Tuple<V, O = true, P = Any> = {
+    type: TupleType;
+    values: V;
+    isOpen: O;
+    openProps: P;
+};
+export declare type Values<T> = Get<T, "values">;
+export declare type IsOpen<T> = Get<T, "isOpen">;
+export declare type OpenProps<T> = Get<T, "openProps">;
+export declare type ResolveTuple<T> = IsOpen<T> extends true ? Concat<RecurseOnTuple<Values<T>>, [...Resolve<OpenProps<T>>[]]> : RecurseOnTuple<Values<T>>;
+declare type RecurseOnTuple<V, R extends any[] = []> = {
+    stop: Reverse<R>;
+    continue: V extends any[] ? RecurseOnTuple<Tail<V>, Prepend<Resolve<Head<V>>, R>> : never;
+}[V extends [any, ...any[]] ? "continue" : "stop"];
+export declare type IsTupleRepresentable<T> = AreAllTupleValuesRepresentable<Values<T>>;
+declare type AreAllTupleValuesRepresentable<V> = {
+    stop: true;
+    continue: V extends any[] ? IsRepresentable<Head<V>> extends false ? false : AreAllTupleValuesRepresentable<Tail<V>> : never;
+}[V extends [any, ...any[]] ? "continue" : "stop"];
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/union.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/union.d.ts
@ -0,0 +1,14 @@
+import { DoesExtend, Get } from "../utils";
+import { Resolve } from ".";
+import { IsRepresentable } from "./utils";
+export declare type UnionType = "union";
+export declare type Union<V> = {
+    type: UnionType;
+    values: V;
+};
+export declare type Values<U> = Get<U, "values">;
+export declare type ResolveUnion<U> = RecurseOnUnion<Values<U>>;
+declare type RecurseOnUnion<V> = V extends infer T ? Resolve<T> : never;
+export declare type IsUnionRepresentable<U> = DoesExtend<true, AreUnionValuesRepresentable<Values<U>>>;
+declare type AreUnionValuesRepresentable<V> = V extends infer T ? IsRepresentable<T> : never;
+export {};
--- a/node_modules/json-schema-to-ts/lib/meta-types/utils.d.ts
+++ b/node_modules/json-schema-to-ts/lib/meta-types/utils.d.ts
@ -0,0 +1,23 @@
+import { Get } from "../utils";
+import { MetaType } from ".";
+import { IsEnumRepresentable } from "./enum";
+import { IsTupleRepresentable } from "./tuple";
+import { IsObjectRepresentable } from "./object";
+import { IsUnionRepresentable } from "./union";
+import { IsIntersectionRepresentable } from "./intersection";
+import { IsExclusionRepresentable } from "./exclusion";
+export declare type IsRepresentable<A> = {
+    any: true;
+    never: false;
+    const: true;
+    enum: IsEnumRepresentable<A>;
+    primitive: true;
+    array: true;
+    tuple: IsTupleRepresentable<A>;
+    object: IsObjectRepresentable<A>;
+    union: IsUnionRepresentable<A>;
+    intersection: IsIntersectionRepresentable<A>;
+    exclusion: IsExclusionRepresentable<A>;
+    error: false;
+    errorMissingType: false;
+}[Get<A, "type"> extends MetaType ? Get<A, "type"> : "errorMissingType"];
--- a/node_modules/json-schema-to-ts/lib/parse-schema/allOf.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/allOf.d.ts
@ -0,0 +1,10 @@
+import { Any, Intersection } from "../meta-types";
+import { Tail, Head, Get, HasKeyIn } from "../utils";
+import { ParseSchema } from ".";
+import { MergeSubSchema } from "./utils";
+export declare type ParseAllOfSchema<S> = RecurseOnAllOfSchema<Get<S, "allOf">, S, HasKeyIn<S, "enum" | "const" | "type" | "anyOf" | "oneOf"> extends true ? ParseSchema<Omit<S, "allOf">> : Any>;
+declare type RecurseOnAllOfSchema<V, S, R> = {
+    stop: R;
+    continue: V extends any[] ? RecurseOnAllOfSchema<Tail<V>, S, Intersection<ParseSchema<MergeSubSchema<Omit<S, "allOf">, Head<V>>>, R>> : never;
+}[V extends [any, ...any[]] ? "continue" : "stop"];
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/anyOf.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/anyOf.d.ts
@ -0,0 +1,10 @@
+import { Intersection, Union } from "../meta-types";
+import { Tail, Head, Get, HasKeyIn, Merge } from "../utils";
+import { ParseSchema } from ".";
+import { MergeSubSchema, RemoveInvalidAdditionalItems } from "./utils";
+export declare type ParseAnyOfSchema<S> = Union<RecurseOnAnyOfSchema<Get<S, "anyOf">, S>>;
+declare type RecurseOnAnyOfSchema<S, P, R = never> = {
+    stop: R;
+    continue: S extends any[] ? RecurseOnAnyOfSchema<Tail<S>, P, R | (HasKeyIn<P, "enum" | "const" | "type"> extends true ? Intersection<ParseSchema<Omit<P, "anyOf">>, ParseSchema<MergeSubSchema<Omit<P, "anyOf">, Head<S>>>> : ParseSchema<Merge<Omit<P, "anyOf">, RemoveInvalidAdditionalItems<Head<S>>>>)> : never;
+}[S extends [any, ...any[]] ? "continue" : "stop"];
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/array.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/array.d.ts
@ -0,0 +1,24 @@
+import { Arr, Tuple, Union, Error } from "../meta-types";
+import { Head, Tail, Reverse, DoesExtend, Get, Prepend, IsObject } from "../utils";
+import { ParseSchema } from ".";
+export declare type ParseArrSchema<S> = "items" extends keyof S ? IsObject<S["items"]> extends true ? Arr<ParseSchema<S["items"]>> : S["items"] extends any[] ? Union<FromTreeTuple<ParseTuple<S["items"]>, S>> : Error<'Invalid value in "items" property'> : Arr;
+export declare type ParseTuple<S, R extends any[] = []> = {
+    stop: R;
+    continue: S extends any[] ? ParseTuple<Tail<S>, Prepend<ParseSchema<Head<S>>, R>> : never;
+}[S extends [any, ...any[]] ? "continue" : "stop"];
+declare type FromTreeTuple<T, S> = T extends any[] ? ApplyAdditionalItems<ApplyBoundaries<T, "minItems" extends keyof S ? S["minItems"] : 0, "maxItems" extends keyof S ? S["maxItems"] : undefined>, "additionalItems" extends keyof S ? S["additionalItems"] : true> : never;
+declare type ApplyBoundaries<T extends any[], Min, Max, R = never, HasMin extends boolean = false, HasMax extends boolean = false, C = T> = {
+    stop: {
+        result: Max extends undefined ? R | Tuple<Reverse<T>, false> : HasMax extends true ? R | Tuple<Reverse<T>, false> : Max extends T["length"] ? Tuple<Reverse<T>, false> : IsLongerThan<Tail<T>, Max> extends true ? never : R | Tuple<Reverse<T>, false>;
+        hasEncounteredMin: DoesExtend<Min, T["length"]>;
+        hasEncounteredMax: HasMax extends true ? true : Max extends T["length"] ? true : IsLongerThan<Tail<T>, Max>;
+        completeTuple: C;
+    };
+    continue: ApplyBoundaries<Tail<T>, Min, Max, T["length"] extends Max ? Tuple<Reverse<T>, false> : R | Tuple<Reverse<T>, false>, HasMin extends true ? true : DoesExtend<Min, T["length"]>, HasMax extends true ? true : DoesExtend<Max, T["length"]>, C>;
+}[Min extends T["length"] ? "stop" : T extends [any, ...any[]] ? "continue" : "stop"];
+declare type IsLongerThan<T extends any[], N, R = false> = {
+    continue: T["length"] extends N ? true : IsLongerThan<Tail<T>, N>;
+    stop: T["length"] extends N ? true : R;
+}[T extends [any, ...any[]] ? "continue" : "stop"];
+declare type ApplyAdditionalItems<R, A> = Get<R, "hasEncounteredMax"> extends true ? Get<R, "hasEncounteredMin"> extends true ? Get<R, "result"> : Error<'"minItems" property is lower than "maxItems"'> : A extends false ? Get<R, "hasEncounteredMin"> extends true ? Get<R, "result"> : Error<'"minItems" property is higher than allowed number of items'> : A extends true ? Get<R, "hasEncounteredMin"> extends true ? Get<R, "result"> | Tuple<Reverse<Get<R, "completeTuple">>> : Tuple<Reverse<Get<R, "completeTuple">>> : IsObject<A> extends true ? Get<R, "hasEncounteredMin"> extends true ? Get<R, "result"> | Tuple<Reverse<Get<R, "completeTuple">>, true, ParseSchema<A>> : Tuple<Reverse<Get<R, "completeTuple">>, true, ParseSchema<A>> : Error<'Invalid value in "additionalItems" property'>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/const.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/const.d.ts
@ -0,0 +1,4 @@
+import { Const, Intersection } from "../meta-types";
+import { Get, HasKeyIn } from "../utils";
+import { ParseSchema } from ".";
+export declare type ParseConstSchema<S> = HasKeyIn<S, "type"> extends true ? Intersection<Const<Get<S, "const">>, ParseSchema<Omit<S, "const">>> : Const<Get<S, "const">>;
--- a/node_modules/json-schema-to-ts/lib/parse-schema/enum.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/enum.d.ts
@ -0,0 +1,4 @@
+import { Enum, Intersection } from "../meta-types";
+import { DeepGet, HasKeyIn } from "../utils";
+import { ParseSchema } from ".";
+export declare type ParseEnumSchema<S> = HasKeyIn<S, "const" | "type"> extends true ? Intersection<Enum<DeepGet<S, ["enum", number]>>, ParseSchema<Omit<S, "enum">>> : Enum<DeepGet<S, ["enum", number]>>;
--- a/node_modules/json-schema-to-ts/lib/parse-schema/ifThenElse.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/ifThenElse.d.ts
@ -0,0 +1,7 @@
+import { ParseSchema } from "../parse-schema";
+import { Intersection, Union, Exclusion } from "../meta-types";
+import { HasKeyIn } from "../utils";
+import { MergeSubSchema } from "./utils";
+export declare type ParseIfThenElseSchema<S, R = Omit<S, "if" | "then" | "else">> = HasKeyIn<S, "enum" | "const" | "type" | "anyOf" | "oneOf" | "allOf" | "not"> extends true ? Intersection<ApplyIfThenElse<S, R>, ParseSchema<R>> : ApplyIfThenElse<S, R>;
+declare type ApplyIfThenElse<S, R, I = "if" extends keyof S ? MergeSubSchema<R, S["if"]> : never> = Union<("then" extends keyof S ? Intersection<ParseSchema<I>, ParseSchema<MergeSubSchema<R, S["then"]>>> : ParseSchema<I>) | Exclusion<"else" extends keyof S ? ParseSchema<MergeSubSchema<R, S["else"]>> : ParseSchema<R>, ParseSchema<I>>>;
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/index.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/index.d.ts
@ -0,0 +1,31 @@
+import { Primitive, Any, Never } from "../meta-types";
+import { ParseConstSchema } from "./const";
+import { ParseEnumSchema } from "./enum";
+import { ParseMixedSchema } from "./mixed";
+import { ParseArrSchema } from "./array";
+import { ParseObjectSchema } from "./object";
+import { ParseAnyOfSchema } from "./anyOf";
+import { ParseOneOfSchema } from "./oneOf";
+import { ParseAllOfSchema } from "./allOf";
+import { ParseNotSchema } from "./not";
+import { ParseIfThenElseSchema } from "./ifThenElse";
+export declare type ParseSchema<S> = {
+    any: Any;
+    never: Never;
+    null: Primitive<null>;
+    boolean: Primitive<boolean>;
+    number: Primitive<number>;
+    string: Primitive<string>;
+    mixed: ParseMixedSchema<S>;
+    object: ParseObjectSchema<S>;
+    array: ParseArrSchema<S>;
+    const: ParseConstSchema<S>;
+    enum: ParseEnumSchema<S>;
+    anyOf: ParseAnyOfSchema<S>;
+    oneOf: ParseOneOfSchema<S>;
+    allOf: ParseAllOfSchema<S>;
+    not: ParseNotSchema<S>;
+    ifThenElse: ParseIfThenElseSchema<S>;
+}[InferSchemaType<S>];
+declare type InferSchemaType<S> = S extends true | string ? "any" : S extends false ? "never" : "if" extends keyof S ? "ifThenElse" : "not" extends keyof S ? "not" : "allOf" extends keyof S ? "allOf" : "oneOf" extends keyof S ? "oneOf" : "anyOf" extends keyof S ? "anyOf" : "enum" extends keyof S ? "enum" : "const" extends keyof S ? "const" : "type" extends keyof S ? S["type"] extends any[] ? "mixed" : S["type"] extends "null" ? "null" : S["type"] extends "boolean" ? "boolean" : S["type"] extends "integer" | "number" ? "number" : S["type"] extends "string" ? "string" : S["type"] extends "object" ? "object" : S["type"] extends "array" ? "array" : "never" : "any";
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/mixed.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/mixed.d.ts
@ -0,0 +1,11 @@
+import { Union } from "../meta-types";
+import { Get, Head, Tail, DeepMergeUnsafe } from "../utils";
+import { ParseSchema } from ".";
+export declare type ParseMixedSchema<S> = Union<RecurseOnMixedSchema<Get<S, "type">, S>>;
+declare type RecurseOnMixedSchema<T, S, R = never> = {
+    stop: R;
+    continue: T extends any[] ? RecurseOnMixedSchema<Tail<T>, S, R | ParseSchema<DeepMergeUnsafe<S, {
+        type: Head<T>;
+    }>>> : never;
+}[T extends [any, ...any[]] ? "continue" : "stop"];
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/not.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/not.d.ts
@ -0,0 +1,8 @@
+import { Any, Primitive, Arr, Object, Union, Exclusion } from "../meta-types";
+import { IsRepresentable } from "../meta-types/utils";
+import { Get, HasKeyIn } from "../utils";
+import { ParseSchema } from ".";
+import { MergeSubSchema } from "./utils";
+declare type AllTypes = Union<Primitive<null> | Primitive<boolean> | Primitive<number> | Primitive<string> | Arr<Any> | Object>;
+export declare type ParseNotSchema<S, P = ParseSchema<Omit<S, "not">>, E = Exclusion<HasKeyIn<S, "enum" | "const" | "type" | "anyOf" | "oneOf" | "allOf"> extends true ? P : AllTypes, ParseSchema<MergeSubSchema<Omit<S, "not">, Get<S, "not">>>>> = IsRepresentable<E> extends true ? E : P;
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/object.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/object.d.ts
@ -0,0 +1,23 @@
+import { Object, Any, Never, Union, Error } from "../meta-types";
+import { IsObject } from "../utils";
+import { ParseSchema } from ".";
+export declare type ParseObjectSchema<S> = "properties" extends keyof S ? Object<{
+    [key in keyof S["properties"]]: ParseSchema<S["properties"][key]>;
+}, GetRequired<S>, "additionalProperties" extends keyof S ? S["additionalProperties"] extends false ? false : true : true, GetOpenProps<S>> : Object<{}, GetRequired<S>, true, GetOpenProps<S>>;
+declare type GetRequired<S> = S extends {
+    required: ReadonlyArray<string>;
+} ? S["required"][number] : never;
+declare type GetOpenProps<S> = "additionalProperties" extends keyof S ? "patternProperties" extends keyof S ? AdditionalAndPatternProps<S["additionalProperties"], S["patternProperties"]> : AdditionalProps<S["additionalProperties"]> : "patternProperties" extends keyof S ? PatternProps<S["patternProperties"]> : Any;
+declare type AdditionalProps<A> = A extends false ? Never : A extends true ? Any : IsObject<A> extends true ? ParseSchema<A> : Error<'Invalid value in "additionalProperties" property'>;
+declare type PatternProps<P> = {
+    type: "union";
+    values: {
+        [key in keyof P]: ParseSchema<P[key]>;
+    }[keyof P];
+};
+declare type AdditionalAndPatternProps<A, P> = A extends boolean ? Union<{
+    [key in keyof P]: ParseSchema<P[key]>;
+}[keyof P]> : IsObject<A> extends true ? Union<ParseSchema<A> | {
+    [key in keyof P]: ParseSchema<P[key]>;
+}[keyof P]> : never;
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/oneOf.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/oneOf.d.ts
@ -0,0 +1,10 @@
+import { Intersection, Union } from "../meta-types";
+import { Tail, Head, Get, HasKeyIn, Merge } from "../utils";
+import { ParseSchema } from ".";
+import { MergeSubSchema, RemoveInvalidAdditionalItems } from "./utils";
+export declare type ParseOneOfSchema<S> = Union<RecurseOnOneOfSchema<Get<S, "oneOf">, S>>;
+declare type RecurseOnOneOfSchema<S, P, R = never> = {
+    stop: R;
+    continue: S extends any[] ? RecurseOnOneOfSchema<Tail<S>, P, R | (HasKeyIn<P, "enum" | "const" | "type" | "anyOf"> extends true ? Intersection<ParseSchema<Omit<P, "oneOf">>, ParseSchema<MergeSubSchema<Omit<P, "oneOf">, Head<S>>>> : ParseSchema<Merge<Omit<P, "oneOf">, RemoveInvalidAdditionalItems<Head<S>>>>)> : never;
+}[S extends [any, ...any[]] ? "continue" : "stop"];
+export {};
--- a/node_modules/json-schema-to-ts/lib/parse-schema/utils.d.ts
+++ b/node_modules/json-schema-to-ts/lib/parse-schema/utils.d.ts
@ -0,0 +1,9 @@
+import { Merge } from "../utils";
+export declare type RemoveInvalidAdditionalItems<S> = "items" extends keyof S ? "additionalItems" extends keyof S ? S : Merge<S, {
+    additionalItems: true;
+}> : Omit<S, "additionalItems">;
+export declare type MergeSubSchema<P, C> = Merge<P, Merge<{
+    properties: {};
+    additionalProperties: true;
+    required: [];
+}, RemoveInvalidAdditionalItems<C>>>;
--- a/node_modules/json-schema-to-ts/lib/utils/and.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/and.d.ts
@ -0,0 +1,8 @@
+/**
+ * Return `true` if `A` and `B` extend `true`, `false` otherwise
+ *
+ * @param A Type
+ * @param B Type
+ * @return Boolean
+ */
+export declare type And<A, B> = A extends true ? B extends true ? true : false : false;
--- a/node_modules/json-schema-to-ts/lib/utils/concat.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/concat.d.ts
@ -0,0 +1,23 @@
+import { Head } from "./head";
+import { Tail } from "./tail";
+import { Prepend } from "./prepend";
+import { Reverse } from "./reverse";
+/**
+ * Concatenate the reverse of tuple `A` to tuple `B`
+ *
+ * @param A Tuple
+ * @param B Tuple
+ * @return Tuple
+ */
+export declare type ConcatReversed<A, B extends any[]> = {
+    stop: B;
+    continue: ConcatReversed<Tail<A>, Prepend<Head<A>, B>>;
+}[A extends [any, ...any[]] ? "continue" : "stop"];
+/**
+ * Concatenate tuple `A` to tuple `B`
+ *
+ * @param A Tuple
+ * @param B Tuple
+ * @return Tuple
+ */
+export declare type Concat<A, B extends any[]> = A extends any[] ? ConcatReversed<Reverse<A>, B> : never;
--- a/node_modules/json-schema-to-ts/lib/utils/extends.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/extends.d.ts
@ -0,0 +1,24 @@
+/**
+ * Returns `true` if type `A` extends type `B`, `false` if not
+ *
+ * @param A Type
+ * @param B Type
+ * @return Boolean
+ */
+export declare type DoesExtend<A, B> = A extends B ? true : false;
+declare type ArrayKeys = keyof [];
+/**
+ * Returns `true` if type is object, `false` if not (excludes arrays)
+ *
+ * @param T Type
+ * @return Boolean
+ */
+export declare type IsObject<T> = T extends object ? ArrayKeys extends Extract<keyof T, ArrayKeys> ? false : true : false;
+/**
+ * Returns `true` if type is array, `false` if not (excludes objects)
+ *
+ * @param T Type
+ * @return Boolean
+ */
+export declare type IsArray<T> = T extends object ? ArrayKeys extends Extract<keyof T, ArrayKeys> ? true : false : false;
+export {};
--- a/node_modules/json-schema-to-ts/lib/utils/filter.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/filter.d.ts
@ -0,0 +1,17 @@
+import { Head } from "./head";
+import { Tail } from "./tail";
+import { Prepend } from "./prepend";
+import { Reverse } from "./reverse";
+/**
+ * Filters out the values of a tuple `T` that don't extend type `F`
+ *
+ * Preserves the tuple original order
+ *
+ * @param T Tuple
+ * @param F Type
+ * @return Tuple
+ */
+export declare type FilterExtending<T, F, R extends any[] = []> = {
+    continue: FilterExtending<Tail<T>, F, Head<T> extends F ? Prepend<Head<T>, R> : R>;
+    stop: Reverse<R>;
+}[T extends [any, ...any[]] ? "continue" : "stop"];
--- a/node_modules/json-schema-to-ts/lib/utils/get.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/get.d.ts
@ -0,0 +1,23 @@
+import { Head } from "./head";
+import { Tail } from "./tail";
+/**
+ * Returns the value at key `K` in object `O`, `F` if `K` misses from object
+ *
+ * @param O Object
+ * @param K Property key
+ * @param F _(optional:_ `never` _)_ Fallback type
+ * @return Type
+ */
+export declare type Get<O, K, F = never> = K extends keyof O ? O[K] : F;
+/**
+ * Returns the value at path `P` in object `O`, `F` if `P` misses from object
+ *
+ * @param O Object
+ * @param P Path
+ * @param F _(optional:_ `never` _)_ Fallback type
+ * @return Type
+ */
+export declare type DeepGet<O, P, F = never> = {
+    continue: Head<P> extends keyof O ? DeepGet<O[Head<P>], Tail<P>, F> : F;
+    stop: O;
+}[P extends [any, ...any[]] ? "continue" : "stop"];
--- a/node_modules/json-schema-to-ts/lib/utils/hasKeyIn.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/hasKeyIn.d.ts
@ -0,0 +1,8 @@
+/**
+ * Returns `true` if object `O` has a property key in `K` (union), `false` if not
+ *
+ * @param O Object
+ * @param K Union of property keys
+ * @return Type
+ */
+export declare type HasKeyIn<O, K> = Extract<keyof O, K> extends never ? false : true;
--- a/node_modules/json-schema-to-ts/lib/utils/head.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/head.d.ts
@ -0,0 +1,7 @@
+/**
+ * Returns the first element of a tuple `T`
+ *
+ * @param T Tuple
+ * @return Type
+ */
+export declare type Head<T> = T extends any[] ? T[0] : never;
--- a/node_modules/json-schema-to-ts/lib/utils/index.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/index.d.ts
@ -0,0 +1,19 @@
+export { And } from "./and";
+export { ConcatReversed, Concat } from "./concat";
+export { DoesExtend, IsObject, IsArray } from "./extends";
+export { FilterExtending } from "./filter";
+export { Get, DeepGet } from "./get";
+export { HasKeyIn } from "./hasKeyIn";
+export { Head } from "./head";
+export { DeepMergeSafe, DeepMergeUnsafe, Merge } from "./merge";
+export { Not } from "./not";
+export { OptionalProps } from "./optionalProps";
+export { Or } from "./or";
+export { Prepend } from "./prepend";
+export { Prettify } from "./prettify";
+export { DeepReadonly } from "./readonly";
+export { Replace } from "./replace";
+export { RequiredProps } from "./requiredProps";
+export { Reverse } from "./reverse";
+export { Tail } from "./tail";
+export { DeepWriteable } from "./writeable";
--- a/node_modules/json-schema-to-ts/lib/utils/merge.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/merge.d.ts
@ -0,0 +1,45 @@
+import { Concat } from "./concat";
+import { IsObject, IsArray } from "./extends";
+/**
+ * Recursively merge two types `A` and `B`:
+ * - Returns `B` if `A` and `B` are not both objects or arrays
+ * - Recursively merge `A` and `B` properties if both are objects
+ * - Concat `A` and `B` if both are arrays
+ *
+ * `DeepMergeUnsafe` preserves non-required properties, but can return `never` if TS infers that `A & B = never` (which can happen if some properties are incompatible)
+ *
+ * @param A Type
+ * @param B Type
+ * @return Type
+ */
+export declare type DeepMergeUnsafe<A, B> = IsObject<A> extends true ? IsObject<B> extends true ? {
+    [K in keyof (A & B)]: K extends keyof B ? K extends keyof A ? DeepMergeUnsafe<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never;
+} : B : IsArray<A> extends true ? IsArray<B> extends true ? B extends any[] ? Concat<A, B> : never : B : B;
+/**
+ * Recursively merge two types `A` and `B`:
+ * - Returns `B` if `A` and `B` are not both objects or arrays
+ * - Recursively merge `A` and `B` properties if both are objects
+ * - Concat `A` and `B` if both are arrays
+ *
+ * Contrary to `DeepMergeUnsafe`, `DeepMergeSafe` never returns `never`, but doesn't preserve non-required properties
+ *
+ * @param A Type
+ * @param B Type
+ * @return Type
+ */
+export declare type DeepMergeSafe<A, B> = IsObject<A> extends true ? IsObject<B> extends true ? {
+    [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? DeepMergeSafe<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never;
+} : B : IsArray<A> extends true ? IsArray<B> extends true ? B extends any[] ? Concat<A, B> : never : B : B;
+/**
+ * Merge two types `A` and `B`:
+ * - Returns `B` if `A` and `B` are not both objects
+ * - Merge `A` and `B` properties if both are objects
+ * - Merging is not recursive: Properties of `B` erase properties of `A`
+ *
+ * @param A Type
+ * @param B Type
+ * @return Type
+ */
+export declare type Merge<A, B> = IsObject<A> extends true ? IsObject<B> extends true ? {
+    [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
+} : B : B;
--- a/node_modules/json-schema-to-ts/lib/utils/not.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/not.d.ts
@ -0,0 +1,7 @@
+/**
+ * Return `true` if `A` extends `false`, `false` if `A` extends `true`, `never` otherwise
+ *
+ * @param A Type
+ * @return Boolean
+ */
+export declare type Not<A> = A extends false ? true : A extends true ? false : never;
--- a/node_modules/json-schema-to-ts/lib/utils/optionalProps.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/optionalProps.d.ts
@ -0,0 +1,9 @@
+/**
+ * Extract the names of an object's optional properties
+ *
+ * @param O Object
+ * @return Property names
+ */
+export declare type OptionalProps<O extends Record<string | number | symbol, unknown>> = Exclude<{
+    [K in keyof O]: undefined extends O[K] ? K : never;
+}[keyof O], undefined>;
--- a/node_modules/json-schema-to-ts/lib/utils/or.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/or.d.ts
@ -0,0 +1,8 @@
+/**
+ * Return `true` if `A` or `B` extend `true`, `false` otherwise
+ *
+ * @param A Type
+ * @param B Type
+ * @return Boolean
+ */
+export declare type Or<A, B> = A extends true ? true : B extends true ? true : false;
--- a/node_modules/json-schema-to-ts/lib/utils/prepend.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/prepend.d.ts
@ -0,0 +1,8 @@
+/**
+ * Inserts an element at the start of a tuple
+ *
+ * @param E Element (type)
+ * @param T Tuple
+ * @return Tuple
+ */
+export declare type Prepend<E, T extends any[]> = ((element: E, ...tail: T) => void) extends (...tuple: infer R) => void ? R : never;
--- a/node_modules/json-schema-to-ts/lib/utils/prettify.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/prettify.d.ts
@ -0,0 +1,10 @@
+import { IsObject } from "./extends";
+/**
+ * Resolves generic definitions in hover windows to human-friendly results
+ *
+ * @param T Type
+ * @return Type
+ */
+export declare type Prettify<T> = IsObject<T> extends true ? {
+    [K in keyof T]: K extends keyof T ? T[K] : never;
+} : T;
--- a/node_modules/json-schema-to-ts/lib/utils/readonly.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/readonly.d.ts
@ -0,0 +1,9 @@
+/**
+ * Recursively add the `readonly` directive from an object properties or tuple items
+ *
+ * @param O Object / Tuple
+ * @return Object / Tuple
+ */
+export declare type DeepReadonly<O> = O extends object ? {
+    readonly [K in keyof O]: DeepReadonly<O[K]>;
+} : O;
--- a/node_modules/json-schema-to-ts/lib/utils/replace.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/replace.d.ts
@ -0,0 +1,16 @@
+import { DeepMergeUnsafe } from "./merge";
+import { OptionalProps } from "./optionalProps";
+import { RequiredProps } from "./requiredProps";
+/**
+ * Set a specified value to an object property or properties
+ *
+ * @param O Object
+ * @param P Properties
+ * @param V Value (type)
+ * @return Object
+ */
+export declare type Replace<O extends Record<string | number | symbol, any>, P extends keyof O, V, Req extends keyof O = RequiredProps<O>, Opt extends keyof O = OptionalProps<O>> = DeepMergeUnsafe<DeepMergeUnsafe<Omit<O, P>, {
+    [key in P & Req]: V;
+}>, {
+    [key in P & Opt]?: V;
+}>;
--- a/node_modules/json-schema-to-ts/lib/utils/requiredProps.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/requiredProps.d.ts
@ -0,0 +1,9 @@
+/**
+ * Extract the names of an object's required properties
+ *
+ * @param O Object
+ * @return Property names
+ */
+export declare type RequiredProps<O extends Record<string | number | symbol, unknown>> = Exclude<{
+    [K in keyof O]: undefined extends O[K] ? never : K;
+}[keyof O], undefined>;
--- a/node_modules/json-schema-to-ts/lib/utils/reverse.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/reverse.d.ts
@ -0,0 +1,13 @@
+import { Head } from "./head";
+import { Tail } from "./tail";
+import { Prepend } from "./prepend";
+/**
+ * Reverses a tuple `T`
+ *
+ * @param T Tuple
+ * @return Tuple
+ */
+export declare type Reverse<T, R extends any[] = []> = {
+    stop: R;
+    continue: T extends any[] ? Reverse<Tail<T>, Prepend<Head<T>, R>> : never;
+}[T extends [any, ...any[]] ? "continue" : "stop"];
--- a/node_modules/json-schema-to-ts/lib/utils/tail.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/tail.d.ts
@ -0,0 +1,7 @@
+/**
+ * Remove the first element of a tuple
+ *
+ * @param T Tuple
+ * @return Tuple
+ */
+export declare type Tail<T> = T extends any[] ? ((...args: T) => void) extends (head: any, ...tail: infer R) => void ? R : T : never;
--- a/node_modules/json-schema-to-ts/lib/utils/writeable.d.ts
+++ b/node_modules/json-schema-to-ts/lib/utils/writeable.d.ts
@ -0,0 +1,9 @@
+/**
+ * Recursively remove the `readonly` directive from an object properties or tuple items
+ *
+ * @param O Object / Tuple
+ * @return Object / Tuple
+ */
+export declare type DeepWriteable<O> = O extends object ? {
+    -readonly [K in keyof O]: DeepWriteable<O[K]>;
+} : O;
--- a/node_modules/json-schema-to-ts/package.json
+++ b/node_modules/json-schema-to-ts/package.json
@ -0,0 +1,44 @@
+{
+  "name": "json-schema-to-ts",
+  "version": "1.6.4",
+  "description": "Infer typescript types from your JSON schemas!",
+  "main": "lib/index.d.ts",
+  "scripts": {
+    "release": "bash scripts/release.bash",
+    "test": "tsc --noEmit && jest --verbose"
+  },
+  "dependencies": {
+    "@types/json-schema": "^7.0.6",
+    "ts-toolbelt": "^6.15.5"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.10.4",
+    "@babel/preset-env": "^7.10.4",
+    "@babel/preset-typescript": "^7.10.4",
+    "@types/jest": "^26.0.4",
+    "ajv": "^6.12.6",
+    "babel-jest": "^26.1.0",
+    "jest": "^26.6.3",
+    "rollup": "^2.45.2",
+    "rollup-plugin-dts": "1.4.10",
+    "rollup-plugin-import-map": "^2.2.2",
+    "typescript": "^3.9.6"
+  },
+  "author": "Thomas Aribart",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ThomasAribart/json-schema-to-ts.git"
+  },
+  "keywords": [
+    "json",
+    "schema",
+    "typescript",
+    "type",
+    "ts"
+  ],
+  "bugs": {
+    "url": "https://github.com/ThomasAribart/json-schema-to-ts/issues"
+  },
+  "homepage": "https://github.com/ThomasAribart/json-schema-to-ts#readme"
+}
--- a/node_modules/json-schema-to-ts/rollup.config.js
+++ b/node_modules/json-schema-to-ts/rollup.config.js
@ -0,0 +1,27 @@
+import dts from "rollup-plugin-dts";
+import { rollupImportMapPlugin } from "rollup-plugin-import-map";
+import { basename } from 'path';
+import { dependencies } from "./package.json"
+
+// as it currently stands, all skypack plugins for rollup do not support scoped imports (e.g. @types/*)
+// nor do they support a ?dts query string suffix to the url, which is necessary for deno
+// import maps are a great substitute for such a plugin, and they offer more flexibility
+const importMap = {};
+for (const [dep, ver] of Object.entries(dependencies))
+    importMap[basename(dep)] = `https://cdn.skypack.dev/${dep}@${ver}?dts`;
+
+const config = [
+  {
+    input: "./src/index.ts",
+    output: [{ file: "./builds/deno/index.d.ts", format: "es" }],
+    plugins: [
+        rollupImportMapPlugin([{
+            imports: importMap,
+        }]),
+        dts(),
+    ],
+  },
+];
+
+export default config;
+
				`@ -0,0 +1 @@`
				`export { JSONSchema6DefinitionWithoutInterface } from "./jsonSchema6";`