UNPKG

28.9 kBTypeScriptView Raw
1// Type definitions for json-schema 4.0, 6.0 and 7.0
2// Project: https://github.com/kriszyp/json-schema
3// Definitions by: Boris Cherny <https://github.com/bcherny>
4// Cyrille Tuzi <https://github.com/cyrilletuzi>
5// Lucian Buzzo <https://github.com/lucianbuzzo>
6// Roland Groza <https://github.com/rolandjitsu>
7// Jason Kwok <https://github.com/JasonHK>
8// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
9// TypeScript Version: 2.2
10
11//==================================================================================================
12// JSON Schema Draft 04
13//==================================================================================================
14
15/**
16 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
17 */
18export type JSONSchema4TypeName =
19 | 'string' //
20 | 'number'
21 | 'integer'
22 | 'boolean'
23 | 'object'
24 | 'array'
25 | 'null'
26 | 'any';
27
28/**
29 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
30 */
31export type JSONSchema4Type =
32 | string //
33 | number
34 | boolean
35 | JSONSchema4Object
36 | JSONSchema4Array
37 | null;
38
39// Workaround for infinite type recursion
40export interface JSONSchema4Object {
41 [key: string]: JSONSchema4Type;
42}
43
44// Workaround for infinite type recursion
45// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
46export interface JSONSchema4Array extends Array<JSONSchema4Type> {}
47
48/**
49 * Meta schema
50 *
51 * Recommended values:
52 * - 'http://json-schema.org/schema#'
53 * - 'http://json-schema.org/hyper-schema#'
54 * - 'http://json-schema.org/draft-04/schema#'
55 * - 'http://json-schema.org/draft-04/hyper-schema#'
56 * - 'http://json-schema.org/draft-03/schema#'
57 * - 'http://json-schema.org/draft-03/hyper-schema#'
58 *
59 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
60 */
61export type JSONSchema4Version = string;
62
63/**
64 * JSON Schema V4
65 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
66 */
67export interface JSONSchema4 {
68 id?: string | undefined;
69 $ref?: string | undefined;
70 $schema?: JSONSchema4Version | undefined;
71
72 /**
73 * This attribute is a string that provides a short description of the
74 * instance property.
75 *
76 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
77 */
78 title?: string | undefined;
79
80 /**
81 * This attribute is a string that provides a full description of the of
82 * purpose the instance property.
83 *
84 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
85 */
86 description?: string | undefined;
87
88 default?: JSONSchema4Type | undefined;
89 multipleOf?: number | undefined;
90 maximum?: number | undefined;
91 exclusiveMaximum?: boolean | undefined;
92 minimum?: number | undefined;
93 exclusiveMinimum?: boolean | undefined;
94 maxLength?: number | undefined;
95 minLength?: number | undefined;
96 pattern?: string | undefined;
97
98 /**
99 * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
100 *
101 * This provides a definition for additional items in an array instance
102 * when tuple definitions of the items is provided. This can be false
103 * to indicate additional items in the array are not allowed, or it can
104 * be a schema that defines the schema of the additional items.
105 *
106 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
107 */
108 additionalItems?: boolean | JSONSchema4 | undefined;
109
110 /**
111 * This attribute defines the allowed items in an instance array, and
112 * MUST be a schema or an array of schemas. The default value is an
113 * empty schema which allows any value for items in the instance array.
114 *
115 * When this attribute value is a schema and the instance value is an
116 * array, then all the items in the array MUST be valid according to the
117 * schema.
118 *
119 * When this attribute value is an array of schemas and the instance
120 * value is an array, each position in the instance array MUST conform
121 * to the schema in the corresponding position for this array. This
122 * called tuple typing. When tuple typing is used, additional items are
123 * allowed, disallowed, or constrained by the "additionalItems"
124 * (Section 5.6) attribute using the same rules as
125 * "additionalProperties" (Section 5.4) for objects.
126 *
127 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
128 */
129 items?: JSONSchema4 | JSONSchema4[] | undefined;
130
131 maxItems?: number | undefined;
132 minItems?: number | undefined;
133 uniqueItems?: boolean | undefined;
134 maxProperties?: number | undefined;
135 minProperties?: number | undefined;
136
137 /**
138 * This attribute indicates if the instance must have a value, and not
139 * be undefined. This is false by default, making the instance
140 * optional.
141 *
142 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
143 */
144 required?: boolean | string[] | undefined;
145
146 /**
147 * This attribute defines a schema for all properties that are not
148 * explicitly defined in an object type definition. If specified, the
149 * value MUST be a schema or a boolean. If false is provided, no
150 * additional properties are allowed beyond the properties defined in
151 * the schema. The default value is an empty schema which allows any
152 * value for additional properties.
153 *
154 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
155 */
156 additionalProperties?: boolean | JSONSchema4 | undefined;
157
158 definitions?: {
159 [k: string]: JSONSchema4;
160 } | undefined;
161
162 /**
163 * This attribute is an object with property definitions that define the
164 * valid values of instance object property values. When the instance
165 * value is an object, the property values of the instance object MUST
166 * conform to the property definitions in this object. In this object,
167 * each property definition's value MUST be a schema, and the property's
168 * name MUST be the name of the instance property that it defines. The
169 * instance property value MUST be valid according to the schema from
170 * the property definition. Properties are considered unordered, the
171 * order of the instance properties MAY be in any order.
172 *
173 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
174 */
175 properties?: {
176 [k: string]: JSONSchema4;
177 } | undefined;
178
179 /**
180 * This attribute is an object that defines the schema for a set of
181 * property names of an object instance. The name of each property of
182 * this attribute's object is a regular expression pattern in the ECMA
183 * 262/Perl 5 format, while the value is a schema. If the pattern
184 * matches the name of a property on the instance object, the value of
185 * the instance's property MUST be valid against the pattern name's
186 * schema value.
187 *
188 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
189 */
190 patternProperties?: {
191 [k: string]: JSONSchema4;
192 } | undefined;
193 dependencies?: {
194 [k: string]: JSONSchema4 | string[];
195 } | undefined;
196
197 /**
198 * This provides an enumeration of all possible values that are valid
199 * for the instance property. This MUST be an array, and each item in
200 * the array represents a possible value for the instance value. If
201 * this attribute is defined, the instance value MUST be one of the
202 * values in the array in order for the schema to be valid.
203 *
204 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
205 */
206 enum?: JSONSchema4Type[] | undefined;
207
208 /**
209 * A single type, or a union of simple types
210 */
211 type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;
212
213 allOf?: JSONSchema4[] | undefined;
214 anyOf?: JSONSchema4[] | undefined;
215 oneOf?: JSONSchema4[] | undefined;
216 not?: JSONSchema4 | undefined;
217
218 /**
219 * The value of this property MUST be another schema which will provide
220 * a base schema which the current schema will inherit from. The
221 * inheritance rules are such that any instance that is valid according
222 * to the current schema MUST be valid according to the referenced
223 * schema. This MAY also be an array, in which case, the instance MUST
224 * be valid for all the schemas in the array. A schema that extends
225 * another schema MAY define additional attributes, constrain existing
226 * attributes, or add other constraints.
227 *
228 * Conceptually, the behavior of extends can be seen as validating an
229 * instance against all constraints in the extending schema as well as
230 * the extended schema(s).
231 *
232 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
233 */
234 extends?: string | string[] | undefined;
235
236 /**
237 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6
238 */
239 [k: string]: any;
240
241 format?: string | undefined;
242}
243
244//==================================================================================================
245// JSON Schema Draft 06
246//==================================================================================================
247
248export type JSONSchema6TypeName =
249 | 'string' //
250 | 'number'
251 | 'integer'
252 | 'boolean'
253 | 'object'
254 | 'array'
255 | 'null'
256 | 'any';
257
258export type JSONSchema6Type =
259 | string //
260 | number
261 | boolean
262 | JSONSchema6Object
263 | JSONSchema6Array
264 | null;
265
266// Workaround for infinite type recursion
267export interface JSONSchema6Object {
268 [key: string]: JSONSchema6Type;
269}
270
271// Workaround for infinite type recursion
272// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
273export interface JSONSchema6Array extends Array<JSONSchema6Type> {}
274
275/**
276 * Meta schema
277 *
278 * Recommended values:
279 * - 'http://json-schema.org/schema#'
280 * - 'http://json-schema.org/hyper-schema#'
281 * - 'http://json-schema.org/draft-06/schema#'
282 * - 'http://json-schema.org/draft-06/hyper-schema#'
283 *
284 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
285 */
286export type JSONSchema6Version = string;
287
288/**
289 * JSON Schema V6
290 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01
291 */
292export type JSONSchema6Definition = JSONSchema6 | boolean;
293export interface JSONSchema6 {
294 $id?: string | undefined;
295 $ref?: string | undefined;
296 $schema?: JSONSchema6Version | undefined;
297
298 /**
299 * Must be strictly greater than 0.
300 * A numeric instance is valid only if division by this keyword's value results in an integer.
301 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1
302 */
303 multipleOf?: number | undefined;
304
305 /**
306 * Representing an inclusive upper limit for a numeric instance.
307 * This keyword validates only if the instance is less than or exactly equal to "maximum".
308 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2
309 */
310 maximum?: number | undefined;
311
312 /**
313 * Representing an exclusive upper limit for a numeric instance.
314 * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
315 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3
316 */
317 exclusiveMaximum?: number | undefined;
318
319 /**
320 * Representing an inclusive lower limit for a numeric instance.
321 * This keyword validates only if the instance is greater than or exactly equal to "minimum".
322 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4
323 */
324 minimum?: number | undefined;
325
326 /**
327 * Representing an exclusive lower limit for a numeric instance.
328 * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
329 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5
330 */
331 exclusiveMinimum?: number | undefined;
332
333 /**
334 * Must be a non-negative integer.
335 * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
336 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6
337 */
338 maxLength?: number | undefined;
339
340 /**
341 * Must be a non-negative integer.
342 * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
343 * Omitting this keyword has the same behavior as a value of 0.
344 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7
345 */
346 minLength?: number | undefined;
347
348 /**
349 * Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
350 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8
351 */
352 pattern?: string | undefined;
353
354 /**
355 * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
356 * Omitting this keyword has the same behavior as an empty schema.
357 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9
358 */
359 items?: JSONSchema6Definition | JSONSchema6Definition[] | undefined;
360
361 /**
362 * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
363 * If "items" is an array of schemas, validation succeeds if every instance element
364 * at a position greater than the size of "items" validates against "additionalItems".
365 * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
366 * (possibly the default value of an empty schema) is applied to all elements.
367 * Omitting this keyword has the same behavior as an empty schema.
368 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
369 */
370 additionalItems?: JSONSchema6Definition | undefined;
371
372 /**
373 * Must be a non-negative integer.
374 * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
375 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11
376 */
377 maxItems?: number | undefined;
378
379 /**
380 * Must be a non-negative integer.
381 * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword.
382 * Omitting this keyword has the same behavior as a value of 0.
383 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12
384 */
385 minItems?: number | undefined;
386
387 /**
388 * If this keyword has boolean value false, the instance validates successfully.
389 * If it has boolean value true, the instance validates successfully if all of its elements are unique.
390 * Omitting this keyword has the same behavior as a value of false.
391 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13
392 */
393 uniqueItems?: boolean | undefined;
394
395 /**
396 * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
397 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
398 */
399 contains?: JSONSchema6Definition | undefined;
400
401 /**
402 * Must be a non-negative integer.
403 * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
404 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15
405 */
406 maxProperties?: number | undefined;
407
408 /**
409 * Must be a non-negative integer.
410 * An object instance is valid against "maxProperties" if its number of properties is greater than,
411 * or equal to, the value of this keyword.
412 * Omitting this keyword has the same behavior as a value of 0.
413 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16
414 */
415 minProperties?: number | undefined;
416
417 /**
418 * Elements of this array must be unique.
419 * An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
420 * Omitting this keyword has the same behavior as an empty array.
421 *
422 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17
423 */
424 required?: string[] | undefined;
425
426 /**
427 * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
428 * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
429 * the child instance for that name successfully validates against the corresponding schema.
430 * Omitting this keyword has the same behavior as an empty object.
431 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18
432 */
433 properties?: {
434 [k: string]: JSONSchema6Definition;
435 } | undefined;
436
437 /**
438 * This attribute is an object that defines the schema for a set of property names of an object instance.
439 * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema.
440 * If the pattern matches the name of a property on the instance object, the value of the instance's property
441 * MUST be valid against the pattern name's schema value.
442 * Omitting this keyword has the same behavior as an empty object.
443 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19
444 */
445 patternProperties?: {
446 [k: string]: JSONSchema6Definition;
447 } | undefined;
448
449 /**
450 * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
451 * If specified, the value MUST be a schema or a boolean.
452 * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
453 * The default value is an empty schema which allows any value for additional properties.
454 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
455 */
456 additionalProperties?: JSONSchema6Definition | undefined;
457
458 /**
459 * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.
460 * Each property specifies a dependency.
461 * If the dependency value is an array, each element in the array must be unique.
462 * Omitting this keyword has the same behavior as an empty object.
463 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
464 */
465 dependencies?: {
466 [k: string]: JSONSchema6Definition | string[];
467 } | undefined;
468
469 /**
470 * Takes a schema which validates the names of all properties rather than their values.
471 * Note the property name that the schema is testing will always be a string.
472 * Omitting this keyword has the same behavior as an empty schema.
473 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
474 */
475 propertyNames?: JSONSchema6Definition | undefined;
476
477 /**
478 * This provides an enumeration of all possible values that are valid
479 * for the instance property. This MUST be an array, and each item in
480 * the array represents a possible value for the instance value. If
481 * this attribute is defined, the instance value MUST be one of the
482 * values in the array in order for the schema to be valid.
483 *
484 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23
485 */
486 enum?: JSONSchema6Type[] | undefined;
487
488 /**
489 * More readable form of a one-element "enum"
490 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
491 */
492 const?: JSONSchema6Type | undefined;
493
494 /**
495 * A single type, or a union of simple types
496 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
497 */
498 type?: JSONSchema6TypeName | JSONSchema6TypeName[] | undefined;
499
500 /**
501 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
502 */
503 allOf?: JSONSchema6Definition[] | undefined;
504
505 /**
506 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
507 */
508 anyOf?: JSONSchema6Definition[] | undefined;
509
510 /**
511 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
512 */
513 oneOf?: JSONSchema6Definition[] | undefined;
514
515 /**
516 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
517 */
518 not?: JSONSchema6Definition | undefined;
519
520 /**
521 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
522 */
523 definitions?: {
524 [k: string]: JSONSchema6Definition;
525 } | undefined;
526
527 /**
528 * This attribute is a string that provides a short description of the instance property.
529 *
530 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
531 */
532 title?: string | undefined;
533
534 /**
535 * This attribute is a string that provides a full description of the of purpose the instance property.
536 *
537 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
538 */
539 description?: string | undefined;
540
541 /**
542 * This keyword can be used to supply a default JSON value associated with a particular schema.
543 * It is RECOMMENDED that a default value be valid against the associated schema.
544 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
545 */
546 default?: JSONSchema6Type | undefined;
547
548 /**
549 * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
550 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
551 */
552 examples?: JSONSchema6Type[] | undefined;
553
554 /**
555 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8
556 */
557 format?: string | undefined;
558}
559
560//==================================================================================================
561// JSON Schema Draft 07
562//==================================================================================================
563// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
564//--------------------------------------------------------------------------------------------------
565
566/**
567 * Primitive type
568 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
569 */
570export type JSONSchema7TypeName =
571 | 'string' //
572 | 'number'
573 | 'integer'
574 | 'boolean'
575 | 'object'
576 | 'array'
577 | 'null';
578
579/**
580 * Primitive type
581 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
582 */
583export type JSONSchema7Type =
584 | string //
585 | number
586 | boolean
587 | JSONSchema7Object
588 | JSONSchema7Array
589 | null;
590
591// Workaround for infinite type recursion
592export interface JSONSchema7Object {
593 [key: string]: JSONSchema7Type;
594}
595
596// Workaround for infinite type recursion
597// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
598export interface JSONSchema7Array extends Array<JSONSchema7Type> {}
599
600/**
601 * Meta schema
602 *
603 * Recommended values:
604 * - 'http://json-schema.org/schema#'
605 * - 'http://json-schema.org/hyper-schema#'
606 * - 'http://json-schema.org/draft-07/schema#'
607 * - 'http://json-schema.org/draft-07/hyper-schema#'
608 *
609 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
610 */
611export type JSONSchema7Version = string;
612
613/**
614 * JSON Schema v7
615 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
616 */
617export type JSONSchema7Definition = JSONSchema7 | boolean;
618export interface JSONSchema7 {
619 $id?: string | undefined;
620 $ref?: string | undefined;
621 $schema?: JSONSchema7Version | undefined;
622 $comment?: string | undefined;
623
624 /**
625 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
626 */
627 type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
628 enum?: JSONSchema7Type[] | undefined;
629 const?: JSONSchema7Type | undefined;
630
631 /**
632 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
633 */
634 multipleOf?: number | undefined;
635 maximum?: number | undefined;
636 exclusiveMaximum?: number | undefined;
637 minimum?: number | undefined;
638 exclusiveMinimum?: number | undefined;
639
640 /**
641 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
642 */
643 maxLength?: number | undefined;
644 minLength?: number | undefined;
645 pattern?: string | undefined;
646
647 /**
648 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
649 */
650 items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
651 additionalItems?: JSONSchema7Definition | undefined;
652 maxItems?: number | undefined;
653 minItems?: number | undefined;
654 uniqueItems?: boolean | undefined;
655 contains?: JSONSchema7 | undefined;
656
657 /**
658 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
659 */
660 maxProperties?: number | undefined;
661 minProperties?: number | undefined;
662 required?: string[] | undefined;
663 properties?: {
664 [key: string]: JSONSchema7Definition;
665 } | undefined;
666 patternProperties?: {
667 [key: string]: JSONSchema7Definition;
668 } | undefined;
669 additionalProperties?: JSONSchema7Definition | undefined;
670 dependencies?: {
671 [key: string]: JSONSchema7Definition | string[];
672 } | undefined;
673 propertyNames?: JSONSchema7Definition | undefined;
674
675 /**
676 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
677 */
678 if?: JSONSchema7Definition | undefined;
679 then?: JSONSchema7Definition | undefined;
680 else?: JSONSchema7Definition | undefined;
681
682 /**
683 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
684 */
685 allOf?: JSONSchema7Definition[] | undefined;
686 anyOf?: JSONSchema7Definition[] | undefined;
687 oneOf?: JSONSchema7Definition[] | undefined;
688 not?: JSONSchema7Definition | undefined;
689
690 /**
691 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
692 */
693 format?: string | undefined;
694
695 /**
696 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
697 */
698 contentMediaType?: string | undefined;
699 contentEncoding?: string | undefined;
700
701 /**
702 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
703 */
704 definitions?: {
705 [key: string]: JSONSchema7Definition;
706 } | undefined;
707
708 /**
709 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
710 */
711 title?: string | undefined;
712 description?: string | undefined;
713 default?: JSONSchema7Type | undefined;
714 readOnly?: boolean | undefined;
715 writeOnly?: boolean | undefined;
716 examples?: JSONSchema7Type | undefined;
717}
718
719export interface ValidationResult {
720 valid: boolean;
721 errors: ValidationError[];
722}
723
724export interface ValidationError {
725 property: string;
726 message: string;
727}
728
729/**
730 * To use the validator call JSONSchema.validate with an instance object and an optional schema object.
731 * If a schema is provided, it will be used to validate. If the instance object refers to a schema (self-validating),
732 * that schema will be used to validate and the schema parameter is not necessary (if both exist,
733 * both validations will occur).
734 */
735export function validate(instance: {}, schema: JSONSchema4 | JSONSchema6 | JSONSchema7): ValidationResult;
736
737/**
738 * The checkPropertyChange method will check to see if an value can legally be in property with the given schema
739 * This is slightly different than the validate method in that it will fail if the schema is readonly and it will
740 * not check for self-validation, it is assumed that the passed in value is already internally valid.
741 */
742export function checkPropertyChange(
743 value: any,
744 schema: JSONSchema4 | JSONSchema6 | JSONSchema7,
745 property: string,
746): ValidationResult;
747
748/**
749 * This checks to ensure that the result is valid and will throw an appropriate error message if it is not.
750 */
751export function mustBeValid(result: ValidationResult): void;