@nocobase/plugin-mcp-server 2.1.0-alpha.18 → 2.1.0-alpha.20

package/dist/node_modules/openapi-mcp-generator/node_modules/ajv-draft-04/node_modules/ajv/lib/types/index.ts

@@ -1,244 +0,0 @@
-import * as URI from "uri-js"
-import type {CodeGen, Code, Name, ScopeValueSets, ValueScopeName} from "../compile/codegen"
-import type {SchemaEnv, SchemaCxt, SchemaObjCxt} from "../compile"
-import type {JSONType} from "../compile/rules"
-import type {KeywordCxt} from "../compile/validate"
-import type Ajv from "../core"
-
-interface _SchemaObject {
-  id?: string
-  $id?: string
-  $schema?: string
-  [x: string]: any // TODO
-}
-
-export interface SchemaObject extends _SchemaObject {
-  id?: string
-  $id?: string
-  $schema?: string
-  $async?: false
-  [x: string]: any // TODO
-}
-
-export interface AsyncSchema extends _SchemaObject {
-  $async: true
-}
-
-export type AnySchemaObject = SchemaObject | AsyncSchema
-
-export type Schema = SchemaObject | boolean
-
-export type AnySchema = Schema | AsyncSchema
-
-export type SchemaMap = {[Key in string]?: AnySchema}
-
-export interface SourceCode {
-  validateName: ValueScopeName
-  validateCode: string
-  scopeValues: ScopeValueSets
-  evaluated?: Code
-}
-
-export interface DataValidationCxt<T extends string | number = string | number> {
-  instancePath: string
-  parentData: {[K in T]: any} // object or array
-  parentDataProperty: T // string or number
-  rootData: Record<string, any> | any[]
-  dynamicAnchors: {[Ref in string]?: ValidateFunction}
-}
-
-export interface ValidateFunction<T = unknown> {
-  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-  (this: Ajv | any, data: any, dataCxt?: DataValidationCxt): data is T
-  errors?: null | ErrorObject[]
-  evaluated?: Evaluated
-  schema: AnySchema
-  schemaEnv: SchemaEnv
-  source?: SourceCode
-}
-
-export interface JTDParser<T = unknown> {
-  (json: string): T | undefined
-  message?: string
-  position?: number
-}
-
-export type EvaluatedProperties = {[K in string]?: true} | true
-
-export type EvaluatedItems = number | true
-
-export interface Evaluated {
-  // determined at compile time if staticProps/Items is true
-  props?: EvaluatedProperties
-  items?: EvaluatedItems
-  // whether props/items determined at compile time
-  dynamicProps: boolean
-  dynamicItems: boolean
-}
-
-export interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {
-  (...args: Parameters<ValidateFunction<T>>): Promise<T>
-  $async: true
-}
-
-export type AnyValidateFunction<T = any> = ValidateFunction<T> | AsyncValidateFunction<T>
-
-export interface ErrorObject<K extends string = string, P = Record<string, any>, S = unknown> {
-  keyword: K
-  instancePath: string
-  schemaPath: string
-  params: P
-  // Added to validation errors of "propertyNames" keyword schema
-  propertyName?: string
-  // Excluded if option `messages` set to false.
-  message?: string
-  // These are added with the `verbose` option.
-  schema?: S
-  parentSchema?: AnySchemaObject
-  data?: unknown
-}
-
-export type ErrorNoParams<K extends string, S = unknown> = ErrorObject<K, Record<string, never>, S>
-
-interface _KeywordDef {
-  keyword: string | string[]
-  type?: JSONType | JSONType[] // data types that keyword applies to
-  schemaType?: JSONType | JSONType[] // allowed type(s) of keyword value in the schema
-  allowUndefined?: boolean // used for keywords that can be invoked by other keywords, not being present in the schema
-  $data?: boolean // keyword supports [$data reference](../../docs/guide/combining-schemas.md#data-reference)
-  implements?: string[] // other schema keywords that this keyword implements
-  before?: string // keyword should be executed before this keyword (should be applicable to the same type)
-  post?: boolean // keyword should be executed after other keywords without post flag
-  metaSchema?: AnySchemaObject // meta-schema for keyword schema value - it is better to use schemaType where applicable
-  validateSchema?: AnyValidateFunction // compiled keyword metaSchema - should not be passed
-  dependencies?: string[] // keywords that must be present in the same schema
-  error?: KeywordErrorDefinition
-  $dataError?: KeywordErrorDefinition
-}
-
-export interface CodeKeywordDefinition extends _KeywordDef {
-  code: (cxt: KeywordCxt, ruleType?: string) => void
-  trackErrors?: boolean
-}
-
-export type MacroKeywordFunc = (
-  schema: any,
-  parentSchema: AnySchemaObject,
-  it: SchemaCxt
-) => AnySchema
-
-export type CompileKeywordFunc = (
-  schema: any,
-  parentSchema: AnySchemaObject,
-  it: SchemaObjCxt
-) => DataValidateFunction
-
-export interface DataValidateFunction {
-  (...args: Parameters<ValidateFunction>): boolean | Promise<any>
-  errors?: Partial<ErrorObject>[]
-}
-
-export interface SchemaValidateFunction {
-  (
-    schema: any,
-    data: any,
-    parentSchema?: AnySchemaObject,
-    dataCxt?: DataValidationCxt
-  ): boolean | Promise<any>
-  errors?: Partial<ErrorObject>[]
-}
-
-export interface FuncKeywordDefinition extends _KeywordDef {
-  validate?: SchemaValidateFunction | DataValidateFunction
-  compile?: CompileKeywordFunc
-  // schema: false makes validate not to expect schema (DataValidateFunction)
-  schema?: boolean // requires "validate"
-  modifying?: boolean
-  async?: boolean
-  valid?: boolean
-  errors?: boolean | "full"
-}
-
-export interface MacroKeywordDefinition extends FuncKeywordDefinition {
-  macro: MacroKeywordFunc
-}
-
-export type KeywordDefinition =
-  | CodeKeywordDefinition
-  | FuncKeywordDefinition
-  | MacroKeywordDefinition
-
-export type AddedKeywordDefinition = KeywordDefinition & {
-  type: JSONType[]
-  schemaType: JSONType[]
-}
-
-export interface KeywordErrorDefinition {
-  message: string | Code | ((cxt: KeywordErrorCxt) => string | Code)
-  params?: Code | ((cxt: KeywordErrorCxt) => Code)
-}
-
-export type Vocabulary = (KeywordDefinition | string)[]
-
-export interface KeywordErrorCxt {
-  gen: CodeGen
-  keyword: string
-  data: Name
-  $data?: string | false
-  schema: any // TODO
-  parentSchema?: AnySchemaObject
-  schemaCode: Code | number | boolean
-  schemaValue: Code | number | boolean
-  schemaType?: JSONType[]
-  errsCount?: Name
-  params: KeywordCxtParams
-  it: SchemaCxt
-}
-
-export type KeywordCxtParams = {[P in string]?: Code | string | number}
-
-export type FormatValidator<T extends string | number> = (data: T) => boolean
-
-export type FormatCompare<T extends string | number> = (data1: T, data2: T) => number | undefined
-
-export type AsyncFormatValidator<T extends string | number> = (data: T) => Promise<boolean>
-
-export interface FormatDefinition<T extends string | number> {
-  type?: T extends string ? "string" | undefined : "number"
-  validate: FormatValidator<T> | (T extends string ? string | RegExp : never)
-  async?: false | undefined
-  compare?: FormatCompare<T>
-}
-
-export interface AsyncFormatDefinition<T extends string | number> {
-  type?: T extends string ? "string" | undefined : "number"
-  validate: AsyncFormatValidator<T>
-  async: true
-  compare?: FormatCompare<T>
-}
-
-export type AddedFormat =
-  | true
-  | RegExp
-  | FormatValidator<string>
-  | FormatDefinition<string>
-  | FormatDefinition<number>
-  | AsyncFormatDefinition<string>
-  | AsyncFormatDefinition<number>
-
-export type Format = AddedFormat | string
-
-export interface RegExpEngine {
-  (pattern: string, u: string): RegExpLike
-  code: string
-}
-
-export interface RegExpLike {
-  test: (s: string) => boolean
-}
-
-export interface UriResolver {
-  parse(uri: string): URI.URIComponents
-  resolve(base: string, path: string): string
-  serialize(component: URI.URIComponents): string
-}

package/dist/node_modules/openapi-mcp-generator/node_modules/ajv-draft-04/node_modules/ajv/lib/types/json-schema.ts

@@ -1,187 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-interface */
-type StrictNullChecksWrapper<Name extends string, Type> = undefined extends null
-  ? `strictNullChecks must be true in tsconfig to use ${Name}`
-  : Type
-
-type UnionToIntersection<U> = (U extends any ? (_: U) => void : never) extends (_: infer I) => void
-  ? I
-  : never
-
-export type SomeJSONSchema = UncheckedJSONSchemaType<Known, true>
-
-type UncheckedPartialSchema<T> = Partial<UncheckedJSONSchemaType<T, true>>
-
-export type PartialSchema<T> = StrictNullChecksWrapper<"PartialSchema", UncheckedPartialSchema<T>>
-
-type JSONType<T extends string, IsPartial extends boolean> = IsPartial extends true
-  ? T | undefined
-  : T
-
-interface NumberKeywords {
-  minimum?: number
-  maximum?: number
-  exclusiveMinimum?: number
-  exclusiveMaximum?: number
-  multipleOf?: number
-  format?: string
-}
-
-interface StringKeywords {
-  minLength?: number
-  maxLength?: number
-  pattern?: string
-  format?: string
-}
-
-type UncheckedJSONSchemaType<T, IsPartial extends boolean> = (
-  | // these two unions allow arbitrary unions of types
-  {
-      anyOf: readonly UncheckedJSONSchemaType<T, IsPartial>[]
-    }
-  | {
-      oneOf: readonly UncheckedJSONSchemaType<T, IsPartial>[]
-    }
-  // this union allows for { type: (primitive)[] } style schemas
-  | ({
-      type: readonly (T extends number
-        ? JSONType<"number" | "integer", IsPartial>
-        : T extends string
-        ? JSONType<"string", IsPartial>
-        : T extends boolean
-        ? JSONType<"boolean", IsPartial>
-        : never)[]
-    } & UnionToIntersection<
-      T extends number
-        ? NumberKeywords
-        : T extends string
-        ? StringKeywords
-        : T extends boolean
-        ? // eslint-disable-next-line @typescript-eslint/ban-types
-          {}
-        : never
-    >)
-  // this covers "normal" types; it's last so typescript looks to it first for errors
-  | ((T extends number
-      ? {
-          type: JSONType<"number" | "integer", IsPartial>
-        } & NumberKeywords
-      : T extends string
-      ? {
-          type: JSONType<"string", IsPartial>
-        } & StringKeywords
-      : T extends boolean
-      ? {
-          type: JSONType<"boolean", IsPartial>
-        }
-      : T extends readonly [any, ...any[]]
-      ? {
-          // JSON AnySchema for tuple
-          type: JSONType<"array", IsPartial>
-          items: {
-            readonly [K in keyof T]-?: UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>
-          } & {length: T["length"]}
-          minItems: T["length"]
-        } & ({maxItems: T["length"]} | {additionalItems: false})
-      : T extends readonly any[]
-      ? {
-          type: JSONType<"array", IsPartial>
-          items: UncheckedJSONSchemaType<T[0], false>
-          contains?: UncheckedPartialSchema<T[0]>
-          minItems?: number
-          maxItems?: number
-          minContains?: number
-          maxContains?: number
-          uniqueItems?: true
-          additionalItems?: never
-        }
-      : T extends Record<string, any>
-      ? {
-          // JSON AnySchema for records and dictionaries
-          // "required" is not optional because it is often forgotten
-          // "properties" are optional for more concise dictionary schemas
-          // "patternProperties" and can be only used with interfaces that have string index
-          type: JSONType<"object", IsPartial>
-          additionalProperties?: boolean | UncheckedJSONSchemaType<T[string], false>
-          unevaluatedProperties?: boolean | UncheckedJSONSchemaType<T[string], false>
-          properties?: IsPartial extends true
-            ? Partial<UncheckedPropertiesSchema<T>>
-            : UncheckedPropertiesSchema<T>
-          patternProperties?: Record<string, UncheckedJSONSchemaType<T[string], false>>
-          propertyNames?: Omit<UncheckedJSONSchemaType<string, false>, "type"> & {type?: "string"}
-          dependencies?: {[K in keyof T]?: Readonly<(keyof T)[]> | UncheckedPartialSchema<T>}
-          dependentRequired?: {[K in keyof T]?: Readonly<(keyof T)[]>}
-          dependentSchemas?: {[K in keyof T]?: UncheckedPartialSchema<T>}
-          minProperties?: number
-          maxProperties?: number
-        } & (IsPartial extends true // "required" is not necessary if it's a non-partial type with no required keys // are listed it only asserts that optional cannot be listed. // "required" type does not guarantee that all required properties
-          ? {required: Readonly<(keyof T)[]>}
-          : [UncheckedRequiredMembers<T>] extends [never]
-          ? {required?: Readonly<UncheckedRequiredMembers<T>[]>}
-          : {required: Readonly<UncheckedRequiredMembers<T>[]>})
-      : T extends null
-      ? {
-          type: JSONType<"null", IsPartial>
-          nullable: true
-        }
-      : never) & {
-      allOf?: Readonly<UncheckedPartialSchema<T>[]>
-      anyOf?: Readonly<UncheckedPartialSchema<T>[]>
-      oneOf?: Readonly<UncheckedPartialSchema<T>[]>
-      if?: UncheckedPartialSchema<T>
-      then?: UncheckedPartialSchema<T>
-      else?: UncheckedPartialSchema<T>
-      not?: UncheckedPartialSchema<T>
-    })
-) & {
-  [keyword: string]: any
-  $id?: string
-  $ref?: string
-  $defs?: Record<string, UncheckedJSONSchemaType<Known, true>>
-  definitions?: Record<string, UncheckedJSONSchemaType<Known, true>>
-}
-
-export type JSONSchemaType<T> = StrictNullChecksWrapper<
-  "JSONSchemaType",
-  UncheckedJSONSchemaType<T, false>
->
-
-type Known =
-  | {[key: string]: Known}
-  | [Known, ...Known[]]
-  | Known[]
-  | number
-  | string
-  | boolean
-  | null
-
-type UncheckedPropertiesSchema<T> = {
-  [K in keyof T]-?: (UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>) | {$ref: string}
-}
-
-export type PropertiesSchema<T> = StrictNullChecksWrapper<
-  "PropertiesSchema",
-  UncheckedPropertiesSchema<T>
->
-
-type UncheckedRequiredMembers<T> = {
-  [K in keyof T]-?: undefined extends T[K] ? never : K
-}[keyof T]
-
-export type RequiredMembers<T> = StrictNullChecksWrapper<
-  "RequiredMembers",
-  UncheckedRequiredMembers<T>
->
-
-type Nullable<T> = undefined extends T
-  ? {
-      nullable: true
-      const?: null // any non-null value would fail `const: null`, `null` would fail any other value in const
-      enum?: Readonly<(T | null)[]> // `null` must be explicitly included in "enum" for `null` to pass
-      default?: T | null
-    }
-  : {
-      nullable?: false
-      const?: T
-      enum?: Readonly<T[]>
-      default?: T
-    }

package/dist/node_modules/openapi-mcp-generator/node_modules/ajv-draft-04/node_modules/ajv/lib/types/jtd-schema.ts

@@ -1,273 +0,0 @@
-/** numeric strings */
-type NumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32"
-
-/** string strings */
-type StringType = "string" | "timestamp"
-
-/** Generic JTD Schema without inference of the represented type */
-export type SomeJTDSchemaType = (
-  | // ref
-  {ref: string}
-  // primitives
-  | {type: NumberType | StringType | "boolean"}
-  // enum
-  | {enum: string[]}
-  // elements
-  | {elements: SomeJTDSchemaType}
-  // values
-  | {values: SomeJTDSchemaType}
-  // properties
-  | {
-      properties: Record<string, SomeJTDSchemaType>
-      optionalProperties?: Record<string, SomeJTDSchemaType>
-      additionalProperties?: boolean
-    }
-  | {
-      properties?: Record<string, SomeJTDSchemaType>
-      optionalProperties: Record<string, SomeJTDSchemaType>
-      additionalProperties?: boolean
-    }
-  // discriminator
-  | {discriminator: string; mapping: Record<string, SomeJTDSchemaType>}
-  // empty
-  // NOTE see the end of
-  // https://github.com/typescript-eslint/typescript-eslint/issues/2063#issuecomment-675156492
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  | {}
-) & {
-  nullable?: boolean
-  metadata?: Record<string, unknown>
-  definitions?: Record<string, SomeJTDSchemaType>
-}
-
-/** required keys of an object, not undefined */
-type RequiredKeys<T> = {
-  [K in keyof T]-?: undefined extends T[K] ? never : K
-}[keyof T]
-
-/** optional or undifined-able keys of an object */
-type OptionalKeys<T> = {
-  [K in keyof T]-?: undefined extends T[K] ? K : never
-}[keyof T]
-
-/** type is true if T is a union type */
-type IsUnion_<T, U extends T = T> = false extends (
-  T extends unknown ? ([U] extends [T] ? false : true) : never
-)
-  ? false
-  : true
-type IsUnion<T> = IsUnion_<T>
-
-/** type is true if T is identically E */
-type TypeEquality<T, E> = [T] extends [E] ? ([E] extends [T] ? true : false) : false
-
-/** type is true if T or null is identically E or null*/
-type NullTypeEquality<T, E> = TypeEquality<T | null, E | null>
-
-/** gets only the string literals of a type or null if a type isn't a string literal */
-type EnumString<T> = [T] extends [never]
-  ? null
-  : T extends string
-  ? string extends T
-    ? null
-    : T
-  : null
-
-/** true if type is a union of string literals */
-type IsEnum<T> = null extends EnumString<T> ? false : true
-
-/** true only if all types are array types (not tuples) */
-// NOTE relies on the fact that tuples don't have an index at 0.5, but arrays
-// have an index at every number
-type IsElements<T> = false extends IsUnion<T>
-  ? [T] extends [readonly unknown[]]
-    ? undefined extends T[0.5]
-      ? false
-      : true
-    : false
-  : false
-
-/** true if the the type is a values type */
-type IsValues<T> = false extends IsUnion<T> ? TypeEquality<keyof T, string> : false
-
-/** true if type is a properties type and Union is false, or type is a discriminator type and Union is true */
-type IsRecord<T, Union extends boolean> = Union extends IsUnion<T>
-  ? null extends EnumString<keyof T>
-    ? false
-    : true
-  : false
-
-/** true if type represents an empty record */
-type IsEmptyRecord<T> = [T] extends [Record<string, never>]
-  ? [T] extends [never]
-    ? false
-    : true
-  : false
-
-/** actual schema */
-export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string, never>> = (
-  | // refs - where null wasn't specified, must match exactly
-  (null extends EnumString<keyof D>
-      ? never
-      :
-          | ({[K in keyof D]: [T] extends [D[K]] ? {ref: K} : never}[keyof D] & {nullable?: false})
-          // nulled refs - if ref is nullable and nullable is specified, then it can
-          // match either null or non-null definitions
-          | (null extends T
-              ? {
-                  [K in keyof D]: [Exclude<T, null>] extends [Exclude<D[K], null>]
-                    ? {ref: K}
-                    : never
-                }[keyof D] & {nullable: true}
-              : never))
-  // empty - empty schemas also treat nullable differently in that it's now fully ignored
-  | (unknown extends T ? {nullable?: boolean} : never)
-  // all other types // numbers - only accepts the type number
-  | ((true extends NullTypeEquality<T, number>
-      ? {type: NumberType}
-      : // booleans - accepts the type boolean
-      true extends NullTypeEquality<T, boolean>
-      ? {type: "boolean"}
-      : // strings - only accepts the type string
-      true extends NullTypeEquality<T, string>
-      ? {type: StringType}
-      : // strings - only accepts the type Date
-      true extends NullTypeEquality<T, Date>
-      ? {type: "timestamp"}
-      : // enums - only accepts union of string literals
-      // TODO we can't actually check that everything in the union was specified
-      true extends IsEnum<Exclude<T, null>>
-      ? {enum: EnumString<Exclude<T, null>>[]}
-      : // arrays - only accepts arrays, could be array of unions to be resolved later
-      true extends IsElements<Exclude<T, null>>
-      ? T extends readonly (infer E)[]
-        ? {
-            elements: JTDSchemaType<E, D>
-          }
-        : never
-      : // empty properties
-      true extends IsEmptyRecord<Exclude<T, null>>
-      ?
-          | {properties: Record<string, never>; optionalProperties?: Record<string, never>}
-          | {optionalProperties: Record<string, never>}
-      : // values
-      true extends IsValues<Exclude<T, null>>
-      ? T extends Record<string, infer V>
-        ? {
-            values: JTDSchemaType<V, D>
-          }
-        : never
-      : // properties
-      true extends IsRecord<Exclude<T, null>, false>
-      ? ([RequiredKeys<Exclude<T, null>>] extends [never]
-          ? {
-              properties?: Record<string, never>
-            }
-          : {
-              properties: {[K in RequiredKeys<T>]: JTDSchemaType<T[K], D>}
-            }) &
-          ([OptionalKeys<Exclude<T, null>>] extends [never]
-            ? {
-                optionalProperties?: Record<string, never>
-              }
-            : {
-                optionalProperties: {
-                  [K in OptionalKeys<T>]: JTDSchemaType<Exclude<T[K], undefined>, D>
-                }
-              }) & {
-            additionalProperties?: boolean
-          }
-      : // discriminator
-      true extends IsRecord<Exclude<T, null>, true>
-      ? {
-          [K in keyof Exclude<T, null>]-?: Exclude<T, null>[K] extends string
-            ? {
-                discriminator: K
-                mapping: {
-                  // TODO currently allows descriminator to be present in schema
-                  [M in Exclude<T, null>[K]]: JTDSchemaType<
-                    Omit<T extends Record<K, M> ? T : never, K>,
-                    D
-                  >
-                }
-              }
-            : never
-        }[keyof Exclude<T, null>]
-      : never) &
-      (null extends T
-        ? {
-            nullable: true
-          }
-        : {nullable?: false}))
-) & {
-  // extra properties
-  metadata?: Record<string, unknown>
-  // TODO these should only be allowed at the top level
-  definitions?: {[K in keyof D]: JTDSchemaType<D[K], D>}
-}
-
-type JTDDataDef<S, D extends Record<string, unknown>> =
-  | // ref
-  (S extends {ref: string}
-      ? D extends {[K in S["ref"]]: infer V}
-        ? JTDDataDef<V, D>
-        : never
-      : // type
-      S extends {type: NumberType}
-      ? number
-      : S extends {type: "boolean"}
-      ? boolean
-      : S extends {type: "string"}
-      ? string
-      : S extends {type: "timestamp"}
-      ? string | Date
-      : // enum
-      S extends {enum: readonly (infer E)[]}
-      ? string extends E
-        ? never
-        : [E] extends [string]
-        ? E
-        : never
-      : // elements
-      S extends {elements: infer E}
-      ? JTDDataDef<E, D>[]
-      : // properties
-      S extends {
-          properties: Record<string, unknown>
-          optionalProperties?: Record<string, unknown>
-          additionalProperties?: boolean
-        }
-      ? {-readonly [K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D>} & {
-          -readonly [K in keyof S["optionalProperties"]]+?: JTDDataDef<
-            S["optionalProperties"][K],
-            D
-          >
-        } & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown)
-      : S extends {
-          properties?: Record<string, unknown>
-          optionalProperties: Record<string, unknown>
-          additionalProperties?: boolean
-        }
-      ? {-readonly [K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D>} & {
-          -readonly [K in keyof S["optionalProperties"]]+?: JTDDataDef<
-            S["optionalProperties"][K],
-            D
-          >
-        } & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown)
-      : // values
-      S extends {values: infer V}
-      ? Record<string, JTDDataDef<V, D>>
-      : // discriminator
-      S extends {discriminator: infer M; mapping: Record<string, unknown>}
-      ? [M] extends [string]
-        ? {
-            [K in keyof S["mapping"]]: JTDDataDef<S["mapping"][K], D> & {[KM in M]: K}
-          }[keyof S["mapping"]]
-        : never
-      : // empty
-        unknown)
-  | (S extends {nullable: true} ? null : never)
-
-export type JTDDataType<S> = S extends {definitions: Record<string, unknown>}
-  ? JTDDataDef<S, S["definitions"]>
-  : JTDDataDef<S, Record<string, never>>