Type(schema)
|
root_map: A map with a root. Keys have to be unique. The keys can be referenced. The root cannot be referenced. The root can reference keys. |
The liquesco schema.
Root type |
|
Key type |
|
Value type |
|
Sorting |
Ascending |
Min length (inclusive) |
0 |
Max length (inclusive) |
Unsigned int 32 maximum (4,294,967,295) |
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(any_type)
|
enumeration: An enumeration (aka enum; tagged union; variant record; discriminated union) contains 1-n variants; Each variant can (optionally) have a value. |
The any type is an enumeration of all possible types available in the type system.
bool |
|
option |
|
seq |
|
binary |
|
unicode |
|
uint |
|
sint |
|
f32 |
|
f64 |
|
enum |
|
struct |
|
map |
|
root_map |
|
key_ref |
|
ascii |
|
uuid |
|
range |
|
decimal |
About
Has variants with value(s) |
Yes |
Specialization |
None |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(schema_root)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
This references the root type. The root type is the type schema validation begins with.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(identifier)
|
sequence: A sequence (aka seq; list; vector; array) describes a sequence of 0-n elements. Unlike struct fields, each element in a sequence has to be of the same type. |
An identifier identifies something in the system. An identifier is composed of 1-12 segments. Each segment is composed of ASCII characters (see segment for details what characters are allowed and about min/max length). These strict constraints allow simple conversions of identifiers to identifiers of the target system (e.g. Java class names, Rust trait names, Dart class names, …).
Element type |
|
Length minimum (inclusive) |
1 |
Length maximum (inclusive) |
12 |
Ordering |
Undefined; any ordering is allowed. |
Unique |
No (duplicates are allowed) |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(unicode)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Arbitrary unicode text. This can be used for human readable text.
meta |
|
length |
|
length_type |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(root_map)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A map with a root. Keys have to be unique. The keys can be referenced. Keys cannot reference itself. The root cannot be referenced. The root can reference keys.
meta |
|
root |
|
key |
|
value |
|
length |
|
sorting |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(uint)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Unsigned integer - maximum 128 bit.
meta |
|
range |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(seq)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A sequence contains 0-n elements of the same type.
meta |
|
element |
|
length |
|
ordering |
|
multiple_of |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(range)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A sequence contains 0-n elements of the same type.
meta |
|
element |
|
inclusion |
|
allow_empty |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(struct)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A structure is similar to a sequence but has a defined length and can contain fields of different types.
meta |
|
fields |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(map)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A sequence of key-value entries. Duplicate keys are not allowed. The keys can optionally be referenced to create recursive data structures.
meta |
|
key |
|
value |
|
length |
|
sorting |
|
anchors |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(key_ref)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps.
meta |
|
level |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(sint)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Signed integer - maximum 128 bit.
meta |
|
range |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(bool)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A boolean: Can either be true or false.
meta |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(uuid)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
16 byte UUID; RFC 4122.
meta |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(binary)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Arbitrary binary.
meta |
|
length |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(enum)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
An enumeration of variants.
meta |
|
variants |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(float_64)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A floating point number. This should be used for technical things. When working with numbers like amount of money consider using the decimal type.
meta |
|
range |
|
allow_positive_zero |
|
allow_negative_zero |
|
allow_nan |
|
allow_positive_infinity |
|
allow_negative_infinity |
|
allow_subnormal |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(option)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Can have a value (some; present) or no value (none; empty; absent).
meta |
|
type |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(ascii)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
The ascii type must not be used to transfer human readable text. It’s to be used to transfer machine readable strings. Only characters withing the ASCII range are allowed.
meta |
|
length |
|
codes |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(decimal)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A normalized decimal number. It’s composed of a signed 128 bit coefficient and a signed 8 bit exponent (c*10^e).
meta |
|
range |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(float_32)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A floating point number. This should be used for technical things. When working with numbers like amount of money consider using the decimal type.
meta |
|
range |
|
allow_positive_zero |
|
allow_negative_zero |
|
allow_nan |
|
allow_positive_infinity |
|
allow_negative_infinity |
|
allow_subnormal |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(field)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A single field in a structure. A field contains a name and a type.
name |
|
type |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(segment)
|
ascii: Ascii (aka ascii text) is a sequence of characters where each of them is within the ascii range (0-127 inclusive). It can be used to transfer technical text (aka string); it’s not to be used to transfer human readable text (use unicode for this case). |
A single segment of an identifier. An identifier can only contain certain ASCII characters and is limited in length.
Min length (inclusive; number of chars) |
1 |
Max length (inclusive; number of chars) |
30 |
Allowed code range #1 |
48 (inclusive) - 58 (exclusive); [0-9] (inclusive). |
Allowed code range #2 |
97 (inclusive) - 123 (exclusive); [a-z] (inclusive). |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(variant)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
A single variant in an enumeration.
name |
|
values |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(meta)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Meta information about the type. You can optionally provide a description/documentation and information about implementation/conformance.
doc |
|
implements |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(length_type)
|
enumeration: An enumeration (aka enum; tagged union; variant record; discriminated union) contains 1-n variants; Each variant can (optionally) have a value. |
Specifies how the length of the unicode is measured. 'byte' can be measured very efficiently - but depends on the encoding. Note: Scalar must not be confused with unicode grapheme clusters.
byte |
|
utf8_byte |
|
scalar |
About
Has variants with value(s) |
No |
Specialization |
None |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(unicode_length)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
Range element |
|
Start inclusive |
Inclusive |
End inclusive |
Inclusive |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(map_length)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The length of a map (number of elements). Both - end and start - are included.
Range element |
|
Start inclusive |
Inclusive |
End inclusive |
Inclusive |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(key)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
Type of keys in this map.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(value)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
Type of values in this map.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(map_sorting)
|
enumeration: An enumeration (aka enum; tagged union; variant record; discriminated union) contains 1-n variants; Each variant can (optionally) have a value. |
Determines the sort order of the keys in this map. You should usually use 'ascending' if not sure.
ascending |
|
descending |
About
Has variants with value(s) |
No |
Specialization |
None |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(root)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
The root type in this map.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(uint_range)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The range within the integer must be. Both (start and end) are inclusive.
Range element |
|
Start inclusive |
Inclusive |
End inclusive |
Inclusive |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(maybe_multiple_of)
|
option: Use the option type (aka maybe; optional; nullable) to describe data that can either be there ('present'; 'some') or absent ('missing'; 'empty'). Alternatively you can also use an enum with two variants to achieve the same. |
Present type |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(ordering)
|
enumeration: An enumeration (aka enum; tagged union; variant record; discriminated union) contains 1-n variants; Each variant can (optionally) have a value. |
Ordering is optional. When there’s no ordering it can be irrelevant or ordering has a special meaning. It’s also possible to specify a required sorting (in this case it’s also possible to disallow duplicates).
none |
|
sorted |
About
Has variants with value(s) |
Yes |
Specialization |
None |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(element)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
The element type of a sequence.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(seq_length)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The length of a sequence (number of elements). It’s tuple of start and end. Both - end and start - are included.
Range element |
|
Start inclusive |
Inclusive |
End inclusive |
Inclusive |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(inclusion)
|
enumeration: An enumeration (aka enum; tagged union; variant record; discriminated union) contains 1-n variants; Each variant can (optionally) have a value. |
Determines whether start and end are inclusive. There’s one special value: 'Supplied'. When you choose this, the data has to contain the information whether start/end are inclusive or not.
both_inclusive |
|
start_inclusive |
|
both_exclusive |
|
end_inclusive |
|
supplied |
About
Has variants with value(s) |
No |
Specialization |
None |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(allow_empty)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
General rule is start < end. When start equals end it’s possible to construct empty ranges (depending on the inclusion). If this is false it’s not allowed to specify a range that’s empty. You usually want this to be false.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(range_element)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
The start and end type of the range.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(fields)
|
sequence: A sequence (aka seq; list; vector; array) describes a sequence of 0-n elements. Unlike struct fields, each element in a sequence has to be of the same type. |
A sequence of fields in a structure.
Element type |
|
Length minimum (inclusive) |
0 |
Length maximum (inclusive) |
Unsigned int 32 maximum (4,294,967,295) |
Ordering |
Undefined; any ordering is allowed. |
Unique |
No (duplicates are allowed) |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(map_value)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
Type of values in this map.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(map_key)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
Type of keys in this map.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(anchors)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
If this is true, the keys in this map can be referenced using key refs. Note: Only values can reference keys. Keys cannot reference itself.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(level)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Specifies which outer map you want to reference. This is usually 0: In this case you reference keys from the next outer map. Note: Those map that do not provide anchors that can be referenced are ignored.
Min value (inclusive) |
0 |
Max value (inclusive) |
Unsigned int 32 maximum (4,294,967,295) |
Memory width |
32 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(sint_range)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The range within the integer must be. Both (start and end) are inclusive.
Range element |
|
Start inclusive |
Inclusive |
End inclusive |
Inclusive |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(binary_length)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
Range element |
|
Start inclusive |
Inclusive |
End inclusive |
Inclusive |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(variants)
|
sequence: A sequence (aka seq; list; vector; array) describes a sequence of 0-n elements. Unlike struct fields, each element in a sequence has to be of the same type. |
Every enumeration has to have one or more variants (just one usually makes no sense but can be used to allow extension in future).
Element type |
|
Length minimum (inclusive) |
1 |
Length maximum (inclusive) |
Unsigned int 32 maximum (4,294,967,295) |
Ordering |
Undefined; any ordering is allowed. |
Unique |
No (duplicates are allowed) |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(allow_negative_infinity)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
This is true if negative infinity is allowed. When the negative infinity is hit, range check is skipped.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(allow_subnormal)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
If this is true, subnormal (denormal) numbers are allowed (excluding the special case for +/- zero). You usually want this to be false. Range check is also performed for subnormal numbers.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(allow_positive_infinity)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
This is true if positive infinity is allowed. When the positive infinity is hit, range check is skipped.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(allow_negative_zero)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
If this is true, the subnormal negative zero value is allowed. This should usually be false. When e negative zero value is hit, range check is skipped.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(float_64_range)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The range the float must be contained within. Note: Only normal numbers are allowed (so no subnormal numbers and NaN are supported); so for example to support floats >=0, set start to smallest positive number (inclusive), allow positive zeros and (optionally) allow subnormal numbers.
Range element |
|
Start inclusive |
Supplied (by data) |
End inclusive |
Supplied (by data) |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(allow_positive_zero)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
If this is true, the subnormal positive zero value is allowed. When a positive zero is hit, range check is skipped.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(allow_nan)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
This is true if NaN ('not a number') is allowed. This should usually be false. When a NaN is hit, range check is skipped.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(present_type)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
Type of the present value in an option.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(codes)
|
sequence: A sequence (aka seq; list; vector; array) describes a sequence of 0-n elements. Unlike struct fields, each element in a sequence has to be of the same type. |
Use this sequence to supply allowed ASCII code ranges. It takes pairs of ASCII codes (start, end); start is inclusive, end is exclusive. The ASCII string is valid if every character of the ASCII string is within one of those ranges.
Element type |
|
Length minimum (inclusive) |
2 |
Length maximum (inclusive) |
64 |
Length multiple of |
2 |
Ordering |
Ascending sorting is required |
Unique |
Yes (only unique elements) |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(ascii_length)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The length constraint of the ASCII string (also number of bytes). Start and end are both inclusive.
Range element |
|
Start inclusive |
Inclusive |
End inclusive |
Inclusive |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(decimal_range)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The range the decimal number must be contained within.
Range element |
|
Start inclusive |
Supplied (by data) |
End inclusive |
Supplied (by data) |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(float_32_range)
|
range: A range (start - end); start/end with configurable inclusion/exclusion. |
The range the float must be contained within. Note: Only normal numbers are allowed (so no subnormal numbers and NaN are supported); so for example to support floats >=0, set start to smallest positive number (inclusive), allow positive zeros and (optionally) allow subnormal numbers.
Range element |
|
Start inclusive |
Supplied (by data) |
End inclusive |
Supplied (by data) |
Allow empty range |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(field_type)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(maybe_values)
|
option: Use the option type (aka maybe; optional; nullable) to describe data that can either be there ('present'; 'some') or absent ('missing'; 'empty'). Alternatively you can also use an enum with two variants to achieve the same. |
Enumeration variants have usually either no value (in this case this is absent) or one value.
Present type |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(maybe_doc)
|
option: Use the option type (aka maybe; optional; nullable) to describe data that can either be there ('present'; 'some') or absent ('missing'; 'empty'). Alternatively you can also use an enum with two variants to achieve the same. |
Optional type description / documentation.
Present type |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(maybe_implements)
|
option: Use the option type (aka maybe; optional; nullable) to describe data that can either be there ('present'; 'some') or absent ('missing'; 'empty'). Alternatively you can also use an enum with two variants to achieve the same. |
Present type |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(unicode_length_element)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Min value (inclusive) |
0 |
Max value (inclusive) |
Unsigned int 64 maximum (18,446,744,073,709,551,615) |
Memory width |
64 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(map_length_element)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Min value (inclusive) |
0 |
Max value (inclusive) |
Unsigned int 32 maximum (4,294,967,295) |
Memory width |
32 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(uint_range_element)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Min value (inclusive) |
0 |
Max value (inclusive) |
Unsigned int 128 maximum |
Memory width |
128 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(multiple_of)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
It’s possible to specify another requirement on the length of the list (number of elements). If this is for example 2, only lengths of 0, 2, 4, 6, 8, … are allowed.
Min value (inclusive) |
2 |
Max value (inclusive) |
Unsigned int 32 maximum (4,294,967,295) |
Memory width |
32 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(sorting)
|
structure: A structure (aka struct) contains 0-n fields. The fields do not need to be of the same type. |
Determines how the sequence needs to be sorted and whether duplicate elements are allowed.
direction |
|
unique |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(seq_length_element)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Min value (inclusive) |
0 |
Max value (inclusive) |
Unsigned int 32 maximum (4,294,967,295) |
Memory width |
32 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(sint_range_element)
|
signed integer: Data of signed integer (aka sint or signed int) holds a single (positive or negative) integer value (within a defined range). |
Min value (inclusive) |
Unsigned int 128 minimum |
Max value (inclusive) |
Unsigned int 128 maximum |
Memory width |
128 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(binary_length_element)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Min value (inclusive) |
0 |
Max value (inclusive) |
Unsigned int 64 maximum (18,446,744,073,709,551,615) |
Memory width |
64 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(float_64_range_element)
|
float64: A IEEE 754 64 bit float number. Do not use this to transfer decimal values. |
The start or end of the float range bounds. Note: Whether this is included or not can be defined.
Min value |
Float minimum value |
Min included |
Yes |
Max value |
Float maximum value |
Max included |
Yes |
Allow positive zero |
No |
Allow negative zero |
No |
Allow NaN (not a number) |
No |
Allow positive infinity |
No |
Allow negative infinity |
No |
Allow subnormal |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(ascii_code)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Min value (inclusive) |
0 |
Max value (inclusive) |
128 |
Memory width |
8 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(ascii_length_element)
|
unsigned integer: Data of an unsigned integer (aka uint or unsigned int) holds a single (positive) integer value (within a defined range). |
Min value (inclusive) |
0 |
Max value (inclusive) |
Unsigned int 64 maximum (18,446,744,073,709,551,615) |
Memory width |
64 bits |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(decimal_range_element)
|
decimal: A normalized decimal number. It’s composed of a signed 128 bit coefficient (at max) and a signed 8 bit exponent (at max) (c*10^e). |
The start or end of the decimal range bounds. Note: Whether this is included or not can be defined.
Minimum (inclusive) |
Decimal minimum value |
Maximum (inclusive) |
Decimal maximum value |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(float_32_range_element)
|
float32: A IEEE 754 32 bit float number. Do not use this to transfer decimal values. |
The start or end of the float range bounds. Note: Whether this is included or not can be defined.
Min value |
Float minimum value |
Min included |
Yes |
Max value |
Float maximum value |
Max included |
Yes |
Allow positive zero |
No |
Allow negative zero |
No |
Allow NaN (not a number) |
No |
Allow positive infinity |
No |
Allow negative infinity |
No |
Allow subnormal |
No |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(values)
|
sequence: A sequence (aka seq; list; vector; array) describes a sequence of 0-n elements. Unlike struct fields, each element in a sequence has to be of the same type. |
Defines the one (or in rare cases more) value the enumeration variant takes. You should only have two or more values when variant got extended - do not use more than one value in the initial schema design.
Element type |
|
Length minimum (inclusive) |
1 |
Length maximum (inclusive) |
32 |
Ordering |
Undefined; any ordering is allowed. |
Unique |
No (duplicates are allowed) |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(documentation)
|
unicode: The unicode type (aka string) can be used to describe arbitrary human readable text. |
Describes / documents the type. Use human readable text. No markup is allowed.
Length type |
Number of UTF-8 bytes (needs to compute the length when encoding is not UTF-8) |
Minimum length (inclusive) |
1 |
Maximum length (inclusive) |
4,000 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(implements)
|
sequence: A sequence (aka seq; list; vector; array) describes a sequence of 0-n elements. Unlike struct fields, each element in a sequence has to be of the same type. |
A sequence of 'things' this type implements. What can this be used for? Say for example your type is an ASCII type. With that information we can’t really say what ASCII is for. Say for example that ASCII has a special meaning in your company: It’s a part number. So you can give that ASCII type a UUID to declare 'this type is a part number'. This makes it possible to find part numbers company wide.
Element type |
|
Length minimum (inclusive) |
1 |
Length maximum (inclusive) |
Unsigned int 8 maximum (255) |
Ordering |
Ascending sorting is required |
Unique |
Yes (only unique elements) |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(unique)
|
boolean: Data of type boolean (aka bool) can hold the value 'true' or the value 'false' (1 or 0; on or off; enabled or disabled). It’s like a single bit of information. As an alternative you an also use an enum with 2 variants (it’s usually better suited in most cases) |
When this is true, no duplicate elements are allowed in the sequence. This automatically implies a sorted sequence.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(direction)
|
enumeration: An enumeration (aka enum; tagged union; variant record; discriminated union) contains 1-n variants; Each variant can (optionally) have a value. |
Determines how the elements in the sequence need to be sorted for the sequence to be valid.
ascending |
|
descending |
About
Has variants with value(s) |
No |
Specialization |
None |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(value_type)
|
key_ref: Key references can reference keys from outer types that supports references (provide anchors that can be referenced): Maps and RootMaps. |
Value type in an enum variant.
Level |
0 |
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|
Type(implements_uuid)
|
uuid: 16 byte UUID; RFC 4122. |
UUID to describe the conformance / implementation / protocol of this type uniquely.
This type is used by
Hashes
Full hash |
|
Technical hash |
|
Type hash |
|