@nikovirtala/projen-constructs 0.2.1 → 0.2.3

package/node_modules/ajv/lib/types/index.ts

@@ -0,0 +1,244 @@
+import {URIComponent} from "fast-uri"
+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): URIComponent
+  resolve(base: string, path: string): string
+  serialize(component: URIComponent): string
+}

package/node_modules/ajv/lib/types/json-schema.ts

@@ -0,0 +1,187 @@
+/* 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/node_modules/ajv/lib/types/jtd-schema.ts

@@ -0,0 +1,273 @@
+/** 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>>