Schema to JSON Schema

The JSONSchema.make function allows you to generate a JSON Schema from a schema.

Example (Creating a JSON Schema for a Struct)

The following example defines a Person schema with properties for name (a string) and age (a number). It then generates the corresponding JSON Schema.

1
import { JSONSchema, Schema } from "effect"
2

3
const Person = Schema.Struct({
4
  name: Schema.String,
5
  age: Schema.Number,
6
})
7

8
const jsonSchema = JSONSchema.make(Person)
9

10
console.log(JSON.stringify(jsonSchema, null, 2))
11
/*
12
Output:
13
{
14
  "$schema": "http://json-schema.org/draft-07/schema#",
15
  "type": "object",
16
  "required": [
17
    "name",
18
    "age"
19
  ],
20
  "properties": {
21
    "name": {
22
      "type": "string"
23
    },
24
    "age": {
25
      "type": "number"
26
    }
27
  },
28
  "additionalProperties": false
29
}
30
*/

The JSONSchema.make function aims to produce an optimal JSON Schema representing the input part of the decoding phase. It does this by traversing the schema from the most nested component, incorporating each refinement, and stops at the first transformation encountered.

Example (Excluding Transformations in JSON Schema)

Consider modifying the age field to include both a refinement and a transformation. Only the refinement is reflected in the JSON Schema.

1
import { JSONSchema, Schema } from "effect"
2

3
const Person = Schema.Struct({
4
  name: Schema.String,
5
  age: Schema.Number.pipe(
6
    // Refinement included in the JSON Schema
7
    Schema.int(),
8
    // Transformation excluded from the JSON Schema
9
    Schema.clamp(1, 10),
10
  ),
11
})
12

13
const jsonSchema = JSONSchema.make(Person)
14

15
console.log(JSON.stringify(jsonSchema, null, 2))
16
/*
17
Output:
18
{
19
  "$schema": "http://json-schema.org/draft-07/schema#",
20
  "type": "object",
21
  "required": [
22
    "name",
23
    "age"
24
  ],
25
  "properties": {
26
    "name": {
27
      "type": "string"
28
    },
29
    "age": {
30
      "type": "integer",
31
      "description": "an integer",
32
      "title": "integer"
33
    }
34
  },
35
  "additionalProperties": false
36
}
37
*/

In this case, the JSON Schema reflects the integer refinement but does not include the transformation that clamps the value.

Targeting a Specific JSON Schema Version

By default, JSONSchema.make generates a JSON Schema compatible with Draft 07. You can change the target schema version by passing an options object with a target property. The supported targets are:

"jsonSchema7" (default) - JSON Schema Draft 07
"jsonSchema2019-09" - JSON Schema Draft 2019-09
"jsonSchema2020-12" - JSON Schema Draft 2020-12
"openApi3.1" - OpenAPI 3.1

Changing the target can affect the generated output. For example, tuple schemas use items and additionalItems in Draft 07, whereas Draft 2020-12 uses prefixItems and items.

Example (Using JSON Schema 2020-12 for a Tuple)

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Tuple(Schema.String, Schema.Number)
4

5
const jsonSchema = JSONSchema.make(schema, {
6
  target: "jsonSchema2020-12",
7
})
8

9
console.log(JSON.stringify(jsonSchema, null, 2))
10
/*
11
Output:
12
{
13
  "$schema": "https://json-schema.org/draft/2020-12/schema",
14
  "type": "array",
15
  "minItems": 2,
16
  "prefixItems": [
17
    {
18
      "type": "string"
19
    },
20
    {
21
      "type": "number"
22
    }
23
  ],
24
  "items": false
25
}
26
*/

Specific Outputs for Schema Types

Literals

Literals are transformed into enum types within JSON Schema.

Example (Single Literal)

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Literal("a")
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "string",
11
  "enum": [
12
    "a"
13
  ]
14
}
15
*/

Example (Union of literals)

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Literal("a", "b")
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "string",
11
  "enum": [
12
    "a",
13
    "b"
14
  ]
15
}
16
*/

Void

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Void
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "$id": "/schemas/void",
11
  "title": "void"
12
}
13
*/

Any

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Any
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "$id": "/schemas/any",
11
  "title": "any"
12
}
13
*/

Unknown

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Unknown
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "$id": "/schemas/unknown",
11
  "title": "unknown"
12
}
13
*/

Object

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Object
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "$id": "/schemas/object",
11
  "anyOf": [
12
    {
13
      "type": "object"
14
    },
15
    {
16
      "type": "array"
17
    }
18
  ],
19
  "description": "an object in the TypeScript meaning, i.e. the `object` type",
20
  "title": "object"
21
}
22
*/

String

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.String
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "string"
11
}
12
*/

Number

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Number
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "number"
11
}
12
*/

Boolean

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Boolean
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "boolean"
11
}
12
*/

Tuples

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Tuple(Schema.String, Schema.Number)
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "array",
11
  "minItems": 2,
12
  "items": [
13
    {
14
      "type": "string"
15
    },
16
    {
17
      "type": "number"
18
    }
19
  ],
20
  "additionalItems": false
21
}
22
*/

Arrays

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Array(Schema.String)
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "array",
11
  "items": {
12
    "type": "string"
13
  }
14
}
15
*/

Non Empty Arrays

Represents an array with at least one element.

Example

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.NonEmptyArray(Schema.String)
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "array",
11
  "minItems": 1,
12
  "items": {
13
    "type": "string"
14
  }
15
}
16
*/

Structs

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Struct({
4
  name: Schema.String,
5
  age: Schema.Number,
6
})
7

8
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
9
/*
10
Output:
11
{
12
  "$schema": "http://json-schema.org/draft-07/schema#",
13
  "type": "object",
14
  "required": [
15
    "name",
16
    "age"
17
  ],
18
  "properties": {
19
    "name": {
20
      "type": "string"
21
    },
22
    "age": {
23
      "type": "number"
24
    }
25
  },
26
  "additionalProperties": false
27
}
28
*/

Records

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Record({
4
  key: Schema.String,
5
  value: Schema.Number,
6
})
7

8
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
9
/*
10
Output:
11
{
12
  "$schema": "http://json-schema.org/draft-07/schema#",
13
  "type": "object",
14
  "required": [],
15
  "properties": {},
16
  "patternProperties": {
17
    "": {
18
      "type": "number"
19
    }
20
  }
21
}
22
*/

Mixed Structs with Records

Combines fixed properties from a struct with dynamic properties from a record.

Example

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Struct(
4
  {
5
    name: Schema.String,
6
    age: Schema.Number,
7
  },
8
  Schema.Record({
9
    key: Schema.String,
10
    value: Schema.Union(Schema.String, Schema.Number),
11
  }),
12
)
13

14
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
15
/*
16
Output:
17
{
18
  "$schema": "http://json-schema.org/draft-07/schema#",
19
  "type": "object",
20
  "required": [
21
    "name",
22
    "age"
23
  ],
24
  "properties": {
25
    "name": {
26
      "type": "string"
27
    },
28
    "age": {
29
      "type": "number"
30
    }
31
  },
32
  "patternProperties": {
33
    "": {
34
      "anyOf": [
35
        {
36
          "type": "string"
37
        },
38
        {
39
          "type": "number"
40
        }
41
      ]
42
    }
43
  }
44
}
45
*/

Enums

1
import { JSONSchema, Schema } from "effect"
2

3
enum Fruits {
4
  Apple,
5
  Banana,
6
}
7

8
const schema = Schema.Enums(Fruits)
9

10
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
11
/*
12
Output:
13
{
14
  "$schema": "http://json-schema.org/draft-07/schema#",
15
  "$comment": "/schemas/enums",
16
  "anyOf": [
17
    {
18
      "type": "number",
19
      "title": "Apple",
20
      "enum": [
21
        0
22
      ]
23
    },
24
    {
25
      "type": "number",
26
      "title": "Banana",
27
      "enum": [
28
        1
29
      ]
30
    }
31
  ]
32
}
33
*/

Template Literals

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.TemplateLiteral(Schema.Literal("a"), Schema.Number)
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "string",
11
  "title": "`a${number}`",
12
  "description": "a template literal",
13
  "pattern": "^a[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?$"
14
}
15
*/

Unions

Unions are expressed using anyOf or enum, depending on the types involved:

Example (Generic Union)

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Union(Schema.String, Schema.Number)
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "anyOf": [
11
    {
12
      "type": "string"
13
    },
14
    {
15
      "type": "number"
16
    }
17
  ]
18
}
19
*/

Example (Union of literals)

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Literal("a", "b")
4

5
console.log(JSON.stringify(JSONSchema.make(schema), null, 2))
6
/*
7
Output:
8
{
9
  "$schema": "http://json-schema.org/draft-07/schema#",
10
  "type": "string",
11
  "enum": [
12
    "a",
13
    "b"
14
  ]
15
}
16
*/

Identifier Annotations

You can add identifier annotations to schemas to improve structure and maintainability. Annotated schemas are included in a $defs object in the root of the JSON Schema and referenced from there.

Example (Using Identifier Annotations)

1
import { JSONSchema, Schema } from "effect"
2

3
const Name = Schema.String.annotations({ identifier: "Name" })
4

5
const Age = Schema.Number.annotations({ identifier: "Age" })
6

7
const Person = Schema.Struct({
8
  name: Name,
9
  age: Age,
10
})
11

12
const jsonSchema = JSONSchema.make(Person)
13

14
console.log(JSON.stringify(jsonSchema, null, 2))
15
/*
16
Output:
17
{
18
  "$schema": "http://json-schema.org/draft-07/schema#",
19
  "$defs": {
20
    "Name": {
21
      "type": "string",
22
      "description": "a string",
23
      "title": "string"
24
    },
25
    "Age": {
26
      "type": "number",
27
      "description": "a number",
28
      "title": "number"
29
    }
30
  },
31
  "type": "object",
32
  "required": [
33
    "name",
34
    "age"
35
  ],
36
  "properties": {
37
    "name": {
38
      "$ref": "#/$defs/Name"
39
    },
40
    "age": {
41
      "$ref": "#/$defs/Age"
42
    }
43
  },
44
  "additionalProperties": false
45
}
46
*/

By using identifier annotations, schemas can be reused and referenced more easily, especially in complex JSON Schemas.

Standard JSON Schema Annotations

Standard JSON Schema annotations such as title, description, default, and examples are supported. These annotations allow you to enrich your schemas with metadata that can enhance readability and provide additional information about the data structure.

Example (Using Annotations for Metadata)

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.String.annotations({
4
  description: "my custom description",
5
  title: "my custom title",
6
  default: "",
7
  examples: ["a", "b"],
8
})
9

10
const jsonSchema = JSONSchema.make(schema)
11

12
console.log(JSON.stringify(jsonSchema, null, 2))
13
/*
14
Output:
15
{
16
  "$schema": "http://json-schema.org/draft-07/schema#",
17
  "type": "string",
18
  "description": "my custom description",
19
  "title": "my custom title",
20
  "examples": [
21
    "a",
22
    "b"
23
  ],
24
  "default": ""
25
}
26
*/

Adding annotations to Struct properties

To enhance the clarity of your JSON schemas, it’s advisable to add annotations directly to the property signatures rather than to the type itself. This method is more semantically appropriate as it links descriptive titles and other metadata specifically to the properties they describe, rather than to the generic type.

Example (Annotated Struct Properties)

1
import { JSONSchema, Schema } from "effect"
2

3
const Person = Schema.Struct({
4
  firstName: Schema.propertySignature(Schema.String).annotations({
5
    title: "First name",
6
  }),
7
  lastName: Schema.propertySignature(Schema.String).annotations({
8
    title: "Last Name",
9
  }),
10
})
11

12
const jsonSchema = JSONSchema.make(Person)
13

14
console.log(JSON.stringify(jsonSchema, null, 2))
15
/*
16
Output:
17
{
18
  "$schema": "http://json-schema.org/draft-07/schema#",
19
  "type": "object",
20
  "required": [
21
    "firstName",
22
    "lastName"
23
  ],
24
  "properties": {
25
    "firstName": {
26
      "type": "string",
27
      "title": "First name"
28
    },
29
    "lastName": {
30
      "type": "string",
31
      "title": "Last Name"
32
    }
33
  },
34
  "additionalProperties": false
35
}
36
*/

Recursive and Mutually Recursive Schemas

Recursive and mutually recursive schemas are supported, however it’s mandatory to use identifier annotations for these types of schemas to ensure correct references and definitions within the generated JSON Schema.

Example (Recursive Schema with Identifier Annotations)

In this example, the Category schema refers to itself, making it necessary to use an identifier annotation to facilitate the reference.

1
import { JSONSchema, Schema } from "effect"
2

3
// Define the interface representing a category structure
4
interface Category {
5
  readonly name: string
6
  readonly categories: ReadonlyArray<Category>
7
}
8

9
// Define a recursive schema with a required identifier annotation
10
const Category = Schema.Struct({
11
  name: Schema.String,
12
  categories: Schema.Array(
13
    // Recursive reference to the Category schema
14
    Schema.suspend((): Schema.Schema<Category> => Category),
15
  ),
16
}).annotations({ identifier: "Category" })
17

18
const jsonSchema = JSONSchema.make(Category)
19

20
console.log(JSON.stringify(jsonSchema, null, 2))
21
/*
22
Output:
23
{
24
  "$schema": "http://json-schema.org/draft-07/schema#",
25
  "$defs": {
26
    "Category": {
27
      "type": "object",
28
      "required": [
29
        "name",
30
        "categories"
31
      ],
32
      "properties": {
33
        "name": {
34
          "type": "string"
35
        },
36
        "categories": {
37
          "type": "array",
38
          "items": {
39
            "$ref": "#/$defs/Category"
40
          }
41
        }
42
      },
43
      "additionalProperties": false
44
    }
45
  },
46
  "$ref": "#/$defs/Category"
47
}
48
*/

Customizing JSON Schema Generation

When working with JSON Schema certain data types, such as bigint, lack a direct representation because JSON Schema does not natively support them. This absence typically leads to an error when the schema is generated.

Example (Error Due to Missing Annotation)

Attempting to generate a JSON Schema for unsupported types like bigint will lead to a missing annotation error:

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Struct({
4
  a_bigint_field: Schema.BigIntFromSelf,
5
})
6

7
const jsonSchema = JSONSchema.make(schema)
8

9
console.log(JSON.stringify(jsonSchema, null, 2))
10
/*
11
throws:
12
Error: Missing annotation
13
at path: ["a_bigint_field"]
14
details: Generating a JSON Schema for this schema requires a "jsonSchema" annotation
15
schema (BigIntKeyword): bigint
16
*/

To address this, you can enhance the schema with a custom jsonSchema annotation, defining how you intend to represent such types in JSON Schema:

Example (Using Custom Annotation for Unsupported Type)

1
import { JSONSchema, Schema } from "effect"
2

3
const schema = Schema.Struct({
4
  // Adding a custom JSON Schema annotation for the `bigint` type
5
  a_bigint_field: Schema.BigIntFromSelf.annotations({
6
    jsonSchema: {
7
      type: "some custom way to represent a bigint in JSON Schema",
8
    },
9
  }),
10
})
11

12
const jsonSchema = JSONSchema.make(schema)
13

14
console.log(JSON.stringify(jsonSchema, null, 2))
15
/*
16
Output:
17
{
18
  "$schema": "http://json-schema.org/draft-07/schema#",
19
  "type": "object",
20
  "required": [
21
    "a_bigint_field"
22
  ],
23
  "properties": {
24
    "a_bigint_field": {
25
      "type": "some custom way to represent a bigint in JSON Schema"
26
    }
27
  },
28
  "additionalProperties": false
29
}
30
*/

When defining a refinement (e.g., through the Schema.filter function), you can include a JSON Schema annotation to describe the refinement. This annotation is added as a “fragment” that becomes part of the generated JSON Schema. If a schema contains multiple refinements, their respective annotations are merged into the output.

Example (Using Refinements with Merged Annotations)

1
import { JSONSchema, Schema } from "effect"
2

3
// Define a schema with a refinement for positive numbers
4
const Positive = Schema.Number.pipe(
5
  Schema.filter((n) => n > 0, {
6
    jsonSchema: { minimum: 0 },
7
  }),
8
)
9

10
// Add an upper bound refinement to the schema
11
const schema = Positive.pipe(
12
  Schema.filter((n) => n <= 10, {
13
    jsonSchema: { maximum: 10 },
14
  }),
15
)
16

17
const jsonSchema = JSONSchema.make(schema)
18

19
console.log(JSON.stringify(jsonSchema, null, 2))
20
/*
21
Output:
22
{
23
  "$schema": "http://json-schema.org/draft-07/schema#",
24
  "type": "number",
25
  "minimum": 0,
26
  "maximum": 10
27
}
28
*/

The jsonSchema annotation is defined as a generic object, allowing it to represent non-standard extensions. This flexibility leaves the responsibility of enforcing type constraints to the user.

If you prefer stricter type enforcement or need to support non-standard extensions, you can introduce a satisfies constraint on the object literal. This constraint should be used in conjunction with the typing library of your choice.

Example (Ensuring Type Correctness)

In the following example, we’ve used the @types/json-schema package to provide TypeScript definitions for JSON Schema. This approach not only ensures type correctness but also enables autocomplete suggestions in your IDE.

1
import { JSONSchema, Schema } from "effect"
2
import type { JSONSchema7 } from "json-schema"
3

4
const Positive = Schema.Number.pipe(
5
  Schema.filter((n) => n > 0, {
6
    jsonSchema: { minimum: 0 }, // Generic object, no type enforcement
7
  }),
8
)
9

10
const schema = Positive.pipe(
11
  Schema.filter((n) => n <= 10, {
12
    jsonSchema: { maximum: 10 } satisfies JSONSchema7, // Enforces type constraints
13
  }),
14
)
15

16
const jsonSchema = JSONSchema.make(schema)
17

18
console.log(JSON.stringify(jsonSchema, null, 2))
19
/*
20
Output:
21
{
22
  "$schema": "http://json-schema.org/draft-07/schema#",
23
  "type": "number",
24
  "minimum": 0,
25
  "maximum": 10
26
}
27
*/

For schema types other than refinements, you can override the default generated JSON Schema by providing a custom jsonSchema annotation. The content of this annotation will replace the system-generated schema.

Example (Custom Annotation for a Struct)

1
import { JSONSchema, Schema } from "effect"
2

3
// Define a struct with a custom JSON Schema annotation
4
const schema = Schema.Struct({ foo: Schema.String }).annotations({
5
  jsonSchema: { type: "object" },
6
})
7

8
const jsonSchema = JSONSchema.make(schema)
9

10
console.log(JSON.stringify(jsonSchema, null, 2))
11
/*
12
Output
13
{
14
  "$schema": "http://json-schema.org/draft-07/schema#",
15
  "type": "object"
16
}
17
the default would be:
18
{
19
  "$schema": "http://json-schema.org/draft-07/schema#",
20
  "type": "object",
21
  "required": [
22
    "foo"
23
  ],
24
  "properties": {
25
    "foo": {
26
      "type": "string"
27
    }
28
  },
29
  "additionalProperties": false
30
}
31
*/

Specialized JSON Schema Generation with Schema.parseJson

The Schema.parseJson function provides a unique approach to JSON Schema generation. Instead of defaulting to a schema for a plain string, which represents the “from” side of the transformation, it generates a schema based on the structure provided within the argument.

This behavior ensures that the generated JSON Schema reflects the intended structure of the parsed data, rather than the raw JSON input.

Example (Generating JSON Schema for a Parsed Object)

1
import { JSONSchema, Schema } from "effect"
2

3
// Define a schema that parses a JSON string into a structured object
4
const schema = Schema.parseJson(
5
  Schema.Struct({
6
    // Nested parsing: JSON string to a number
7
    a: Schema.parseJson(Schema.NumberFromString),
8
  }),
9
)
10

11
const jsonSchema = JSONSchema.make(schema)
12

13
console.log(JSON.stringify(jsonSchema, null, 2))
14
/*
15
Output:
16
{
17
  "$schema": "http://json-schema.org/draft-07/schema#",
18
  "type": "object",
19
  "required": [
20
    "a"
21
  ],
22
  "properties": {
23
    "a": {
24
      "type": "string",
25
      "contentMediaType": "application/json"
26
    }
27
  },
28
  "additionalProperties": false
29
}
30
*/