JSONSchema

Arrayable

t

type t<'item>

src/JSONSchema.res:6:3

tagged

type tagged<'item> = Single('item) | Array(array<'item>)

src/JSONSchema.res:7:3

array

let array: array<'item> => t<'item>

src/JSONSchema.res:9:3

single

let single: 'item => t<'item>

src/JSONSchema.res:10:3

isArray

let isArray: t<'item> => bool

src/JSONSchema.res:12:3

classify

let classify: t<'item> => tagged<'item>

src/JSONSchema.res:14:7

src/JSONSchema.res:5:8

typeName

type typeName = [
  | #array
  | #boolean
  | #integer
  | #null
  | #number
  | #object
  | #string
]

Primitive type
@see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1

src/JSONSchema.res:27:1

version

type version = string

Meta schema

Recommended values:

@see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5

src/JSONSchema.res:48:1

t

type t = {
  id?: string,
  ref?: string,
  schema?: version,
  defs?: dict<definition>,
  type_?: Arrayable.t<typeName>,
  enum?: array<JSON.t>,
  const?: JSON.t,
  multipleOf?: float,
  maximum?: float,
  exclusiveMaximum?: float,
  minimum?: float,
  exclusiveMinimum?: float,
  maxLength?: int,
  minLength?: int,
  pattern?: string,
  items?: Arrayable.t<definition>,
  additionalItems?: definition,
  maxItems?: int,
  minItems?: int,
  uniqueItems?: bool,
  contains?: t,
  maxProperties?: int,
  minProperties?: int,
  required?: array<string>,
  properties?: dict<definition>,
  patternProperties?: dict<definition>,
  additionalProperties?: definition,
  dependencies?: dict<dependency>,
  propertyNames?: definition,
  if_?: definition,
  then?: definition,
  else_?: definition,
  allOf?: array<definition>,
  anyOf?: array<definition>,
  oneOf?: array<definition>,
  not?: definition,
  format?: string,
  contentMediaType?: string,
  contentEncoding?: string,
  definitions?: dict<definition>,
  title?: string,
  description?: string,
  deprecated?: bool,
  nullable?: bool,
  default?: JSON.t,
  readOnly?: bool,
  writeOnly?: bool,
  examples?: array<JSON.t>,
}

JSON Schema v7
@see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01

src/JSONSchema.res:54:1

definition

@unboxed
type definition =
  | Schema(t)
  | @as(false) Never
  | @as(true) Any

src/JSONSchema.res:148:1

dependency

@unboxed
type dependency =
  | RequiredSchema(t)
  | RequiredProperties(array<string>)

src/JSONSchema.res:149:1

Mutable

readOnly

type readOnly = t

src/JSONSchema.res:152:3

t

type t = {
  mutable id?: string,
  mutable ref?: string,
  mutable schema?: version,
  mutable defs?: dict<definition>,
  mutable type_?: Arrayable.t<typeName>,
  mutable enum?: array<JSON.t>,
  mutable const?: JSON.t,
  mutable multipleOf?: float,
  mutable maximum?: float,
  mutable exclusiveMaximum?: float,
  mutable minimum?: float,
  mutable exclusiveMinimum?: float,
  mutable maxLength?: int,
  mutable minLength?: int,
  mutable pattern?: string,
  mutable items?: Arrayable.t<definition>,
  mutable additionalItems?: definition,
  mutable maxItems?: int,
  mutable minItems?: int,
  mutable uniqueItems?: bool,
  mutable contains?: t,
  mutable maxProperties?: int,
  mutable minProperties?: int,
  mutable required?: array<string>,
  mutable properties?: dict<definition>,
  mutable patternProperties?: dict<definition>,
  mutable additionalProperties?: definition,
  mutable dependencies?: dict<dependency>,
  mutable propertyNames?: definition,
  mutable if_?: definition,
  mutable then?: definition,
  mutable else_?: definition,
  mutable allOf?: array<definition>,
  mutable anyOf?: array<definition>,
  mutable oneOf?: array<definition>,
  mutable not?: definition,
  mutable format?: string,
  mutable contentMediaType?: string,
  mutable contentEncoding?: string,
  mutable definitions?: dict<definition>,
  mutable title?: string,
  mutable description?: string,
  mutable deprecated?: bool,
  mutable nullable?: bool,
  mutable default?: JSON.t,
  mutable readOnly?: bool,
  mutable writeOnly?: bool,
  mutable examples?: array<JSON.t>,
}

src/JSONSchema.res:153:3

definition

@unboxed
type definition =
  | Schema(t)
  | @as(false) Never
  | @as(true) Any

src/JSONSchema.res:247:3

dependency

@unboxed
type dependency =
  | RequiredSchema(t)
  | RequiredProperties(array<string>)

src/JSONSchema.res:248:3

fromReadOnly

let fromReadOnly: readOnly => t

src/JSONSchema.res:250:3

toReadOnly

let toReadOnly: t => readOnly

src/JSONSchema.res:251:3

mixin

let mixin: (t, readOnly) => unit

src/JSONSchema.res:253:3

src/JSONSchema.res:151:8