Packages > pkg.pkl-lang.org/pkl-pantry/org.json_schema

org.json_schema.JsonSchema1.0.4

Overview
Properties
Methods
Type Aliases

open module org.json_schema.JsonSchema

A document that describes constraints on JSON values.

Module URI:: package://pkg.pkl-lang.org/pkl-pantry/org.json_schema@1.0.4#/JsonSchema.pkl
Source code:: JsonSchema.pkl
Known subtypes:
Known usages:
All versions:

Properties(show inherited)

link

hidden

output: ModuleOutput (pkl.base)Source

The output of this module.

Defaults to all module properties rendered as either Pcf or the format specified on the command line.
link

hidden

versions: List<String>Source

The known versions of JSON Schema.

For example, http://json-schema.org/draft-06/schema#.
link

hidden

$$baseSchema: JsonSchema?Source

The base-level schema.

This is a utility property to help with resolving references.
link

hidden

$$idUri: URI?Source

The ID as an instance of URI.
link

hidden

$$refUri: URI?Source

The reference as an instance of URI.
link
$id: String?Source

URI-reference for the schema.
The reference serves two purposes:
- It declares a unique identifier for the schema.
- It declares a base URI against which $ref URI-references are resolved.
It is best practice that every top-level schema should set $id to an absolute-URI (not a relative reference), with a domain that you control.

https://json-schema.org/understanding-json-schema/structuring.html#the-id-property
link

$ref: String?Source

Reference to a schema.

https://json-schema.org/understanding-json-schema/structuring.html#using-id-with-ref
link
$schema: JsonSchemaVersion?Source

The presence of this property declares that this object represents a JSON Schema, and also represents the version that the schema was written against.
It is recommended that all JSON Schemas have a $schema entry, which must be at the root. Therefore most of the time, you'll want this at the root of your schema:
```
"$schema": "http://json-schema.org/draft/2019-09/schema#"
```
https://json-schema.org/understanding-json-schema/reference/schema.html
link

$comment: String(availableAfter("http://json-schema.org/draft-07/schema#"))?Source

Implementation comments for a schema.

Its value must always be a string. Unlike the annotations title, description, and examples, JSON schema implementations aren't allowed to attach any meaning or behavior to it whatsoever, and may even strip them at any time. Therefore, they are useful for leaving notes to future editors of a JSON schema, but should not be used to communicate to users of the schema.

https://json-schema.org/understanding-json-schema/reference/generic.html#comments
link

definitions: Mapping<String, Schema>?Source

Defines schemas that maybe re-used within a complex JSON Schema document.

https://json-schema.org/understanding-json-schema/structuring.html?highlight=definitions#reuse
link

$defs: Mapping<String, Schema>(availableAfter("https://json-schema.org/draft/2019-09/schema"))?Source

Defines schemas that maybe re-used within a complex JSON Schema document.

This is the same thing as definitions, but was renamed in draft 2019.

https://json-schema.org/understanding-json-schema/structuring.html#defs
link

title: String?Source

A short descriptor of this schema.

https://json-schema.org/understanding-json-schema/reference/generic.html#annotations
link

description: String?Source

A long descriptor of this schema.

https://json-schema.org/understanding-json-schema/reference/generic.html#annotations
link

default: JsonSchemaValue?Source

A default instance value of this schema.

This value is not used to fill in missing values during the validation process. Non-validation tools such as documentation generators or form generators may use this value to give hints to users about how to use a value. However, default is typically used to express that if a value is missing, then the value is semantically the same as if the value was present with the default value. The value of default should validate against the schema in which it resides, but that isn't required.

https://json-schema.org/understanding-json-schema/reference/generic.html#annotations
link

examples: JsonSchemaValue?Source

A place to provide a set of examples that validate against the schema.

This isn't used for validation, but may help with explaining the effect and purpose of the schema to a reader. Each entry should validate against the schema in which it resides, but that isn't strictly required. There is no need to duplicate the default value in the examples array, since default will be treated as another example.

https://json-schema.org/understanding-json-schema/reference/generic.html#annotations
link

deprecated: Boolean(availableAfter("https://json-schema.org/draft/2019-09/schema"))?Source

Indicates that the instance value should not be used and may be removed in the future.

Introduced in draft 2019-09.
link

readOnly: Boolean(availableAfter("http://json-schema.org/draft-07/schema#"))?Source

Metadata indicating that the instance value should not be modified.

It could be used to indicate that a PUT request that changes a value would result in a 400 Bad Request response

Introduced in draft 7.
link

writeOnly: Boolean(availableAfter("http://json-schema.org/draft-07/schema#"))?Source

Metadata indicating that a value may be set, but will remain hidden.

In could be used to indicate you can set a value with a PUT request, but it would not be included when retrieving that record with a GET request

Introduced in draft 7.
link
type: (JsonSchemaTypeName|Listing<JsonSchemaTypeName>)?Source

The fundamental data type for a schema.
At its core, JSON Schema defines the following basic types:
- string
- number
- integer
- boolean
- array
- object
- null
type may either be a string or a listing.
- If it's a string, it is the name of one of the basic types above.
- If it is an array, it must be an array of strings, where each string is the name of one of the basic types, and each element is unique. In this case, the JSON snippet is valid if it matches any of the given types.
https://json-schema.org/understanding-json-schema/reference/type.html#type
link

enum: (JsonSchemaValue|Listing<JsonSchemaValue>)?Source

Restricts the instance value to a fixed set of values.

It must be a listing with at least one element, where each element is unique. You can use enum even without a type, to accept values of different types.

Elements in the array might be of any value, including null. https://json-schema.org/understanding-json-schema/reference/generic.html#enumerated-values
link

`const`: JsonSchemaValue?Source

Restricts the instance value to a single value.

https://json-schema.org/understanding-json-schema/reference/generic.html#constant-values
link

multipleOf: Number(isPositive)?Source

Restricts the instance value to a multiple of the given number.

It may be set to any positive number.

https://json-schema.org/understanding-json-schema/reference/numeric.html#multiples
link

minimum: Number?Source

Restricts the instance value to be at minimum the given number.

https://json-schema.org/understanding-json-schema/reference/numeric.html#range
link

exclusiveMinimum: Number?Source

Restricts the instance value to be larger than the given number.

https://json-schema.org/understanding-json-schema/reference/numeric.html#range
link

maximum: Number?Source

Restricts the instance value to be at maximum the given number.

https://json-schema.org/understanding-json-schema/reference/numeric.html#range
link

exclusiveMaximum: Number?Source

Restricts the instance value to be smaller than the given number.

https://json-schema.org/understanding-json-schema/reference/numeric.html#range
link

pattern: String(isRegex)?Source

Restricts the instance value to a regex pattern.

The regular expression must conform to ECMA 262.

https://json-schema.org/understanding-json-schema/reference/string.html#regular-expressions
link

minLength: UInt?Source

Restricts the instance value's length to be at minimum the given number.

https://json-schema.org/understanding-json-schema/reference/string.html#length
link

maxLength: UInt?Source

Restricts the instance value's length to be at maximum the given number.

https://json-schema.org/understanding-json-schema/reference/string.html#length
link

format: ("date-time"|"time"|"date"|"email"|"idn-email"|"hostname"|"ipv4"|"ipv6"|"uri"|"uri-reference"|"iri"|"iri-reference"|"uri-template"|"json-pointer"|"relative-json-pointer"|"regex"|String)?Source

Allows for basic semantic validation on certain kinds of string values that are commonly used.

This allows values to be constrained beyond what the other tools in JSON Schema, including Regular Expressions can do.

https://json-schema.org/understanding-json-schema/reference/string.html#format
link

properties: Mapping<String, Schema>?Source

The properties (key-value pairs) on the instance value.

Each key is the name of a property and each value is a schema used to validate that property. Any property on the instance value that doesn't match any of the property names within properties is ignored.

https://json-schema.org/understanding-json-schema/reference/object.html#properties
link

patternProperties: Mapping<String(isRegex), Schema>?Source

Specifies that properties on the instance value that match the specified regular expression should conform to a certain schema.

Sometimes you want to say that, given a particular kind of property name, the value should match a particular schema. That’s where patternProperties comes in: it maps regular expressions to schemas. If a property name matches the given regular expression, the property value must validate against the corresponding schema.

https://json-schema.org/understanding-json-schema/reference/object.html#pattern-properties
link

additionalProperties: Schema?Source

Controls the handling of any properties on the instance value that are not listed within properties, or match any of the regular expressions in patternProperties.

By default, any additional properties are allowed.

Setting the additionalProperties to false means no additional properties will be allowed.

https://json-schema.org/understanding-json-schema/reference/object.html#additional-properties
link

required: Listing<String>?Source

Properties that are required to exist on the instance value.

By default, no properties are required.

The required keyword takes an array of zero or more strings. Each of these strings must be unique.

https://json-schema.org/understanding-json-schema/reference/object.html#required-properties
link

propertyNames: Schema?Source

Validate that the property names match a schema.

The type for the schema is implicitly "string".

https://json-schema.org/understanding-json-schema/reference/object.html#property-names
link

minProperties: UInt?Source

The minimum amount of properties that the instance value should have.

https://json-schema.org/understanding-json-schema/reference/object.html#size
link

maxProperties: UInt?Source

The maximum amount of properties that the instance value should have.

https://json-schema.org/understanding-json-schema/reference/object.html#size
link
items: (Schema|Listing<Schema>)?Source

Constraints on items within an array.
There are two ways in which arrays are generally used in JSON:
- List validation: a sequence of arbitrary length where each item matches the same schema.
- Tuple validation: a sequence of fixed length where each item may have a different schema. In this usage, the index (or location) of each item is meaningful as to how the value is interpreted. (This usage is often given a whole separate type in some programming languages, such as Python's tuple).
https://json-schema.org/understanding-json-schema/reference/array.html#items
link

additionalItems: Schema?Source

Controls whether it’s valid to have additional items in a tuple beyond what is defined in items.

The value of the additionalItems is a schema that all additional items must pass in order for the keyword to validate. This is ignored if there is not a “tuple validation” items keyword present in the same schema.

https://json-schema.org/understanding-json-schema/reference/array.html#addtional-items
link

contains: Schema?Source

A schema that must match at least one item within the instance array.

https://json-schema.org/understanding-json-schema/reference/array.html#contains
link

minItems: UInt?Source

Constrains the instance value's length to be at minimum the given number.

https://json-schema.org/understanding-json-schema/reference/array.html#length
link

maxItems: UInt?Source

Constrains the instance value's length to be at maximum the given number.

https://json-schema.org/understanding-json-schema/reference/array.html#length
link

uniqueItems: Boolean?Source

Specifies that each item in the instance value is unique.

https://json-schema.org/understanding-json-schema/reference/array.html#uniqueness
link

oneOf: Listing<Schema>(!isEmpty)?Source

Specifies that the value must match against exactly one of the subschemas.

https://json-schema.org/understanding-json-schema/reference/combining.html#oneof
link

anyOf: Listing<Schema>(!isEmpty)?Source

Specifies that the value must match ay least one of the subschemas.

https://json-schema.org/understanding-json-schema/reference/combining.html#anyof
link

allOf: Listing<Schema>(!isEmpty)?Source

Specifies that the value must match all of the subschemas.

https://json-schema.org/understanding-json-schema/reference/combining.html#allof
link

not: Schema?Source

The not keyword declares that an instance validates if it doesn’t validate against the given subschema.

https://json-schema.org/understanding-json-schema/reference/combining.html#not
link

_inline_: Mapping<String, Schema>?Source

Any additional properties that are JsonSchema.

Additional properties do not affect the validation of the instance value, but may be referred to using $ref.

This is a child property because Pkl modules cannot express both known names and arbitrary names.

Methods(show inherited)

link

function

getClass(): Class (pkl.base)Source

Returns the class of this.
link

function

toString(): String (pkl.base)Source

Returns a string representation of this.

This method is used to convert the values of string interpolation expressions to strings.
link

function

ifNonNull<Result>(transform: (NonNull) -> Result): Result? (pkl.base)Source

Returns this |> transform if this is non-null, and null otherwise.

This method is the complement of the ?? operator and the equivalent of an Option type's map and flatMap methods.
link

function

hasProperty(name: String): Boolean (pkl.base)Source

Tells if this object has a property with the given name.
link

function

getProperty(name: String): unknown (pkl.base)Source

Returns the value of the property with the given name.

Throws if a property with this name does not exist.
link

function

getPropertyOrNull(name: String): unknown? (pkl.base)Source

Returns the value of the property with the given name.

Returns null if a property with this name does not exist.
link

function

toDynamic(): Dynamic (pkl.base)Source

Converts this object to a Dynamic object.
link

function

toMap(): Map<String, unknown> (pkl.base)Source

Converts this object to a Map.
link

function
relativePathTo(other: Module): List<String> (pkl.base)Source

Returns the relative, descendent directory path between this module and other.
Throws if no such path exists.

For example, if module mod1 has path /dir1/mod1.pkl, and module mod2 has path /dir1/dir2/dir3/mod2.pkl, then mod1.relativePathTo(mod2) will return List("dir2", "dir3").

A common use case is to compute the directory path between a template located at the root of a hierarchy (say rootModule.pkl) and the currently evaluated module (accessible via the module keyword):
```
import "rootModule.pkl" // self-import
path = rootModule.relativePathTo(module)
```

Type Aliases

link

typealias

JsonSchemaTypeName = "string"|"number"|"integer"|"boolean"|"object"|"array"|"null"Source
link

typealias

JsonSchemaVersion = "http://json-schema.org/draft-06/schema#"|"http://json-schema.org/draft-06/schema"|"http://json-schema.org/draft-07/schema#"|"http://json-schema.org/draft-07/schema"|"https://json-schema.org/draft/2019-09/schema"|"https://json-schema.org/draft/2020-12/schema"|String Source
link

typealias

JsonSchemaValue = Boolean|Number|Null|String|Dynamic|Typed|Listing|Mapping Source
link

typealias
Schema = JsonSchema|Boolean Source

A JSON Schema can either be a JsonSchema object or a simple boolean.
A boolean schema is shorthand for:
- true: Any value is valid
- false: No value is valid