Inferal Type System Ontology

The Inferal Type System Ontology defines RDF terms for scalar, structured, literal, union, enum, callable, template, value, scalar initializer, and type-relation facts.

Prefix	IRI
`ts`	`https://ontology.inferal.com/modules/type-system/`
`skos`	`http://www.w3.org/2004/02/skos/core#`

Term	Kind	Normative role
`ts:Entity`	Class	Base class for resources in a type-system graph.
`ts:Vocabulary`	Class	A named collection of type-system declarations.
`ts:Namespace`	Class	A semantic grouping scope for declarations.
`ts:Declaration`	Class	A named binding for a type-system resource.
`ts:TypeDeclaration`	Class	A declaration whose resource is a type.
`ts:ValueDeclaration`	Class	A declaration whose resource is a value.
`ts:AliasDeclaration`	Class	A declaration whose resource is an alias.
`ts:Alias`	Class	A shorthand resource that points at another type-system resource.

Family	Classes	Notes
Root	`ts:Type`, `ts:DataType`, `ts:AnonymousTypeExpression`	Every type resource is a `ts:Type`; inline expressions additionally use the anonymous expression class.
Intrinsic	`ts:IntrinsicType`, `ts:UnknownType`, `ts:AnyType`, `ts:VoidType`, `ts:NeverType`, `ts:NullType`, `ts:ErrorType`	Built-in top, permissive, bottom, absence, null, and error value spaces.
Scalar	`ts:Scalar`, `ts:StringType`, `ts:UrlType`, `ts:BytesType`, `ts:BooleanType`, `ts:NumericType`, `ts:IntegerType`, `ts:FloatType`, `ts:DecimalType`	Atomic primitive or user-defined value spaces.
Temporal	`ts:TemporalType`, `ts:DateType`, `ts:TimeType`, `ts:DateTimeType`, `ts:DurationType`, `ts:TemporalKind`, `ts:TemporalZoneSemantics`	Calendar, clock, date-time, duration, and zone semantics.

Term	Kind	Normative role
`ts:StructuredType`	Class	A data type with child slots, positions, keys, or alternatives.
`ts:CollectionType`	Class	A structured type whose values contain ordered or keyed child values.
`ts:RecordType`	Class	A structured type with named fields.
`ts:RecordExpression`	Class	An anonymous record type expression.
`ts:RecordMapType`	Class	A record-compatible keyed value space.
`ts:OptionRecordType`	Class	A record used as typed options or parameter bags.
`ts:ArrayType`	Class	An ordered collection with a common element type.
`ts:ArrayExpression`	Class	An anonymous array type expression.
`ts:TupleType`	Class	An ordered collection with position-specific element types.
`ts:TupleExpression`	Class	An anonymous tuple type expression.
`ts:StreamType`	Class	A collection type whose values are delivered over time.
`ts:IntersectionType`	Class	A type that combines constituent type requirements.
`ts:IntersectionExpression`	Class	An anonymous intersection type expression.
`ts:TypedSlot`	Class	A named, keyed, ordered, or otherwise addressable type-bearing slot.
`ts:Field`	Class	A typed named slot in a record type.
`ts:FieldKey`	Class	The key by which a field is addressed.
`ts:FieldKeyKind`	Class	A controlled category for field key spelling.
`ts:TupleElement`	Class	One ordered element of a tuple type.
`ts:IndexerSlot`	Class	A typed lookup slot on an array or map-like type.

Term	Kind	Normative role
`ts:Union`	Class	A type that admits values from one or more alternatives.
`ts:UnionExpression`	Class	An anonymous union type expression.
`ts:NullableType`	Class	A union whose alternatives include null and one non-null base type.
`ts:UnionAlternative`	Class	One ordered alternative of a union type.
`ts:UnionVariant`	Class	A named union alternative that can be referenced as a type.
`ts:Discriminator`	Class	A type-level selector that distinguishes alternatives.
`ts:DiscriminatorEnvelope`	Class	A controlled discriminator placement strategy.
`ts:Enum`	Class	A type with a finite set of named members.
`ts:EnumMember`	Class	One named member of an enum type.

Family	Terms	Normative role
Callables	`ts:CallableType`, `ts:CallableSetType`, `ts:InterfaceType`, `ts:CallableSetMembership`, `ts:ParameterSlot`, `ts:ResultSlot`	Callable signatures, callable groups, and typed input/output slots.
Templates	`ts:TemplateParameter`, `ts:TypeParameter`, `ts:ValueParameter`, `ts:TypeOrValueParameter`, `ts:TemplateInstantiation`, `ts:TemplateArgument`, `ts:TypeArgument`, `ts:ValueArgument`	Generic type-system resources, supplied arguments, and instantiation results.
Type-level expressions	`ts:ValueOfType`, `ts:TypeOfValue`	Value-space constraints and type expressions derived from values.

Family	Terms	Normative role
Literal types	`ts:LiteralType`, `ts:LiteralKind`, `ts:StringLiteralType`, `ts:StringTemplateLiteralType`, `ts:StringTemplatePart`, `ts:NumericLiteralType`, `ts:BooleanLiteralType`, `ts:NullLiteralType`, `ts:EnumMemberReferenceLiteralType`, `ts:UnionVariantReferenceLiteralType`	Exact literal value spaces and member-reference literal types.
Values	`ts:Value`, `ts:ConstValue`, `ts:ScalarValue`, `ts:StringValue`, `ts:NumericValue`, `ts:BooleanValue`, `ts:NullValue`, `ts:EnumValue`, `ts:ObjectValue`, `ts:ObjectValueMember`, `ts:ArrayValue`, `ts:ArrayValueItem`	Concrete values and exact inferred object or array shapes.

Term	Kind	Normative role
`ts:TypeRelation`	Class	A first-class assertion about two types.
`ts:AssignableTypeRelation`	Class	The source can be assigned to the target.
`ts:SubtypeRelation`	Class	The source is a subtype of the target.
`ts:ExactTypeRelation`	Class	The source and target have the same inhabited shape or value space.
`ts:NonAssignableTypeRelation`	Class	The source cannot be assigned to the target.
`ts:TypeRelationEvidence`	Class	Evidence attached to a first-class relation.
`ts:FieldMatch`	Class	Evidence comparing one source field to one target field.
`ts:AlternativeMatch`	Class	Evidence comparing source and target union alternatives.
`ts:TupleElementMatch`	Class	Evidence comparing source and target tuple elements.
`ts:CollectionElementTypeMatch`	Class	Evidence comparing collection element value spaces.

Class Model

This section documents each class in the type-system ontology in its own section. Classes are grouped by modeling role rather than listed alphabetically, so nearby sections show the relationships that matter when reading or authoring a graph. Examples use the same prefixes as examples.ttl: ex: for illustrative resources, ts: for this ontology, and skos: for preferred labels.

Core Identity And Declarations

These classes describe resources, declaration scopes, preferred names, aliases, and the binding between a name and the entity it denotes. They are how the ontology represents the naming layer that languages usually hide in modules, packages, imports, exports, schema registries, or namespaces.

export type CustomerId = string;
export { CustomerId as Id };

CustomerId = str
Id = CustomerId

CREATE DOMAIN customer_id AS text;

`ts:Entity`

A resource that participates in a type-system graph.

ts:Entity is the common resource class for anything that needs identity inside a type-system graph. Use it for shared metadata such as skos:prefLabel and for generic containment links before a resource is narrowed to a type, value, declaration, slot, or evidence class.

Modeling Notes

ts:Entity is a root class in the type-system module.
Direct subclasses: ts:Alias, ts:AlternativeMatch, ts:ArrayValueItem, ts:CallableSetMembership, ts:CollectionElementTypeMatch, ts:Declaration, ts:Discriminator, and 20 more.
Primary outgoing properties: ts:booleanValue, ts:defaultValue, ts:hasDeclaration, ts:hasTemplateParameter, ts:hasTypeOrValueParameter, ts:hasTypeParameter, ts:hasValueParameter, and 5 more.
Commonly referenced by: ts:aliasTarget, ts:argumentExpression, ts:declares, and ts:instantiates.

ex:Customer
    a ts:Entity ;
    skos:prefLabel "Customer" .

`ts:Vocabulary`

A named collection of type-system declarations.

Use ts:Vocabulary for a named package of declarations that should travel together as a vocabulary unit. Its main job is ownership: it gathers ts:Declaration resources with ts:hasDeclaration without saying that the vocabulary itself is a type.

Modeling Notes

ts:Vocabulary is a subclass of ts:Entity.

ex:TypeVocabulary
    a ts:Vocabulary ;
    ts:hasDeclaration ex:CustomerDeclaration .

`ts:Namespace`

A semantic grouping scope for declarations.

Use ts:Namespace when declarations need a semantic grouping scope inside or across vocabularies. It is lighter than ts:Vocabulary: it organizes bindings with ts:hasDeclaration but does not imply a publication package.

Modeling Notes

ts:Namespace is a subclass of ts:Entity.

ex:CommerceNamespace
    a ts:Namespace ;
    ts:hasDeclaration ex:CustomerDeclaration .

`ts:Declaration`

A named binding for a type, value, alias, or namespace-local resource.

Use ts:Declaration for the binding between a preferred name and the resource that name denotes. The declaration carries the name with skos:prefLabel and points at the bound resource with ts:declares.

Modeling Notes

ts:Declaration is a subclass of ts:Entity.
Direct subclasses: ts:AliasDeclaration, ts:TypeDeclaration, and ts:ValueDeclaration.
Primary outgoing properties: ts:declares.
Commonly referenced by: ts:hasDeclaration.

ex:CustomerDeclaration
    a ts:Declaration ;
    skos:prefLabel "Customer" ;
    ts:declares ex:Customer .

`ts:TypeDeclaration`

A named declaration whose declared resource is a type.

Use ts:TypeDeclaration when the declared resource is a ts:Type. This separates the named binding from the type node, which lets the same type resource participate in aliases, namespaces, and relation evidence.

Modeling Notes

ts:TypeDeclaration is a subclass of ts:Declaration.

ex:CustomerDeclaration
    a ts:TypeDeclaration ;
    skos:prefLabel "Customer" ;
    ts:declares ex:Customer .

`ts:ValueDeclaration`

A named declaration whose declared resource is a value.

Use ts:ValueDeclaration when the declared resource is a ts:Value. This is the declaration form for constants, defaults, enum values, or other graph values that need a preferred referential name.

Modeling Notes

ts:ValueDeclaration is a subclass of ts:Declaration.

ex:DefaultCurrencyDeclaration
    a ts:ValueDeclaration ;
    skos:prefLabel "defaultCurrency" ;
    ts:declares ex:default-currency .

`ts:AliasDeclaration`

A named declaration whose declared resource is an alias.

Use ts:AliasDeclaration when the declared resource is an ts:Alias. The declaration names the alias itself, while ts:aliasTarget on the alias identifies the resource being abbreviated.

Modeling Notes

ts:AliasDeclaration is a subclass of ts:Declaration.

ex:CustomerIdDeclaration
    a ts:AliasDeclaration ;
    skos:prefLabel "CustomerId" ;
    ts:declares ex:CustomerIdAlias .

`ts:Alias`

A type-system shorthand that points at another type-system resource.

Use ts:Alias for a first-class shorthand that points to another type-system resource. Model the shortcut as an entity so it can have its own preferred label, declaration, and target through ts:aliasTarget.

Modeling Notes

ts:Alias is a subclass of ts:Entity.
Primary outgoing properties: ts:aliasTarget.

ex:CustomerIdAlias
    a ts:Alias ;
    skos:prefLabel "CustomerId" ;
    ts:aliasTarget ex:Id .

Type Roots And Intrinsics

These classes form the top of the type hierarchy and the built-in value-space markers used by downstream type facts. They let a graph preserve distinctions such as unknown versus permissive any, void versus null, and bottom types such as never.

unknown | any | void | never | null

Any | None | NoReturn

()  // unit
!   // never

`ts:Type`

A value type assignable to fields, parameters, results, collection elements, alternatives, enum members, template parameters, or values.

ts:Type is the root for resources that can stand in type position: fields, parameters, results, alternatives, enum members, values, and template constraints can all refer to it. Use direct subclasses to say what kind of value space the type represents.

Modeling Notes

ts:Type is a subclass of ts:Entity.
Direct subclasses: ts:AnonymousTypeExpression, ts:CallableSetType, ts:CallableType, ts:DataType, ts:EnumMember, ts:ErrorType, ts:IntrinsicType, and 5 more.
Primary outgoing properties: ts:admittedByUnion, ts:assignableTo, ts:isAnonymous, ts:isBuiltInType, ts:isExactType, ts:isUserDefinedType, ts:maxItems, and 6 more.
Commonly referenced by: ts:additionalPropertyType, ts:alternativeType, ts:argumentType, ts:arrayValueType, ts:assignableTo, ts:declaredType, ts:elementType, and 27 more.

ex:Customer
    a ts:Type ;
    skos:prefLabel "Customer" .

`ts:DataType`

A type that describes data values.

Use ts:DataType for types that describe data values rather than callables, template projections, or error/result markers. Scalars, records, unions, enums, streams, and structured collections specialize this class.

Modeling Notes

ts:DataType is a subclass of ts:Type.
Direct subclasses: ts:Enum, ts:Scalar, ts:StreamType, ts:StructuredType, ts:TypeParameter, and ts:Union.

ex:Customer
    a ts:DataType ;
    skos:prefLabel "Customer" .

`ts:AnonymousTypeExpression`

An inline type expression that has no declaration name of its own.

Use ts:AnonymousTypeExpression for inline type expressions that are not declaration-named. Combine it with a concrete expression class such as ts:RecordExpression or ts:UnionExpression and mark the node with ts:isAnonymous when useful.

Modeling Notes

ts:AnonymousTypeExpression is a subclass of ts:Type.
Direct subclasses: ts:ArrayExpression, ts:IntersectionExpression, ts:RecordExpression, ts:TupleExpression, and ts:UnionExpression.

ex:inline-customer-shape
    a ts:RecordExpression, ts:AnonymousTypeExpression ;
    ts:isAnonymous true .

`ts:IntrinsicType`

A built-in type supplied by the type system.

Use ts:IntrinsicType for built-in type-system resources supplied by the ontology or processor. It distinguishes built-ins such as ts:UnknownType and ts:AnyType from user-defined declarations without relying on spelling conventions.

Modeling Notes

ts:IntrinsicType is a subclass of ts:Type.
Direct subclasses: ts:AnyType, ts:NeverType, ts:NullType, ts:UnknownType, and ts:VoidType.

ts:string
    a ts:StringType, ts:IntrinsicType ;
    skos:prefLabel "string" .

`ts:UnknownType`

An intrinsic placeholder for values whose specific type is unknown or unresolved.

Use ts:UnknownType when a value has a type position but the specific value space is not known. It is useful as a conservative marker for template parameters, incomplete schemas, and relation targets without asserting that every built-in type is its subtype.

Modeling Notes

ts:UnknownType is a subclass of ts:IntrinsicType.

ts:unknown
    a ts:UnknownType ;
    skos:prefLabel "unknown" .

`ts:AnyType`

An intrinsic type that suppresses normal assignability precision.

Use ts:AnyType when the graph intentionally suppresses normal precision. Unlike ts:UnknownType, it represents a permissive escape hatch where assignability checks should not preserve detailed type information.

Modeling Notes

ts:AnyType is a subclass of ts:IntrinsicType.

ts:any
    a ts:AnyType ;
    skos:prefLabel "any" .

`ts:VoidType`

The absence of a result value.

Use ts:VoidType for callable results that intentionally return no value. It keeps “no result” in type position without modeling that absence as ts:NullType or as an omitted result slot.

Modeling Notes

ts:VoidType is a subclass of ts:IntrinsicType.

ts:void
    a ts:VoidType ;
    skos:prefLabel "void" .

`ts:NeverType`

The bottom type that no value can inhabit.

Use ts:NeverType for an uninhabited value space. It is the right marker for impossible alternatives, unreachable result positions, and relation evidence that needs a bottom type.

Modeling Notes

ts:NeverType is a subclass of ts:IntrinsicType.

ts:never
    a ts:NeverType ;
    skos:prefLabel "never" .

`ts:NullType`

The type inhabited by null.

Use ts:NullType for the type whose only inhabitant is null. Nullable shapes should usually use ts:NullableType to pair this null alternative with a non-null base type.

Modeling Notes

ts:NullType is a subclass of ts:IntrinsicType.

ts:null
    a ts:NullType ;
    skos:prefLabel "null" .

`ts:ErrorType`

A type that denotes an error case in a typed result space.

Use ts:ErrorType when an error case itself must appear in type position, for example in a typed result space. It is a ts:Type rather than a runtime exception model.

Modeling Notes

ts:ErrorType is a subclass of ts:Type.

ex:ParseError
    a ts:ErrorType ;
    skos:prefLabel "ParseError" .

Scalar And Temporal Types

These classes describe atomic value spaces, numeric refinement, temporal kinds, and zone or offset semantics. They keep language scalar names, numeric widths, decimal precision, and temporal semantics as explicit facts instead of relying on a lossy primitive string.

type CustomerId = string;
type CreatedAt = Date;
type Amount = number;

CustomerId = NewType("CustomerId", str)
created_at: datetime
amount: Decimal

struct CustomerId(String);
created_at: chrono::DateTime<chrono::Utc>
amount: rust_decimal::Decimal

`ts:Scalar`

An atomic primitive or user-defined value type.

ts:Scalar is the base for atomic value spaces. Use ts:baseScalar and ts:standardBaseScalar to describe refinements, and attach ts:ScalarInitializer resources when construction or parsing is part of the scalar contract.

Modeling Notes

ts:Scalar is a subclass of ts:DataType.
Direct subclasses: ts:BooleanType, ts:BytesType, ts:NumericType, ts:StringType, and ts:TemporalType.
Primary outgoing properties: ts:baseScalar, ts:hasInitializer, and ts:standardBaseScalar.
Commonly referenced by: ts:baseScalar, ts:initializerResult, and ts:standardBaseScalar.

ex:Id
    a ts:Scalar ;
    ts:baseScalar ts:string ;
    ts:standardBaseScalar ts:string .

`ts:StringType`

A scalar textual string type.

Use ts:StringType for textual scalar value spaces. Refined string-like domains can point back to ts:string with ts:baseScalar and use length facets when the allowed lexical space is constrained.

Language analogs: TypeScript string, Python str, Rust String or &str, GraphQL String, JSON Schema { "type": "string" }.

Modeling Notes

ts:StringType is a subclass of ts:Scalar.
Direct subclasses: ts:UrlType.

ex:Id
    a ts:StringType ;
    ts:baseScalar ts:string ;
    ts:standardBaseScalar ts:string .

`ts:UrlType`

A string-like scalar constrained to URL values.

Use ts:UrlType for URL-constrained textual scalars. It remains a ts:StringType, so string facets and string assignability still apply while URL-specific meaning is explicit.

Modeling Notes

ts:UrlType is a subclass of ts:StringType.

ex:WebhookUrl
    a ts:UrlType ;
    ts:baseScalar ts:url ;
    ts:standardBaseScalar ts:url .

`ts:BytesType`

A scalar byte-sequence type.

Use ts:BytesType for byte-sequence scalars. Length facets such as ts:minLength and ts:maxLength describe fixed-size hashes, keys, or binary payload identifiers.

Modeling Notes

ts:BytesType is a subclass of ts:Scalar.

ex:Digest
    a ts:BytesType ;
    ts:minLength 32 ;
    ts:maxLength 32 .

`ts:BooleanType`

A scalar boolean type.

Use ts:BooleanType for true-or-false scalar value spaces. Boolean values should refer to a boolean type through ts:declaredType or ts:inferredType, not through string or enum encodings.

Language analogs: TypeScript boolean, Python bool, Rust bool, GraphQL Boolean, JSON Schema { "type": "boolean" }.

Modeling Notes

ts:BooleanType is a subclass of ts:Scalar.

ex:EnabledFlag
    a ts:BooleanType ;
    ts:standardBaseScalar ts:boolean .

`ts:NumericType`

A scalar numeric type.

ts:NumericType is the common parent for integer, floating, and decimal scalar spaces. Use it for shared numeric facets such as bounds, radix, precision, and widening relationships.

Modeling Notes

ts:NumericType is a subclass of ts:Scalar.
Direct subclasses: ts:DecimalType, ts:FloatType, and ts:IntegerType.
Primary outgoing properties: ts:maxExponent, ts:minExponent, ts:numericBitWidth, ts:numericMaxFiniteMagnitude, ts:numericMinFiniteMagnitude, ts:numericPrecisionDigits, ts:numericRadix, and 1 more.
Commonly referenced by: ts:numericRangeAssignableTo.

ex:Quantity
    a ts:NumericType ;
    ts:minValue 0 .

`ts:IntegerType`

A whole-number scalar type.

Use ts:IntegerType for whole-number numeric spaces. Built-ins such as ts:int32 and ts:uint64 combine this class with range and bit-width facets.

Language analogs: TypeScript number with integer constraints, Python int, Rust i64 or u64, GraphQL Int, JSON Schema { "type": "integer" }.

Modeling Notes

ts:IntegerType is a subclass of ts:NumericType.

ex:CustomerCount
    a ts:IntegerType ;
    ts:baseScalar ts:integer ;
    ts:minValue 0 .

`ts:FloatType`

A floating-point scalar type.

Use ts:FloatType for approximate floating-point spaces. Precision, radix, exponent, and finite-magnitude facets describe the representation when the graph needs more detail than “number”.

Language analogs: TypeScript number, Python float, Rust f64, GraphQL Float, JSON Schema { "type": "number" }.

Modeling Notes

ts:FloatType is a subclass of ts:NumericType.

ex:Score
    a ts:FloatType ;
    ts:numericRadix 2 .

`ts:DecimalType`

A decimal scalar type.

Use ts:DecimalType for base-10 numeric spaces where decimal precision matters. This class is appropriate for money, measurements, and fixed or arbitrary precision decimal values.

Language analogs: Python decimal.Decimal, Rust Decimal from decimal crates, database DECIMAL or NUMERIC, and JSON Schema numeric strings or numbers with precision constraints.

Modeling Notes

ts:DecimalType is a subclass of ts:NumericType.

ex:MoneyAmount
    a ts:DecimalType ;
    ts:numericRadix 10 ;
    ts:numericPrecisionDigits 34 .

`ts:TemporalType`

A scalar date, time, date-time, or duration type.

ts:TemporalType groups scalar date, time, date-time, and duration spaces. Use ts:temporalKind and ts:temporalZoneSemantics to make calendar and zone semantics explicit.

Modeling Notes

ts:TemporalType is a subclass of ts:Scalar.
Direct subclasses: ts:DateTimeType, ts:DateType, ts:DurationType, and ts:TimeType.
Primary outgoing properties: ts:temporalKind and ts:temporalZoneSemantics.

ex:BusinessTime
    a ts:TemporalType ;
    ts:temporalKind ts:clockTimeTemporalKind .

`ts:DateType`

A scalar calendar date type.

Use ts:DateType for calendar-date values without clock-time semantics. Pair it with ts:calendarDateTemporalKind and, where needed, a zone-semantics individual such as ts:noZoneTemporalSemantics.

Language analogs: Python datetime.date, JavaScript date-only strings, Rust chrono::NaiveDate, SQL DATE, JSON Schema format: date.

Modeling Notes

ts:DateType is a subclass of ts:TemporalType.

ex:BirthDate
    a ts:DateType ;
    ts:temporalKind ts:calendarDateTemporalKind .

`ts:TimeType`

A scalar clock time type.

Use ts:TimeType for clock-time values. It should describe a time-of-day value space rather than a timestamp or duration.

Modeling Notes

ts:TimeType is a subclass of ts:TemporalType.

ex:StoreOpeningTime
    a ts:TimeType ;
    ts:temporalKind ts:clockTimeTemporalKind .

`ts:DateTimeType`

A scalar instant or date-time type.

Use ts:DateTimeType for instant or date-time value spaces. Zone semantics distinguish UTC-normalized date-times from values that preserve an explicit offset.

Language analogs: Python datetime.datetime, JavaScript ISO timestamp strings or Date, Rust DateTime, SQL TIMESTAMP, JSON Schema format: date-time.

Modeling Notes

ts:DateTimeType is a subclass of ts:TemporalType.

ex:CreatedAt
    a ts:DateTimeType ;
    ts:temporalKind ts:dateTimeTemporalKind ;
    ts:temporalZoneSemantics ts:utcTemporalSemantics .

`ts:DurationType`

A scalar duration or time-period type.

Use ts:DurationType for duration or period value spaces. It represents elapsed or relative time rather than calendar dates or clock instants.

Language analogs: Python datetime.timedelta, JavaScript duration strings or millisecond counts, Rust std::time::Duration, and ISO 8601 duration literals.

Modeling Notes

ts:DurationType is a subclass of ts:TemporalType.

ex:RetentionPeriod
    a ts:DurationType ;
    ts:temporalKind ts:durationTemporalKind .

`ts:TemporalKind`

A controlled value-space category for temporal scalars.

Use ts:TemporalKind individuals as controlled categories for temporal scalars. They let validators and processors distinguish date, time, date-time, and duration behavior without parsing a label.

Modeling Notes

ts:TemporalKind is a subclass of ts:Entity.
Commonly referenced by: ts:temporalKind.

ts:calendarDateTemporalKind
    a ts:TemporalKind ;
    skos:prefLabel "calendarDate" .

`ts:TemporalZoneSemantics`

A controlled description of whether a temporal scalar carries zone or offset semantics.

Use ts:TemporalZoneSemantics individuals to state whether a temporal scalar has no zone, UTC semantics, explicit offset semantics, or no applicable zone concept.

Modeling Notes

ts:TemporalZoneSemantics is a subclass of ts:Entity.
Commonly referenced by: ts:temporalZoneSemantics.

ts:utcTemporalSemantics
    a ts:TemporalZoneSemantics ;
    skos:prefLabel "utc" .

Structured And Collection Types

These classes describe records, arrays, tuples, intersections, and the type-bearing slots that give those structures shape. They model child positions and keys separately from the container so field matching, tuple matching, and additional-property behavior can be explained.

type Customer = { id: string; labels: string[] };
type Coordinate = [number, number];

class Customer(TypedDict):
    id: str
    labels: list[str]

Coordinate = tuple[float, float]

{
  "type": "array",
  "prefixItems": [{ "type": "number" }, { "type": "number" }]
}

`ts:StructuredType`

A data type with child slots, positions, keys, or alternatives.

ts:StructuredType is the parent for value spaces with internal shape: fields, positions, keys, constituents, or alternatives. Use its concrete subclasses to say which structural mechanism defines the values.

Modeling Notes

ts:StructuredType is a subclass of ts:DataType.
Direct subclasses: ts:CollectionType, ts:IntersectionType, and ts:RecordType.

ex:Customer
    a ts:StructuredType ;
    skos:prefLabel "Customer" .

`ts:CollectionType`

A structured type whose values contain ordered or keyed child values.

Use ts:CollectionType for structured values that contain child values by order or key. Arrays and related collection forms specialize it with element, item-count, and lookup properties.

Modeling Notes

ts:CollectionType is a subclass of ts:StructuredType.
Direct subclasses: ts:ArrayType.
Primary outgoing properties: ts:elementType and ts:hasIndexerSlot.

ex:StringArray
    a ts:CollectionType ;
    ts:arrayValueType ts:string .

`ts:RecordType`

A structured type with named fields.

Use ts:RecordType for object-like values with named fields. Attach each ts:Field with ts:hasField, and describe closed or open shape behavior with exactness and additional-property properties.

Language analogs: TypeScript interface or object type, Python dataclass or TypedDict, Rust struct, GraphQL type, JSON Schema object.

// ex:Customer with ts:hasField ex:customer-id-field
interface Customer {
  id: string;
}

@dataclass
class Customer:
    id: str

struct Customer {
    id: String,
}

Modeling Notes

ts:RecordType is a subclass of ts:StructuredType.
Direct subclasses: ts:OptionRecordType, ts:RecordExpression, and ts:RecordMapType.
Primary outgoing properties: ts:additionalPropertiesRecord, ts:additionalPropertyType, and ts:hasField.

ex:Customer
    a ts:RecordType ;
    skos:prefLabel "Customer" ;
    ts:hasField ex:customer-id-field .

`ts:RecordExpression`

An anonymous record type expression.

Use ts:RecordExpression for inline record shapes that do not have their own declaration name. It carries the same field structure as ts:RecordType while also being an ts:AnonymousTypeExpression.

Language analogs: inline TypeScript object types, Python TypedDict used locally, Rust anonymous struct-like values in macros, and JSON Schema object fragments.

Modeling Notes

ts:RecordExpression is a subclass of ts:RecordType and ts:AnonymousTypeExpression.

ex:inline-customer-shape
    a ts:RecordExpression ;
    ts:hasField ex:customer-id-field ;
    ts:isAnonymous true .

`ts:RecordMapType`

A record-compatible type with arbitrary keyed fields of a common value type.

Use ts:RecordMapType for record-compatible maps where arbitrary keys share a common value type. ts:recordKeyType and ts:recordValueType describe the key and value spaces.

Language analogs: TypeScript Record<K, V>, Python dict[K, V], Rust HashMap<K, V>, GraphQL custom map scalars, JSON Schema additionalProperties.

Modeling Notes

ts:RecordMapType is a subclass of ts:RecordType.
Primary outgoing properties: ts:recordKeyType and ts:recordValueType.
Commonly referenced by: ts:additionalPropertiesRecord.

ex:CustomerById
    a ts:RecordMapType ;
    ts:recordKeyType ts:string ;
    ts:recordValueType ex:Customer .

`ts:OptionRecordType`

A record type used as typed options or parameter bags.

Use ts:OptionRecordType for typed option bags or parameter objects. It is still a ts:RecordType, but signals that optional named fields act as configuration inputs.

Language analogs: option bags in TypeScript and Python keyword-argument objects, Rust builder option structs, GraphQL input objects with optional fields, and JSON Schema partial objects.

Modeling Notes

ts:OptionRecordType is a subclass of ts:RecordType.

ex:FindCustomerOptions
    a ts:OptionRecordType ;
    ts:hasField ex:include-deleted-field .

`ts:ArrayType`

An ordered collection with a common element type.

Use ts:ArrayType for ordered collections with a common element type. Model the element value space with ts:arrayValueType and count constraints with item facets.

Language analogs: TypeScript T[] or Array<T>, Python list[T], Rust Vec<T>, GraphQL list types, JSON Schema arrays.

// ex:StringArray with ts:arrayValueType ts:string
type StringArray = string[];

StringArray = list[str]

type StringArray = Vec<String>;

Modeling Notes

ts:ArrayType is a subclass of ts:CollectionType.
Direct subclasses: ts:ArrayExpression and ts:TupleType.
Primary outgoing properties: ts:arrayValueType.

ex:StringArray
    a ts:ArrayType ;
    ts:arrayValueType ts:string .

`ts:ArrayExpression`

An anonymous array type expression.

Use ts:ArrayExpression for inline array value spaces. It is the anonymous counterpart of ts:ArrayType and should carry the same element-type facts.

Modeling Notes

ts:ArrayExpression is a subclass of ts:ArrayType and ts:AnonymousTypeExpression.

ex:inline-string-array
    a ts:ArrayExpression ;
    ts:arrayValueType ts:string ;
    ts:isAnonymous true .

`ts:TupleType`

A fixed-position ordered collection with per-position element types.

Use ts:TupleType for ordered collections whose positions have distinct types or meanings. Attach ts:TupleElement resources with ts:tupleElement and preserve position using ts:ordinal.

Language analogs: TypeScript tuple types, Python tuple[T1, T2], Rust tuples, fixed-length JSON arrays, and database composite values.

// ex:Coordinate has ex:x-coordinate and ex:y-coordinate
type Coordinate = [number, number];

Coordinate = tuple[float, float]

type Coordinate = (f64, f64);

Modeling Notes

ts:TupleType is a subclass of ts:ArrayType.
Direct subclasses: ts:TupleExpression.
Primary outgoing properties: ts:tupleElement.

ex:Coordinate
    a ts:TupleType ;
    ts:tupleElement ex:x-coordinate ;
    ts:tupleElement ex:y-coordinate .

`ts:TupleExpression`

An anonymous tuple type expression.

Use ts:TupleExpression for inline tuple shapes. It combines tuple position semantics with ts:AnonymousTypeExpression so it can appear directly inside another type expression.

Modeling Notes

ts:TupleExpression is a subclass of ts:TupleType and ts:AnonymousTypeExpression.

ex:inline-coordinate
    a ts:TupleExpression ;
    ts:tupleElement ex:x-coordinate ;
    ts:isAnonymous true .

`ts:StreamType`

A type whose values are delivered incrementally as elements of another type.

Use ts:StreamType for values delivered incrementally as elements over time. Its ts:streamElementType describes each emitted value, not a stored array.

Language analogs: TypeScript AsyncIterable<T>, Python AsyncIterator[T], Rust Stream<Item = T>, and reactive stream abstractions.

Modeling Notes

ts:StreamType is a subclass of ts:DataType.
Primary outgoing properties: ts:streamElementType.

ex:CustomerEvents
    a ts:StreamType ;
    ts:streamElementType ex:CustomerEvent .

`ts:IntersectionType`

A type whose values satisfy all constituent types.

Use ts:IntersectionType when values must satisfy all listed constituent types. Attach each required value space with ts:intersectionConstituent.

Language analogs: TypeScript A & B, Python protocols composed through multiple inheritance, Rust trait bounds such as A + B, and JSON Schema allOf.

Modeling Notes

ts:IntersectionType is a subclass of ts:StructuredType.
Direct subclasses: ts:IntersectionExpression.
Primary outgoing properties: ts:intersectionConstituent.

ex:AuditedCustomer
    a ts:IntersectionType ;
    ts:intersectionConstituent ex:Customer ;
    ts:intersectionConstituent ex:Audited .

`ts:IntersectionExpression`

An anonymous intersection type expression.

Use ts:IntersectionExpression for inline intersections. It is useful when a composite constraint appears locally and does not merit a declaration of its own.

Modeling Notes

ts:IntersectionExpression is a subclass of ts:IntersectionType and ts:AnonymousTypeExpression.

ex:inline-audited-customer
    a ts:IntersectionExpression ;
    ts:intersectionConstituent ex:Customer ;
    ts:isAnonymous true .

`ts:TypedSlot`

A field, tuple element, parameter, result, alternative, or lookup slot that carries values of a type.

ts:TypedSlot is the shared class for addressable positions that carry values of a type. Fields, parameters, results, alternatives, tuple elements, and indexers inherit cardinality and default-value behavior from this role.

Language analogs: typed positions such as TypeScript properties or parameters, Python annotated fields or parameters, Rust fields or function parameters, and GraphQL field or argument definitions.

Modeling Notes

ts:TypedSlot is a subclass of ts:Entity.
Direct subclasses: ts:Field, ts:IndexerSlot, ts:ParameterSlot, ts:ResultSlot, ts:TemplateParameter, ts:TupleElement, and ts:UnionAlternative.
Primary outgoing properties: ts:isOptional, ts:isVariadic, ts:maxCount, ts:minCount, and ts:valueType.

ex:customer-id-field
    a ts:TypedSlot ;
    ts:valueType ts:string ;
    ts:minCount 1 .

`ts:Field`

A named slot on a record type.

Use ts:Field for a named slot on a ts:RecordType. The field points to its key with ts:fieldKey, to its value space with ts:fieldType, and to ordering or optionality facts when those matter.

Language analogs: TypeScript object properties, Python dataclass attributes or TypedDict keys, Rust struct fields, GraphQL fields, SQL columns, and JSON object properties.

// ex:customer-id-field: key "id", type string
interface Customer {
  id: string;
}

@dataclass
class Customer:
    id: str

CREATE TABLE customer (
  id TEXT NOT NULL
);

Modeling Notes

ts:Field is a subclass of ts:TypedSlot.
Primary outgoing properties: ts:fieldKey and ts:fieldType.
Commonly referenced by: ts:discriminatorField, ts:hasField, ts:matchSourceField, and ts:matchTargetField.

ex:customer-id-field
    a ts:Field ;
    ts:fieldKey ex:customer-id-key ;
    ts:fieldType ts:string ;
    ts:ordinal 0 .

`ts:FieldKey`

The declared key for a record field.

Use ts:FieldKey to model the declared key separately from the field. This keeps key text, escaping category, and field identity distinct.

Language analogs: property keys in TypeScript, dictionary keys in Python, field identifiers in Rust structs, GraphQL field names, and JSON object member names.

Modeling Notes

ts:FieldKey is a subclass of ts:Entity.
Primary outgoing properties: ts:fieldKeyKind and ts:keyText.
Commonly referenced by: ts:fieldKey.

ex:customer-id-key
    a ts:FieldKey ;
    ts:keyText "id" ;
    ts:fieldKeyKind ts:identifierFieldKey .

`ts:FieldKeyKind`

A controlled category for field keys.

Use ts:FieldKeyKind individuals to classify how a field key is written or interpreted, such as identifier keys versus string-literal keys.

Modeling Notes

ts:FieldKeyKind is a subclass of ts:Entity.
Commonly referenced by: ts:fieldKeyKind.

ts:identifierFieldKey
    a ts:FieldKeyKind ;
    skos:prefLabel "identifier" .

`ts:TupleElement`

A typed position in a tuple type.

Use ts:TupleElement for a typed position in a ts:TupleType. The element type and ts:ordinal together define the meaning of the tuple position.

Language analogs: tuple positions in TypeScript, Python, and Rust, positional array schemas in JSON Schema, and ordered result columns in SQL row values.

Modeling Notes

ts:TupleElement is a subclass of ts:TypedSlot.
Primary outgoing properties: ts:tupleElementType.
Commonly referenced by: ts:matchSourceTupleElement, ts:matchTargetTupleElement, and ts:tupleElement.

ex:x-coordinate
    a ts:TupleElement ;
    ts:tupleElementType ts:decimal ;
    ts:ordinal 0 .

`ts:IndexerSlot`

A typed lookup slot on an array or map-like type.

Use ts:IndexerSlot for lookup behavior on array-like or map-like types. The indexer key type and value type describe what can be addressed dynamically.

Language analogs: TypeScript index signatures, Python mapping key/value annotations, Rust map lookup types, and JSON Schema property-name plus additional-property constraints.

Modeling Notes

ts:IndexerSlot is a subclass of ts:TypedSlot.
Primary outgoing properties: ts:indexerKeyType and ts:indexerValueType.
Commonly referenced by: ts:hasIndexerSlot.

ex:customer-indexer
    a ts:IndexerSlot ;
    ts:indexerKeyType ts:string ;
    ts:indexerValueType ex:Customer .

Choice Types

These classes describe value spaces selected from alternatives: unions, nullable types, discriminators, variants, enums, and enum members. They are meant to preserve both closed sets of named choices and structural alternatives with selector fields.

type Status = "draft" | "published";
type Result = { ok: true; value: string } | { ok: false; error: string };

enum Status { DRAFT PUBLISHED }
union SearchResult = Customer | Order

enum ResultValue {
    Ok { value: String },
    Err { error: String },
}

`ts:Union`

A type that admits values from one or more alternative types.

Use ts:Union for value spaces admitted by one or more alternatives. Alternatives should be materialized with ts:hasUnionAlternative when ordering, discriminator values, or evidence needs to point at them.

Language analogs: TypeScript unions and discriminated unions, Python typing.Union or |, Rust enum, GraphQL union, JSON Schema oneOf.

// ex:Animal has cat and dog alternatives
type Animal = Cat | Dog;

Animal = Cat | Dog

enum Animal {
    Cat(Cat),
    Dog(Dog),
}

Modeling Notes

ts:Union is a subclass of ts:DataType.
Direct subclasses: ts:NullableType and ts:UnionExpression.
Primary outgoing properties: ts:hasDiscriminator and ts:hasUnionAlternative.
Commonly referenced by: ts:admittedByUnion and ts:unionVariantOf.

ex:Animal
    a ts:Union ;
    ts:hasUnionAlternative ex:cat-alternative ;
    ts:hasUnionAlternative ex:dog-alternative .

`ts:UnionExpression`

An anonymous union type expression.

Use ts:UnionExpression for inline unions. It is useful for local alternatives such as a parameter accepting a few literal types or a nullable expression embedded in a larger shape.

Modeling Notes

ts:UnionExpression is a subclass of ts:Union and ts:AnonymousTypeExpression.

ex:inline-id-or-null
    a ts:UnionExpression ;
    ts:hasUnionAlternative ex:id-alternative ;
    ts:isAnonymous true .

`ts:NullableType`

A union whose alternatives include null and one non-null base type.

Use ts:NullableType for the common union pattern of null plus one non-null base type. ts:nullableBaseType identifies the non-null value space directly.

Language analogs: TypeScript T | null, Python T | None, Rust Option<T>, nullable GraphQL fields, and JSON Schema unions with null.

Modeling Notes

ts:NullableType is a subclass of ts:Union.
Primary outgoing properties: ts:nullableBaseType.

ex:NullableCustomer
    a ts:NullableType ;
    ts:nullableBaseType ex:Customer .

`ts:UnionAlternative`

One ordered alternative of a union type.

Use ts:UnionAlternative for one branch of a union. It carries the admitted type, position, and optional discriminator value so relations can compare alternatives directly.

Language analogs: a member of a TypeScript union, a Python union arm, a Rust enum variant type, a GraphQL union member, or a JSON Schema oneOf branch.

Modeling Notes

ts:UnionAlternative is a subclass of ts:TypedSlot.
Direct subclasses: ts:UnionVariant.
Primary outgoing properties: ts:alternativeType and ts:discriminatorValue.
Commonly referenced by: ts:hasUnionAlternative, ts:matchSourceAlternative, and ts:matchTargetAlternative.

ex:cat-alternative
    a ts:UnionAlternative ;
    ts:alternativeType ex:Cat ;
    ts:discriminatorValue ex:cat-kind-value ;
    ts:ordinal 0 .

`ts:UnionVariant`

A named union alternative that can also be referenced as a type.

Use ts:UnionVariant when a union alternative also needs to be referenced as a type. It is both an alternative slot and a ts:Type.

Language analogs: discriminated union cases in TypeScript, tagged dataclasses in Python, Rust enum variants, GraphQL object types admitted by a union, and tagged JSON objects.

Modeling Notes

ts:UnionVariant is a subclass of ts:UnionAlternative and ts:Type.
Primary outgoing properties: ts:unionVariantOf.

ex:CatVariant
    a ts:UnionVariant ;
    ts:unionVariantOf ex:Animal ;
    ts:alternativeType ex:Cat .

`ts:Discriminator`

A type-level selector that distinguishes alternatives in a union.

Use ts:Discriminator for the selector that distinguishes union alternatives. It links to the selector field and to an envelope strategy so processors can find the discriminator in values.

Language analogs: TypeScript discriminant fields, Python tag fields, Rust serde tag attributes, GraphQL __typename-like selectors, and OpenAPI discriminator mappings.

Modeling Notes

ts:Discriminator is a subclass of ts:Entity.
Primary outgoing properties: ts:discriminatorEnvelope and ts:discriminatorField.
Commonly referenced by: ts:hasDiscriminator.

ex:animal-kind-discriminator
    a ts:Discriminator ;
    ts:discriminatorField ex:animal-kind-field ;
    ts:discriminatorEnvelope ts:envelopeObject .

`ts:DiscriminatorEnvelope`

A controlled discriminator placement strategy.

Use ts:DiscriminatorEnvelope individuals as controlled placement strategies for discriminated unions. They tell consumers whether the selector is embedded in an object envelope or absent.

Modeling Notes

ts:DiscriminatorEnvelope is a subclass of ts:Entity.
Commonly referenced by: ts:discriminatorEnvelope.

ts:envelopeObject
    a ts:DiscriminatorEnvelope ;
    skos:prefLabel "object" .

`ts:Enum`

A type with a finite set of named members.

Use ts:Enum for finite named member sets. Attach each ts:EnumMember with ts:hasEnumMember and model member values explicitly when the enum has concrete values.

Language analogs: TypeScript enums or string-literal unions, Python Enum, Rust enum, GraphQL enum, JSON Schema enum.

// ex:Currency has enum member ex:usd-member
type Currency = "USD";

class Currency(Enum):
    USD = "USD"

enum Currency {
  USD
}

Modeling Notes

ts:Enum is a subclass of ts:DataType.
Primary outgoing properties: ts:hasEnumMember.
Commonly referenced by: ts:enumMemberOf.

ex:Currency
    a ts:Enum ;
    ts:hasEnumMember ex:usd-member .

`ts:EnumMember`

One named member of an enum type. A member can be referenced in type position and can denote a value.

Use ts:EnumMember for a named member of an enum that can also appear in type position. Link it back to the enum with ts:enumMemberOf and to its denoted value with ts:enumMemberValue .

Language analogs: TypeScript enum members or string-literal alternatives, Python enum members, Rust unit variants, GraphQL enum values, and JSON Schema enum values.

Modeling Notes

ts:EnumMember is a subclass of ts:Type.
Primary outgoing properties: ts:enumMemberOf, ts:enumMemberType, and ts:enumMemberValue.
Commonly referenced by: ts:hasEnumMember.

ex:usd-member
    a ts:EnumMember ;
    ts:enumMemberOf ex:Currency ;
    ts:enumMemberValue ex:usd-value .

Callables, Templates, And Type Expressions

These classes describe callable signatures, generic resources, supplied arguments, and type-level expressions derived from values or constraints. They make overloads, generic bounds, type arguments, value arguments, defaults, and resulting types inspectable.

function getCustomer<T extends Customer>(id: string): Promise<T>;
type Page<T> = { items: T[]; next?: string };

T = TypeVar("T")
def get_customer(id: str, model: type[T]) -> T: ...

fn get_customer<T: Customer>(id: String) -> T;
struct Page<T> { items: Vec<T>, next: Option<String> }

`ts:CallableType`

A function-like type with typed parameters and results.

Use ts:CallableType for function-like signatures. Materialize inputs with ts:ParameterSlot and outputs with ts:ResultSlot when callers, validators, or documentation need slot-level facts.

Language analogs: TypeScript function types, Python Callable or annotated def, Rust fn signatures or callable traits, GraphQL resolver signatures.

// ex:get-customer has id parameter and Customer result
type GetCustomer = (id: string) => Customer;

def get_customer(id: str) -> Customer:
    ...

fn get_customer(id: &str) -> Customer

Modeling Notes

ts:CallableType is a subclass of ts:Type.
Direct subclasses: ts:ScalarInitializer.
Primary outgoing properties: ts:hasParameterSlot and ts:hasResultSlot.
Commonly referenced by: ts:hasCallable and ts:membershipCallable.

ex:get-customer
    a ts:CallableType ;
    ts:hasParameterSlot ex:get-customer-id ;
    ts:hasResultSlot ex:get-customer-result .

`ts:CallableSetType`

A type-level grouping of callable signatures.

Use ts:CallableSetType for a type-level grouping of callable signatures. It is the right class for overload sets, protocol surfaces, and callable collections.

Language analogs: overloaded TypeScript call signatures, Python overload sets, Rust trait implementations with multiple callable forms, and APIs with several resolver signatures.

Modeling Notes

ts:CallableSetType is a subclass of ts:Type.
Direct subclasses: ts:InterfaceType.
Primary outgoing properties: ts:hasCallable.
Commonly referenced by: ts:membershipSet.

ex:CustomerApi
    a ts:CallableSetType ;
    ts:hasCallable ex:get-customer .

`ts:InterfaceType`

A named callable set type.

Use ts:InterfaceType for a named callable set. It specializes ts:CallableSetType when the set acts as an interface rather than an anonymous group.

Language analogs: TypeScript interfaces, Python protocols or abstract base classes, Rust traits, GraphQL interfaces, and structural object contracts.

Modeling Notes

ts:InterfaceType is a subclass of ts:CallableSetType.

ex:CustomerApi
    a ts:InterfaceType ;
    ts:hasCallable ex:get-customer .

`ts:CallableSetMembership`

A relation between a callable set type and one callable type.

Use ts:CallableSetMembership when membership between a callable set and callable needs its own identity or metadata. Otherwise ts:hasCallable can link the set directly.

Modeling Notes

ts:CallableSetMembership is a subclass of ts:Entity.
Primary outgoing properties: ts:membershipCallable and ts:membershipSet.

ex:customer-api-get-membership
    a ts:CallableSetMembership ;
    ts:membershipSet ex:CustomerApi ;
    ts:membershipCallable ex:get-customer .

`ts:ParameterSlot`

A typed input slot of a callable type.

Use ts:ParameterSlot for a callable input. Its ts:parameterType, cardinality, default, and preferred label describe how the callable accepts arguments.

Language analogs: function parameters in TypeScript, Python, and Rust, GraphQL arguments, and RPC input positions.

Modeling Notes

ts:ParameterSlot is a subclass of ts:TypedSlot.
Primary outgoing properties: ts:parameterType.
Commonly referenced by: ts:hasParameterSlot, ts:initializerArgumentFor, and ts:initializerParameter.

ex:get-customer-id
    a ts:ParameterSlot ;
    skos:prefLabel "id" ;
    ts:parameterType ts:string ;
    ts:minCount 1 .

`ts:ResultSlot`

A typed output slot of a callable type.

Use ts:ResultSlot for a callable output. Its ts:resultType and cardinality describe what the callable returns, including multi-result or optional-result shapes.

Language analogs: TypeScript return types, Python return annotations, Rust return types, GraphQL field return types, and RPC response value positions.

Modeling Notes

ts:ResultSlot is a subclass of ts:TypedSlot.
Primary outgoing properties: ts:resultType.
Commonly referenced by: ts:hasResultSlot.

ex:get-customer-result
    a ts:ResultSlot ;
    ts:resultType ex:Customer ;
    ts:minCount 1 .

`ts:TemplateParameter`

A type-system parameter used to instantiate a generic type or callable.

ts:TemplateParameter is the shared class for parameters used to instantiate generic resources. Use its subclasses to distinguish type arguments, value arguments, or arguments that may be either.

Language analogs: generic parameters in TypeScript, type variables in Python, generic parameters in Rust, GraphQL schema-generator parameters, and template placeholders in IDLs.

Modeling Notes

ts:TemplateParameter is a subclass of ts:TypedSlot.
Direct subclasses: ts:TypeOrValueParameter, ts:TypeParameter, and ts:ValueParameter.
Primary outgoing properties: ts:parameterDefaultConformance, ts:typeParameterDefaultValue, and ts:typeParameterValueConstraint.
Commonly referenced by: ts:argumentParameter and ts:hasTemplateParameter.

ex:CustomerListValue
    a ts:TemplateParameter ;
    skos:prefLabel "Value" ;
    ts:typeParameterValueConstraint ex:any-customer-value .

`ts:TypeParameter`

A template parameter whose arguments are types.

Use ts:TypeParameter when a generic parameter accepts a type expression. Bounds and defaults belong on the parameter through ts:typeParameterConstraint and ts:typeParameterDefaultType.

Language analogs: TypeScript <T> parameters, Python TypeVar, Rust generic type parameters, and parameterized schema types.

Modeling Notes

ts:TypeParameter is a subclass of ts:TemplateParameter and ts:Type.
Primary outgoing properties: ts:typeParameterConstraint and ts:typeParameterDefaultType.
Commonly referenced by: ts:hasTypeParameter.

ex:CustomerListValue
    a ts:TypeParameter ;
    skos:prefLabel "Value" ;
    ts:typeParameterConstraint ts:unknown .

`ts:ValueParameter`

A template parameter whose arguments are values.

Use ts:ValueParameter when a generic parameter accepts a value. Defaults and value-space constraints remain explicit type-system facts rather than prose on the declaration.

Language analogs: const generic parameters in Rust, literal-constrained TypeScript generics, Python value parameters in factory types, and schema templates parameterized by values.

Modeling Notes

ts:ValueParameter is a subclass of ts:TemplateParameter.
Commonly referenced by: ts:hasValueParameter.

ex:Limit
    a ts:ValueParameter ;
    skos:prefLabel "Limit" ;
    ts:typeParameterDefaultValue ex:default-limit .

`ts:TypeOrValueParameter`

A template parameter that can accept either a type argument or a value argument.

Use ts:TypeOrValueParameter when the same generic parameter can accept either a type or a value expression. Supplied arguments should state which form they take.

Modeling Notes

ts:TypeOrValueParameter is a subclass of ts:TemplateParameter.
Commonly referenced by: ts:hasTypeOrValueParameter.

ex:SchemaOrValue
    a ts:TypeOrValueParameter ;
    skos:prefLabel "SchemaOrValue" .

`ts:TemplateInstantiation`

The result of applying template arguments to a generic type-system entity.

Use ts:TemplateInstantiation for the result of applying arguments to a generic type-system entity. It records the generic with ts:instantiates, supplied arguments with ts:templateArgument, and the produced type with ts:resultingType.

Language analogs: TypeScript Page<Customer>, Python list[Customer], Rust Vec<Customer>, and generated schema aliases with concrete arguments.

// ex:ConcreteCustomerList supplies ex:customer-list-value-argument
type ConcreteCustomerList = CustomerListTemplate<Customer>;

ConcreteCustomerList = CustomerListTemplate[Customer]

type ConcreteCustomerList = CustomerListTemplate<Customer>;

Modeling Notes

ts:TemplateInstantiation is a subclass of ts:Type.
Primary outgoing properties: ts:instantiates, ts:resultingType, and ts:templateArgument.

ex:ConcreteCustomerList
    a ts:TemplateInstantiation ;
    ts:instantiates ex:CustomerListTemplate ;
    ts:templateArgument ex:customer-list-value-argument .

`ts:TemplateArgument`

One supplied argument for a template instantiation.

Use ts:TemplateArgument for one supplied argument in an instantiation. It connects back to the parameter it satisfies and can carry ordering, named-argument, expression, and conformance facts.

Language analogs: the Customer in TypeScript Page<Customer>, Python list[Customer], and Rust Vec<Customer>.

Modeling Notes

ts:TemplateArgument is a subclass of ts:Entity.
Direct subclasses: ts:TypeArgument and ts:ValueArgument.
Primary outgoing properties: ts:argumentConformance, ts:argumentEvaluationOrdinal, ts:argumentExpression, ts:argumentName, ts:argumentParameter, ts:argumentType, ts:argumentValue, and 1 more.
Commonly referenced by: ts:templateArgument.

ex:customer-list-value-argument
    a ts:TemplateArgument ;
    ts:argumentParameter ex:CustomerListValue ;
    ts:argumentExpression ex:Customer .

`ts:TypeArgument`

A template argument whose supplied expression is a type.

Use ts:TypeArgument when the supplied template argument is a type. Put the type expression in ts:argumentType and keep evaluation order separate with ts:argumentEvaluationOrdinal.

Language analogs: concrete generic type arguments such as TypeScript Customer, Python Customer, or Rust Customer inside a parameterized type.

Modeling Notes

ts:TypeArgument is a subclass of ts:TemplateArgument.

ex:customer-list-value-argument
    a ts:TypeArgument ;
    ts:argumentParameter ex:CustomerListValue ;
    ts:argumentType ex:Customer .

`ts:ValueArgument`

A template argument whose supplied expression is a value.

Use ts:ValueArgument when the supplied template argument is a value. Put the value in ts:argumentValue and use conformance evidence when the value must satisfy a parameter constraint.

Language analogs: Rust const-generic values such as array lengths, literal template parameters in schema generators, and value-level options passed to generated types.

Modeling Notes

ts:ValueArgument is a subclass of ts:TemplateArgument.

ex:limit-argument
    a ts:ValueArgument ;
    ts:argumentParameter ex:Limit ;
    ts:argumentValue ex:default-limit .

`ts:ValueOfType`

A type-level constraint whose accepted values have a declared or inferred type assignable to a base type.

Use ts:ValueOfType for a type-level constraint over values assignable to a base type. It is useful for value parameters that must be values of some type rather than arbitrary literals.

Language analogs: type annotation edges such as TypeScript const x: T, Python x: T, Rust let x: T, and JSON values validated against a schema.

Modeling Notes

ts:ValueOfType is a subclass of ts:Type.
Primary outgoing properties: ts:valueOfBaseType.
Commonly referenced by: ts:typeParameterValueConstraint.

ex:any-customer-value
    a ts:ValueOfType ;
    ts:valueOfBaseType ex:Customer .

`ts:TypeOfValue`

A type expression produced from the declared or inferred type of a value.

Use ts:TypeOfValue for a type expression projected from a value. The expression names the value with ts:typeOfValue and can record the resolved result type with ts:typeOfResultType.

Language analogs: inferred type queries such as TypeScript typeof value, Python runtime class inspection, Rust inferred binding types, and schema inference over example values.

Modeling Notes

ts:TypeOfValue is a subclass of ts:Type.
Primary outgoing properties: ts:typeOfResultType and ts:typeOfValue.

ex:default-currency-type
    a ts:TypeOfValue ;
    ts:typeOfValue ex:default-currency ;
    ts:typeOfResultType ts:string .

Literals And Values

These classes distinguish exact literal value spaces from concrete values represented inside a type-system graph. Literal types answer “which values are allowed”; value resources answer “which value is present here.”

type Currency = "USD" | "EUR";
const defaultCurrency = "USD" as const;

Currency = Literal["USD", "EUR"]
default_currency: Currency = "USD"

{ "enum": ["USD", "EUR"], "default": "USD" }

`ts:LiteralType`

A type-level literal expression, including exact singleton literal value spaces, template literal value spaces, and enum or union member references used in literal position.

Use ts:LiteralType when a type expression is literal-like. Exact singleton literals should state the literal category, base type, and concrete literal value when those facts are known.

Language analogs: TypeScript literal types, Python typing.Literal, Rust unit variants or const values, JSON Schema const, and singleton value spaces.

// ex:customer-id-literal is the string literal "cus_123"
type CustomerIdLiteral = "cus_123";

CustomerIdLiteral = Literal["cus_123"]

{
  "const": "cus_123"
}

Modeling Notes

ts:LiteralType is a subclass of ts:Type.
Direct subclasses: ts:BooleanLiteralType, ts:EnumMemberReferenceLiteralType, ts:NullLiteralType, ts:NumericLiteralType, ts:StringLiteralType, ts:StringTemplateLiteralType, and ts:UnionVariantReferenceLiteralType.
Primary outgoing properties: ts:literalBaseType, ts:literalKind, and ts:literalValue.

ex:customer-id-literal
    a ts:LiteralType ;
    ts:literalKind ts:stringLiteral ;
    ts:literalBaseType ts:string ;
    ts:literalValue "cus_123" .

`ts:LiteralKind`

A controlled category for literal type resources.

Use ts:LiteralKind individuals as controlled categories for literal types. They let processors distinguish string, numeric, boolean, null, enum-member, and union-variant references.

Modeling Notes

ts:LiteralKind is a subclass of ts:Entity.
Commonly referenced by: ts:literalKind.

ts:stringLiteral
    a ts:LiteralKind ;
    skos:prefLabel "stringLiteral" .

`ts:StringLiteralType`

A literal type whose only inhabitant is a specific string value.

Use ts:StringLiteralType for a type inhabited by one specific string. Store the concrete string with ts:literalValue or ts:stringValue as appropriate.

Language analogs: TypeScript string literal types, Python Literal["value"], Rust string constants used as tags, and JSON Schema string const values.

Modeling Notes

ts:StringLiteralType is a subclass of ts:LiteralType.

ex:customer-id-literal
    a ts:StringLiteralType ;
    ts:literalValue "cus_123" ;
    ts:stringValue "cus_123" .

`ts:StringTemplateLiteralType`

A literal type assembled from string literal and interpolation parts.

Use ts:StringTemplateLiteralType for literal types assembled from string literal and interpolated parts. Attach ordered ts:StringTemplatePart resources with ts:hasTemplatePart.

Modeling Notes

ts:StringTemplateLiteralType is a subclass of ts:LiteralType.
Primary outgoing properties: ts:hasTemplatePart.

ex:greeting-template
    a ts:StringTemplateLiteralType ;
    ts:hasTemplatePart ex:greeting-template-name .

`ts:StringTemplatePart`

A literal text or interpolation part of a string template literal.

Use ts:StringTemplatePart for each literal or interpolated component of a template literal. It can carry a literal value, an interpolated value expression, and conformance evidence for string compatibility.

Modeling Notes

ts:StringTemplatePart is a subclass of ts:Entity.
Primary outgoing properties: ts:templatePartConformance, ts:templatePartExpression, and ts:templatePartValue.
Commonly referenced by: ts:hasTemplatePart.

ex:greeting-template-name
    a ts:StringTemplatePart ;
    ts:templatePartExpression ex:customer-name-value .

`ts:NumericLiteralType`

A literal type whose only inhabitant is a specific numeric value.

Use ts:NumericLiteralType for a type inhabited by one numeric value. Numeric facts such as ts:numericValue and ts:isIntegralNumericValue preserve the literal semantics.

Language analogs: TypeScript numeric literal types, Python numeric Literal values, Rust const numeric values, and JSON Schema numeric const values.

Modeling Notes

ts:NumericLiteralType is a subclass of ts:LiteralType.
Primary outgoing properties: ts:isIntegralNumericValue.

ex:limit-literal
    a ts:NumericLiteralType ;
    ts:numericValue 100 ;
    ts:isIntegralNumericValue true .

`ts:BooleanLiteralType`

A literal type whose only inhabitant is true or false.

Use ts:BooleanLiteralType for a type inhabited only by true or false. It keeps boolean literal types distinct from the broader ts:BooleanType value space.

Language analogs: TypeScript true or false literal types, Python Literal[True], Rust boolean constants, and JSON Schema boolean const values.

Modeling Notes

ts:BooleanLiteralType is a subclass of ts:LiteralType.

ex:enabled-literal
    a ts:BooleanLiteralType ;
    ts:booleanValue true .

`ts:NullLiteralType`

A literal type whose only inhabitant is null.

Use ts:NullLiteralType for a literal type whose only inhabitant is null. This is the literal-type counterpart to the built-in ts:NullType.

Language analogs: TypeScript null, Python None, Rust None when paired with an option type, GraphQL nullable absence, and JSON null.

Modeling Notes

ts:NullLiteralType is a subclass of ts:LiteralType.

ex:null-literal
    a ts:NullLiteralType ;
    ts:literalKind ts:nullLiteral .

`ts:EnumMemberReferenceLiteralType`

A literal-like type expression produced by referring to an enum member in type position.

Use ts:EnumMemberReferenceLiteralType when type syntax refers to an enum member as a literal-like type. It preserves that reference without collapsing it to the member's concrete value.

Modeling Notes

ts:EnumMemberReferenceLiteralType is a subclass of ts:LiteralType.

ex:usd-reference
    a ts:EnumMemberReferenceLiteralType ;
    ts:literalBaseType ex:Currency .

`ts:UnionVariantReferenceLiteralType`

A literal-like type expression produced by referring to a union variant in type position.

Use ts:UnionVariantReferenceLiteralType when type syntax refers to a union variant as a literal-like type. It preserves the variant reference as a type-level expression.

Modeling Notes

ts:UnionVariantReferenceLiteralType is a subclass of ts:LiteralType.

ex:cat-reference
    a ts:UnionVariantReferenceLiteralType ;
    ts:literalBaseType ex:CatVariant .

`ts:Value`

A value in the type-system graph.

ts:Value is the root for concrete or graph-level values. Values can carry declared and inferred type facts and can be used as defaults, discriminator values, enum values, or template arguments.

Language analogs: TypeScript constants, Python assigned values, Rust constants or literals, JSON values, and RDF individuals that represent concrete values.

// ex:default-currency is declared as a string value
declare const defaultCurrency: string;

default_currency: str

{
  "defaultCurrency": { "type": "string" }
}

Modeling Notes

ts:Value is a subclass of ts:Entity.
Direct subclasses: ts:ArrayValue, ts:ConstValue, ts:EnumValue, ts:NullValue, ts:ObjectValue, ts:ScalarInitializerCall, and ts:ScalarValue.
Primary outgoing properties: ts:declaredType and ts:inferredType.
Commonly referenced by: ts:argumentValue, ts:defaultValue, ts:discriminatorValue, ts:enumMemberValue, ts:initializerArgumentValue, ts:itemValue, ts:memberValue, and 4 more.

ex:default-currency
    a ts:Value ;
    ts:declaredType ts:string .

`ts:ConstValue`

A named value binding with a declared or inferred type.

Use ts:ConstValue for a named value binding with a stable preferred name. It is the value-side counterpart to declarations for constants and named defaults.

Language analogs: TypeScript as const values, Python module constants, Rust const items, GraphQL enum values, and JSON Schema const examples.

Modeling Notes

ts:ConstValue is a subclass of ts:Value.

ex:default-currency
    a ts:ConstValue ;
    skos:prefLabel "defaultCurrency" ;
    ts:declaredType ts:string .

`ts:ScalarValue`

A scalar value.

Use ts:ScalarValue for concrete scalar values before narrowing to string, numeric, or boolean value classes. It gives shared typing behavior to atomic values.

Modeling Notes

ts:ScalarValue is a subclass of ts:Value.
Direct subclasses: ts:BooleanValue, ts:NumericValue, and ts:StringValue.

ex:cat-kind-value
    a ts:ScalarValue ;
    ts:declaredType ts:string .

`ts:StringValue`

A scalar value whose concrete value is a string.

Use ts:StringValue for concrete string values. Store the value with ts:stringValue and point at its value space with ts:declaredType or ts:inferredType.

Language analogs: JavaScript or TypeScript string values, Python str values, Rust String or &str values, GraphQL string values, and JSON strings.

Modeling Notes

ts:StringValue is a subclass of ts:ScalarValue.

ex:cat-kind-value
    a ts:StringValue ;
    ts:declaredType ts:string ;
    ts:stringValue "cat" .

`ts:NumericValue`

A scalar value whose concrete value is numeric.

Use ts:NumericValue for concrete numeric values. Store the numeric content with ts:numericValue and use the declared or inferred type to distinguish integer, float, or decimal meaning.

Language analogs: TypeScript number values, Python int, float, or Decimal values, Rust numeric values, GraphQL numeric values, and JSON numbers.

Modeling Notes

ts:NumericValue is a subclass of ts:ScalarValue.

ex:default-limit
    a ts:NumericValue ;
    ts:declaredType ts:integer ;
    ts:numericValue 100 .

`ts:BooleanValue`

A scalar value whose concrete value is boolean.

Use ts:BooleanValue for concrete boolean values. Store the boolean content with ts:booleanValue instead of encoding booleans as strings or enum members.

Language analogs: TypeScript boolean values, Python bool values, Rust bool values, GraphQL boolean values, and JSON booleans.

Modeling Notes

ts:BooleanValue is a subclass of ts:ScalarValue.

ex:include-deleted-default
    a ts:BooleanValue ;
    ts:declaredType ts:boolean ;
    ts:booleanValue false .

`ts:NullValue`

The null value.

Use ts:NullValue for the concrete null value. It can be attached as a default, discriminator value, or argument while retaining explicit value identity.

Modeling Notes

ts:NullValue is a subclass of ts:Value.

ex:no-customer
    a ts:NullValue ;
    ts:declaredType ts:null .

`ts:EnumValue`

A value that denotes a specific enum member.

Use ts:EnumValue for a value that denotes a specific enum member. It is the value-level resource that can be referenced by defaults, literals, or member facts.

Modeling Notes

ts:EnumValue is a subclass of ts:Value.

ex:usd-value
    a ts:EnumValue ;
    ts:enumMemberValue ex:usd-member .

`ts:ObjectValue`

An object value with named members.

Use ts:ObjectValue for concrete object-shaped values. Attach ts:ObjectValueMember resources so each member value can have its own name, ordering, or type facts.

Language analogs: JavaScript object literals, Python dictionaries or dataclass instances, Rust struct values, GraphQL input objects, and JSON objects.

Modeling Notes

ts:ObjectValue is a subclass of ts:Value.
Primary outgoing properties: ts:objectMember.

ex:customer-object
    a ts:ObjectValue ;
    ts:objectMember ex:customer-object-id .

`ts:ObjectValueMember`

A named member of an object value.

Use ts:ObjectValueMember for a named member inside an ts:ObjectValue. The member name and member value are separate so object values can preserve structure and value identity.

Modeling Notes

ts:ObjectValueMember is a subclass of ts:Entity.
Primary outgoing properties: ts:memberValue.
Commonly referenced by: ts:objectMember.

ex:customer-object-id
    a ts:ObjectValueMember ;
    ts:memberName "id" ;
    ts:memberValue ex:cat-kind-value .

`ts:ArrayValue`

An array value with ordered items.

Use ts:ArrayValue for concrete ordered arrays. Attach ts:ArrayValueItem resources with ts:arrayItem so item values and positions remain explicit.

Language analogs: JavaScript arrays, Python lists, Rust vectors or arrays, GraphQL lists, and JSON arrays.

Modeling Notes

ts:ArrayValue is a subclass of ts:Value.
Primary outgoing properties: ts:arrayItem.

ex:customer-labels
    a ts:ArrayValue ;
    ts:arrayItem ex:customer-label-item-0 .

`ts:ArrayValueItem`

An ordered item of an array value.

Use ts:ArrayValueItem for one ordered item in an ts:ArrayValue. The item carries both its value and ordinal position.

Modeling Notes

ts:ArrayValueItem is a subclass of ts:Entity.
Primary outgoing properties: ts:itemValue.
Commonly referenced by: ts:arrayItem.

ex:customer-label-item-0
    a ts:ArrayValueItem ;
    ts:itemValue ex:vip-label ;
    ts:ordinal 0 .

Scalar Initializers

These classes model scalar constructors and parser-like calls when the callable form is part of the scalar type contract. They describe construction semantics without turning the type ontology into a general runtime execution model.

const id = CustomerId.fromString("cus_123");

id = CustomerId.from_string("cus_123")

let id = "cus_123".parse::<CustomerId>()?;

`ts:ScalarInitializer`

A callable type-level resource that constructs or parses values for a scalar type.

Use ts:ScalarInitializer when constructing or parsing scalar values is part of the type contract. Because it is a callable type, it can expose parameters, results, and semantic kind.

Language analogs: TypeScript factory functions, Python class methods or constructors, Rust FromStr or TryFrom, and scalar coercion hooks in schema systems.

// ex:id-from-string initializes ex:Id
const id = Id.fromString(input);

id = Id.parse(input)

let id = input.parse::<Id>()?;

Modeling Notes

ts:ScalarInitializer is a subclass of ts:CallableType.
Direct subclasses: ts:ScalarConstructorInitializer.
Primary outgoing properties: ts:initializerParameter, ts:initializerResult, and ts:initializerSemanticKind.
Commonly referenced by: ts:hasInitializer and ts:invokesInitializer.

ex:id-from-string
    a ts:ScalarInitializer ;
    ts:initializerParameter ex:id-from-string-value ;
    ts:initializerResult ex:Id .

`ts:ScalarConstructorInitializer`

A scalar initializer that constructs a scalar value directly from an input value.

Use ts:ScalarConstructorInitializer for initializers that directly construct scalar values from input values. It specializes scalar initialization for constructor-like conversion behavior.

Language analogs: constructors such as TypeScript new CustomerId(value), Python CustomerId(value), and Rust tuple struct constructors.

Modeling Notes

ts:ScalarConstructorInitializer is a subclass of ts:ScalarInitializer.

ex:id-from-string
    a ts:ScalarConstructorInitializer ;
    ts:initializerResult ex:Id ;
    ts:initializerSemanticKind ts:scalarValueConversionInitializer .

`ts:ScalarInitializerSemanticKind`

A controlled category for scalar initializer behavior.

Use ts:ScalarInitializerSemanticKind individuals to classify initializer behavior, such as value conversion, ISO lexical parsing, or current temporal value creation.

Modeling Notes

ts:ScalarInitializerSemanticKind is a subclass of ts:Entity.
Commonly referenced by: ts:initializerSemanticKind.

ts:scalarValueConversionInitializer
    a ts:ScalarInitializerSemanticKind ;
    skos:prefLabel "valueConversion" .

`ts:ScalarInitializerCall`

A value produced by invoking a scalar initializer.

Use ts:ScalarInitializerCall for a value produced by invoking a scalar initializer. It records which initializer was invoked and which arguments were supplied.

Language analogs: a concrete call to a parser, constructor, or coercion function, such as TypeScript CustomerId.fromString(input) or Rust input.parse().

Modeling Notes

ts:ScalarInitializerCall is a subclass of ts:Value.
Primary outgoing properties: ts:hasInitializerArgument and ts:invokesInitializer.

ex:new-id-call
    a ts:ScalarInitializerCall ;
    ts:invokesInitializer ex:id-from-string ;
    ts:hasInitializerArgument ex:new-id-input .

`ts:InitializerArgument`

One supplied argument in a scalar initializer call.

Use ts:InitializerArgument for one supplied argument in a scalar initializer call. It points to the parameter slot it satisfies and to the value supplied.

Modeling Notes

ts:InitializerArgument is a subclass of ts:Entity.
Primary outgoing properties: ts:initializerArgumentFor and ts:initializerArgumentValue.
Commonly referenced by: ts:hasInitializerArgument.

ex:new-id-input
    a ts:InitializerArgument ;
    ts:initializerArgumentFor ex:id-from-string-value ;
    ts:initializerArgumentValue ex:cat-kind-value .

Type Relations And Evidence

These classes materialize assignability, subtype, exactness, failure, and structural evidence between two type positions. They are the explanation layer for type checking, schema compatibility, migration checks, and generated diagnostics.

const customer: Customer = preview; // relation check: CustomerPreview -> Customer

def accepts_customer(customer: Customer) -> None: ...
accepts_customer(preview)  # relation check

{ "sourceType": "CustomerPreview", "targetType": "Customer", "evidence": ["field:id matches", "field:email missing"] }

`ts:TypeRelation`

A first-class assertion about the relationship between two types.

Use ts:TypeRelation when a relationship between two types must be first-class in the graph. The relation records its two endpoint types and can carry evidence resources.

Language analogs: assignability checks in TypeScript, protocol or structural compatibility checks in Python, trait-bound satisfaction in Rust, and schema compatibility results.

// ex:customer-assignability: Customer is assignable to unknown
declare const customer: Customer;
const value: unknown = customer;

customer: Customer
value: object = customer

Customer is assignable to unknown.

Modeling Notes

ts:TypeRelation is a subclass of ts:Entity.
Direct subclasses: ts:AssignableTypeRelation and ts:NonAssignableTypeRelation.
Primary outgoing properties: ts:hasEvidence, ts:relationSourceType, and ts:relationTargetType.
Commonly referenced by: ts:alternativeMatchRelation, ts:argumentConformance, ts:collectionElementMatchRelation, ts:evidenceRelation, ts:fieldMatchRelation, ts:parameterDefaultConformance, ts:templatePartConformance, and 1 more.

ex:customer-assignability
    a ts:TypeRelation ;
    ts:relationSourceType ex:Customer ;
    ts:relationTargetType ts:unknown .

`ts:AssignableTypeRelation`

A type relation whose source type can be assigned to the target type.

Use ts:AssignableTypeRelation when values of one type can be assigned to another type. It is the positive assignability relation that evidence and structural matches can justify.

Language analogs: TypeScript successful assignment, Python value accepted by an annotation or protocol, Rust type satisfying a required trait bound, and schema validation accepted as compatible.

Modeling Notes

ts:AssignableTypeRelation is a subclass of ts:TypeRelation.
Direct subclasses: ts:ExactTypeRelation and ts:SubtypeRelation.

ex:customer-assignability
    a ts:AssignableTypeRelation ;
    ts:relationSourceType ex:Customer ;
    ts:relationTargetType ts:unknown .

`ts:SubtypeRelation`

A type relation whose source type is a subtype of the target type.

Use ts:SubtypeRelation when the relation is specifically subtype-to-supertype. It specializes assignability for hierarchy-style reasoning.

Language analogs: class or interface subtyping, TypeScript structural subtyping, Python protocol satisfaction, Rust trait implementation relationships, and schema narrowing.

Modeling Notes

ts:SubtypeRelation is a subclass of ts:AssignableTypeRelation.

ex:customer-subtype-relation
    a ts:SubtypeRelation ;
    ts:relationSourceType ex:Customer ;
    ts:relationTargetType ts:unknown .

`ts:ExactTypeRelation`

A type relation whose source and target have the same inhabited shape or value space.

Use ts:ExactTypeRelation when two types have the same inhabited shape or value space. It is stricter than ordinary assignability because both endpoints describe equivalent values.

Language analogs: exact type equality checks, invariant generic matches, closed-schema equality, and cases where two aliases denote the same value space.

Modeling Notes

ts:ExactTypeRelation is a subclass of ts:AssignableTypeRelation.

ex:customer-exact-relation
    a ts:ExactTypeRelation ;
    ts:relationSourceType ex:Customer ;
    ts:relationTargetType ex:Customer .

`ts:NonAssignableTypeRelation`

A type relation whose source type cannot be assigned to the target type.

Use ts:NonAssignableTypeRelation when a failed assignability check is itself useful evidence. It lets validators explain why a source endpoint cannot be used at a target endpoint.

Language analogs: TypeScript assignment errors, Python type-checker incompatibilities, Rust trait-bound failures, and schema compatibility failures.

Modeling Notes

ts:NonAssignableTypeRelation is a subclass of ts:TypeRelation.

ex:string-not-customer
    a ts:NonAssignableTypeRelation ;
    ts:relationSourceType ts:string ;
    ts:relationTargetType ex:Customer .

`ts:TypeRelationEvidence`

Evidence attached to a first-class type relation.

Use ts:TypeRelationEvidence for explanation attached to a ts:TypeRelation. Evidence can record endpoint types, a rule label, and structural match resources.

Language analogs: compiler diagnostics or proof traces that explain an assignment result, such as matched fields, matched alternatives, or the first incompatible slot.

Modeling Notes

ts:TypeRelationEvidence is a subclass of ts:Entity.
Primary outgoing properties: ts:evidenceRelation, ts:evidenceRule, ts:evidenceSourceType, ts:evidenceTargetType, ts:hasAlternativeMatch, ts:hasCollectionElementTypeMatch, ts:hasFieldMatch, and 1 more.
Commonly referenced by: ts:hasEvidence.

ex:customer-subtype-evidence
    a ts:TypeRelationEvidence ;
    ts:evidenceRelation ex:customer-subtype-relation ;
    ts:evidenceRule "unknown target type" .

`ts:FieldMatch`

Evidence that compares one source field with one target field.

Use ts:FieldMatch when relation evidence compares a field on one side to a field on the other side. It can point to the field-level relation that proves compatibility.

Language analogs: property-by-property comparison in TypeScript structural typing, Python protocol matching, Rust struct-field mapping, and JSON object schema property matching.

Modeling Notes

ts:FieldMatch is a subclass of ts:Entity.
Primary outgoing properties: ts:fieldMatchRelation, ts:matchSourceField, and ts:matchTargetField.
Commonly referenced by: ts:hasFieldMatch.

ex:id-field-match
    a ts:FieldMatch ;
    ts:matchSourceField ex:customer-id-field ;
    ts:matchTargetField ex:customer-id-field .

`ts:AlternativeMatch`

Evidence that compares one source union alternative with one target alternative or covering type.

Use ts:AlternativeMatch when relation evidence compares union alternatives. It preserves which alternatives were matched and which relation justified the comparison.

Language analogs: selecting the accepted arm of a TypeScript union, Python union, Rust enum-like decoding path, GraphQL union member, or JSON Schema oneOf branch.

Modeling Notes

ts:AlternativeMatch is a subclass of ts:Entity.
Primary outgoing properties: ts:alternativeMatchRelation, ts:matchSourceAlternative, and ts:matchTargetAlternative.
Commonly referenced by: ts:hasAlternativeMatch.

ex:cat-alternative-match
    a ts:AlternativeMatch ;
    ts:matchSourceAlternative ex:cat-alternative ;
    ts:matchTargetAlternative ex:cat-alternative .

`ts:TupleElementMatch`

Evidence that compares one source tuple element with one target tuple element.

Use ts:TupleElementMatch when relation evidence compares tuple positions. It keeps positional compatibility distinct from field or collection-element compatibility.

Language analogs: comparing tuple positions in TypeScript, Python, or Rust, and validating positional array items in JSON Schema.

Modeling Notes

ts:TupleElementMatch is a subclass of ts:Entity.
Primary outgoing properties: ts:matchSourceTupleElement, ts:matchTargetTupleElement, and ts:tupleElementMatchRelation.
Commonly referenced by: ts:hasTupleElementMatch.

ex:x-coordinate-match
    a ts:TupleElementMatch ;
    ts:matchSourceTupleElement ex:x-coordinate ;
    ts:matchTargetTupleElement ex:x-coordinate .

`ts:CollectionElementTypeMatch`

Evidence that compares collection element value spaces.

Use ts:CollectionElementTypeMatch when relation evidence compares collection element value spaces. It is appropriate for arrays, streams, and other collection-like types.

Language analogs: checking array element types in TypeScript, list element types in Python, vector item types in Rust, GraphQL list item types, and JSON Schema item schemas.

Modeling Notes

ts:CollectionElementTypeMatch is a subclass of ts:Entity.
Primary outgoing properties: ts:collectionElementMatchRelation, ts:matchSourceElementType, and ts:matchTargetElementType.
Commonly referenced by: ts:hasCollectionElementTypeMatch.

ex:string-array-element-match
    a ts:CollectionElementTypeMatch ;
    ts:matchSourceElementType ts:string ;
    ts:matchTargetElementType ts:string .

Vocabulary Reference

This section defines every Inferal-owned term in the type-system namespace. The definitions below are derived from ontology.ttl and are the targets used by cross-references throughout this specification. Links to ts: terms use explicit fragment references because ReSpec normalizes definition labels case-insensitively, while RDF IRIs remain case-sensitive.

Read this section as the compact dictionary for the ontology. The class model explains how to use terms together; this reference gives the exact term, definition, domain, range, and built-in individual target needed by implementers and validators.

Class Definitions

Class rows define the RDF type that a resource can assert with rdf:type. When a row says that a class is a subclass of another class, processors can use that relationship during validation and during higher-level language mapping.

Term	Definition	Class relation
`ts:Entity`	A resource that participates in a type-system graph.	Root class in this module.
`ts:Vocabulary`	A named collection of type-system declarations.	Subclass of `ts:Entity`.
`ts:Namespace`	A semantic grouping scope for declarations.	Subclass of `ts:Entity`.
`ts:Declaration`	A named binding for a type, value, alias, or namespace-local resource.	Subclass of `ts:Entity`.
`ts:TypeDeclaration`	A named declaration whose declared resource is a type.	Subclass of `ts:Declaration`.
`ts:ValueDeclaration`	A named declaration whose declared resource is a value.	Subclass of `ts:Declaration`.
`ts:AliasDeclaration`	A named declaration whose declared resource is an alias.	Subclass of `ts:Declaration`.
`ts:Alias`	A type-system shorthand that points at another type-system resource.	Subclass of `ts:Entity`.
`ts:Type`	A value type assignable to fields, parameters, results, collection elements, alternatives, enum members, template parameters, or values.	Subclass of `ts:Entity`.
`ts:AnonymousTypeExpression`	An inline type expression that has no declaration name of its own.	Subclass of `ts:Type`.
`ts:IntrinsicType`	A built-in type supplied by the type system.	Subclass of `ts:Type`.
`ts:DataType`	A type that describes data values.	Subclass of `ts:Type`.
`ts:Scalar`	An atomic primitive or user-defined value type.	Subclass of `ts:DataType`.
`ts:StringType`	A scalar textual string type.	Subclass of `ts:Scalar`.
`ts:UrlType`	A string-like scalar constrained to URL values.	Subclass of `ts:StringType`.
`ts:BytesType`	A scalar byte-sequence type.	Subclass of `ts:Scalar`.
`ts:BooleanType`	A scalar boolean type.	Subclass of `ts:Scalar`.
`ts:NumericType`	A scalar numeric type.	Subclass of `ts:Scalar`.
`ts:IntegerType`	A whole-number scalar type.	Subclass of `ts:NumericType`.
`ts:FloatType`	A floating-point scalar type.	Subclass of `ts:NumericType`.
`ts:DecimalType`	A decimal scalar type.	Subclass of `ts:NumericType`.
`ts:TemporalType`	A scalar date, time, date-time, or duration type.	Subclass of `ts:Scalar`.
`ts:DateType`	A scalar calendar date type.	Subclass of `ts:TemporalType`.
`ts:TimeType`	A scalar clock time type.	Subclass of `ts:TemporalType`.
`ts:DateTimeType`	A scalar instant or date-time type.	Subclass of `ts:TemporalType`.
`ts:DurationType`	A scalar duration or time-period type.	Subclass of `ts:TemporalType`.
`ts:TemporalKind`	A controlled value-space category for temporal scalars.	Subclass of `ts:Entity`.
`ts:TemporalZoneSemantics`	A controlled description of whether a temporal scalar carries zone or offset semantics.	Subclass of `ts:Entity`.
`ts:NullType`	The type inhabited by null.	Subclass of `ts:IntrinsicType`.
`ts:UnknownType`	An intrinsic placeholder for values whose specific type is unknown or unresolved.	Subclass of `ts:IntrinsicType`.
`ts:AnyType`	An intrinsic type that suppresses normal assignability precision.	Subclass of `ts:IntrinsicType`.
`ts:VoidType`	The absence of a result value.	Subclass of `ts:IntrinsicType`.
`ts:NeverType`	The bottom type that no value can inhabit.	Subclass of `ts:IntrinsicType`.
`ts:ErrorType`	A type that denotes an error case in a typed result space.	Subclass of `ts:Type`.
`ts:StructuredType`	A data type with child slots, positions, keys, or alternatives.	Subclass of `ts:DataType`.
`ts:CollectionType`	A structured type whose values contain ordered or keyed child values.	Subclass of `ts:StructuredType`.
`ts:RecordType`	A structured type with named fields.	Subclass of `ts:StructuredType`.
`ts:RecordExpression`	An anonymous record type expression.	Subclass of `ts:RecordType`, `ts:AnonymousTypeExpression`.
`ts:RecordMapType`	A record-compatible type with arbitrary keyed fields of a common value type.	Subclass of `ts:RecordType`.
`ts:OptionRecordType`	A record type used as typed options or parameter bags.	Subclass of `ts:RecordType`.
`ts:ArrayType`	An ordered collection with a common element type.	Subclass of `ts:CollectionType`.
`ts:ArrayExpression`	An anonymous array type expression.	Subclass of `ts:ArrayType`, `ts:AnonymousTypeExpression`.
`ts:TupleType`	A fixed-position ordered collection with per-position element types.	Subclass of `ts:ArrayType`.
`ts:TupleExpression`	An anonymous tuple type expression.	Subclass of `ts:TupleType`, `ts:AnonymousTypeExpression`.
`ts:StreamType`	A type whose values are delivered incrementally as elements of another type.	Subclass of `ts:DataType`.
`ts:IntersectionType`	A type whose values satisfy all constituent types.	Subclass of `ts:StructuredType`.
`ts:IntersectionExpression`	An anonymous intersection type expression.	Subclass of `ts:IntersectionType`, `ts:AnonymousTypeExpression`.
`ts:TypedSlot`	A field, tuple element, parameter, result, alternative, or lookup slot that carries values of a type.	Subclass of `ts:Entity`.
`ts:Field`	A named slot on a record type.	Subclass of `ts:TypedSlot`.
`ts:FieldKey`	The declared key for a record field.	Subclass of `ts:Entity`.
`ts:FieldKeyKind`	A controlled category for field keys.	Subclass of `ts:Entity`.
`ts:TupleElement`	A typed position in a tuple type.	Subclass of `ts:TypedSlot`.
`ts:IndexerSlot`	A typed lookup slot on an array or map-like type.	Subclass of `ts:TypedSlot`.
`ts:Union`	A type that admits values from one or more alternative types.	Subclass of `ts:DataType`.
`ts:UnionExpression`	An anonymous union type expression.	Subclass of `ts:Union`, `ts:AnonymousTypeExpression`.
`ts:NullableType`	A union whose alternatives include null and one non-null base type.	Subclass of `ts:Union`.
`ts:UnionAlternative`	One ordered alternative of a union type.	Subclass of `ts:TypedSlot`.
`ts:UnionVariant`	A named union alternative that can also be referenced as a type.	Subclass of `ts:UnionAlternative`, `ts:Type`.
`ts:Discriminator`	A type-level selector that distinguishes alternatives in a union.	Subclass of `ts:Entity`.
`ts:DiscriminatorEnvelope`	A controlled discriminator placement strategy.	Subclass of `ts:Entity`.
`ts:Enum`	A type with a finite set of named members.	Subclass of `ts:DataType`.
`ts:EnumMember`	One named member of an enum type. A member can be referenced in type position and can denote a value.	Subclass of `ts:Type`.
`ts:CallableType`	A function-like type with typed parameters and results.	Subclass of `ts:Type`.
`ts:CallableSetType`	A type-level grouping of callable signatures.	Subclass of `ts:Type`.
`ts:InterfaceType`	A named callable set type.	Subclass of `ts:CallableSetType`.
`ts:CallableSetMembership`	A relation between a callable set type and one callable type.	Subclass of `ts:Entity`.
`ts:ParameterSlot`	A typed input slot of a callable type.	Subclass of `ts:TypedSlot`.
`ts:ResultSlot`	A typed output slot of a callable type.	Subclass of `ts:TypedSlot`.
`ts:TemplateParameter`	A type-system parameter used to instantiate a generic type or callable.	Subclass of `ts:TypedSlot`.
`ts:TypeParameter`	A template parameter whose arguments are types.	Subclass of `ts:TemplateParameter` and `ts:Type`.
`ts:ValueParameter`	A template parameter whose arguments are values.	Subclass of `ts:TemplateParameter`.
`ts:TypeOrValueParameter`	A template parameter that can accept either a type argument or a value argument.	Subclass of `ts:TemplateParameter`.
`ts:TemplateInstantiation`	The result of applying template arguments to a generic type-system entity.	Subclass of `ts:Type`.
`ts:TemplateArgument`	One supplied argument for a template instantiation.	Subclass of `ts:Entity`.
`ts:TypeArgument`	A template argument whose supplied expression is a type.	Subclass of `ts:TemplateArgument`.
`ts:ValueArgument`	A template argument whose supplied expression is a value.	Subclass of `ts:TemplateArgument`.
`ts:ValueOfType`	A type-level constraint whose accepted values have a declared or inferred type assignable to a base type.	Subclass of `ts:Type`.
`ts:TypeOfValue`	A type expression produced from the declared or inferred type of a value.	Subclass of `ts:Type`.
`ts:LiteralType`	A type-level literal expression, including exact singleton literal value spaces, template literal value spaces, and enum or union member references used in literal position.	Subclass of `ts:Type`.
`ts:LiteralKind`	A controlled category for literal type resources.	Subclass of `ts:Entity`.
`ts:StringLiteralType`	A literal type whose only inhabitant is a specific string value.	Subclass of `ts:LiteralType`.
`ts:StringTemplateLiteralType`	A literal type assembled from string literal and interpolation parts.	Subclass of `ts:LiteralType`.
`ts:StringTemplatePart`	A literal text or interpolation part of a string template literal.	Subclass of `ts:Entity`.
`ts:NumericLiteralType`	A literal type whose only inhabitant is a specific numeric value.	Subclass of `ts:LiteralType`.
`ts:BooleanLiteralType`	A literal type whose only inhabitant is true or false.	Subclass of `ts:LiteralType`.
`ts:NullLiteralType`	A literal type whose only inhabitant is null.	Subclass of `ts:LiteralType`.
`ts:EnumMemberReferenceLiteralType`	A literal-like type expression produced by referring to an enum member in type position.	Subclass of `ts:LiteralType`.
`ts:UnionVariantReferenceLiteralType`	A literal-like type expression produced by referring to a union variant in type position.	Subclass of `ts:LiteralType`.
`ts:Value`	A value in the type-system graph.	Subclass of `ts:Entity`.
`ts:ConstValue`	A named value binding with a declared or inferred type.	Subclass of `ts:Value`.
`ts:ScalarValue`	A scalar value.	Subclass of `ts:Value`.
`ts:StringValue`	A scalar value whose concrete value is a string.	Subclass of `ts:ScalarValue`.
`ts:NumericValue`	A scalar value whose concrete value is numeric.	Subclass of `ts:ScalarValue`.
`ts:BooleanValue`	A scalar value whose concrete value is boolean.	Subclass of `ts:ScalarValue`.
`ts:NullValue`	The null value.	Subclass of `ts:Value`.
`ts:EnumValue`	A value that denotes a specific enum member.	Subclass of `ts:Value`.
`ts:ObjectValue`	An object value with named members.	Subclass of `ts:Value`.
`ts:ObjectValueMember`	A named member of an object value.	Subclass of `ts:Entity`.
`ts:ArrayValue`	An array value with ordered items.	Subclass of `ts:Value`.
`ts:ArrayValueItem`	An ordered item of an array value.	Subclass of `ts:Entity`.
`ts:ScalarInitializer`	A callable type-level resource that constructs or parses values for a scalar type.	Subclass of `ts:CallableType`.
`ts:ScalarConstructorInitializer`	A scalar initializer that constructs a scalar value directly from an input value.	Subclass of `ts:ScalarInitializer`.
`ts:ScalarInitializerSemanticKind`	A controlled category for scalar initializer behavior.	Subclass of `ts:Entity`.
`ts:ScalarInitializerCall`	A value produced by invoking a scalar initializer.	Subclass of `ts:Value`.
`ts:InitializerArgument`	One supplied argument in a scalar initializer call.	Subclass of `ts:Entity`.
`ts:TypeRelation`	A first-class assertion about the relationship between two types.	Subclass of `ts:Entity`.
`ts:AssignableTypeRelation`	A type relation whose source type can be assigned to the target type.	Subclass of `ts:TypeRelation`.
`ts:SubtypeRelation`	A type relation whose source type is a subtype of the target type.	Subclass of `ts:AssignableTypeRelation`.
`ts:ExactTypeRelation`	A type relation whose source and target have the same inhabited shape or value space.	Subclass of `ts:AssignableTypeRelation`.
`ts:NonAssignableTypeRelation`	A type relation whose source type cannot be assigned to the target type.	Subclass of `ts:TypeRelation`.
`ts:TypeRelationEvidence`	Evidence attached to a first-class type relation.	Subclass of `ts:Entity`.
`ts:FieldMatch`	Evidence that compares one source field with one target field.	Subclass of `ts:Entity`.
`ts:AlternativeMatch`	Evidence that compares one source union alternative with one target alternative or covering type.	Subclass of `ts:Entity`.
`ts:TupleElementMatch`	Evidence that compares one source tuple element with one target tuple element.	Subclass of `ts:Entity`.
`ts:CollectionElementTypeMatch`	Evidence that compares collection element value spaces.	Subclass of `ts:Entity`.

Object Property Definitions

Object properties connect one type-system resource to another. Domains and ranges are not syntax restrictions on one programming language; they describe the graph shape a conforming data graph should use.

Term	Definition	Domain	Range
`ts:hasDeclaration`	Connects a vocabulary or namespace to a declaration it owns.	`ts:Entity`	`ts:Declaration`
`ts:declares`	Connects a declaration to the type-system resource it binds.	`ts:Declaration`	`ts:Entity`
`ts:aliasTarget`	Connects an alias to its target type-system resource.	`ts:Alias`	`ts:Entity`
`ts:declaredType`	Connects a value to its explicitly declared type.	`ts:Value`	`ts:Type`
`ts:inferredType`	Connects a value to its inferred type.	`ts:Value`	`ts:Type`
`ts:defaultValue`	Connects a typed slot or parameter to its default value.	`ts:Entity`	`ts:Value`
`ts:subtypeOf`	Connects a source type to a supertype.	`ts:Type`	`ts:Type`
`ts:assignableTo`	Connects a source type to a target type to which values of the source can be assigned.	`ts:Type`	`ts:Type`
`ts:baseScalar`	Connects a scalar to the scalar it directly refines.	`ts:Scalar`	`ts:Scalar`
`ts:standardBaseScalar`	Connects a scalar to its nearest standard scalar value space.	`ts:Scalar`	`ts:Scalar`
`ts:numericRangeAssignableTo`	Connects numeric scalar types whose value ranges make assignment valid.	`ts:NumericType`	`ts:NumericType`
`ts:temporalKind`	Connects a temporal scalar to its value-space category.	`ts:TemporalType`	`ts:TemporalKind`
`ts:temporalZoneSemantics`	Connects a temporal scalar to its zone or offset semantics.	`ts:TemporalType`	`ts:TemporalZoneSemantics`
`ts:relationSourceType`	The source type of a type relation.	`ts:TypeRelation`	`ts:Type`
`ts:relationTargetType`	The target type of a type relation.	`ts:TypeRelation`	`ts:Type`
`ts:hasEvidence`	Connects a type relation to evidence supporting it.	`ts:TypeRelation`	`ts:TypeRelationEvidence`
`ts:evidenceRelation`	Connects evidence to the type relation it supports.	`ts:TypeRelationEvidence`	`ts:TypeRelation`
`ts:evidenceSourceType`	The source type described by type relation evidence.	`ts:TypeRelationEvidence`	`ts:Type`
`ts:evidenceTargetType`	The target type described by type relation evidence.	`ts:TypeRelationEvidence`	`ts:Type`
`ts:hasFieldMatch`	Connects type relation evidence to field-level match evidence.	`ts:TypeRelationEvidence`	`ts:FieldMatch`
`ts:hasAlternativeMatch`	Connects type relation evidence to union-alternative match evidence.	`ts:TypeRelationEvidence`	`ts:AlternativeMatch`
`ts:hasTupleElementMatch`	Connects type relation evidence to tuple-element match evidence.	`ts:TypeRelationEvidence`	`ts:TupleElementMatch`
`ts:hasCollectionElementTypeMatch`	Connects type relation evidence to collection element-type match evidence.	`ts:TypeRelationEvidence`	`ts:CollectionElementTypeMatch`
`ts:valueType`	The type of values accepted by a typed slot.	`ts:TypedSlot`	`ts:Type`
`ts:hasField`	Connects a record type to one of its fields.	`ts:RecordType`	`ts:Field`
`ts:fieldType`	The value type of a field.	`ts:Field`	`ts:Type`
`ts:fieldKey`	Connects a field to its declared key.	`ts:Field`	`ts:FieldKey`
`ts:fieldKeyKind`	Connects a field key to its key kind.	`ts:FieldKey`	`ts:FieldKeyKind`
`ts:elementType`	The common element type of a collection type.	`ts:CollectionType`	`ts:Type`
`ts:arrayValueType`	The element type accepted by an array type.	`ts:ArrayType`	`ts:Type`
`ts:streamElementType`	The element type delivered by a stream type.	`ts:StreamType`	`ts:Type`
`ts:tupleElement`	Connects a tuple type to one of its ordered elements.	`ts:TupleType`	`ts:TupleElement`
`ts:tupleElementType`	The value type of a tuple element.	`ts:TupleElement`	`ts:Type`
`ts:hasIndexerSlot`	Connects a collection type to a lookup slot.	`ts:CollectionType`	`ts:IndexerSlot`
`ts:indexerKeyType`	The key type accepted by an indexer slot.	`ts:IndexerSlot`	`ts:Type`
`ts:indexerValueType`	The value type returned by an indexer slot.	`ts:IndexerSlot`	`ts:Type`
`ts:recordKeyType`	The key type accepted by a record map.	`ts:RecordMapType`	`ts:Type`
`ts:recordValueType`	The value type accepted by a record map.	`ts:RecordMapType`	`ts:Type`
`ts:additionalPropertyType`	The type accepted by additional properties on a record-like type.	`ts:RecordType`	`ts:Type`
`ts:additionalPropertiesRecord`	Connects a record type to the record-map type that describes its additional fields.	`ts:RecordType`	`ts:RecordMapType`
`ts:intersectionConstituent`	Connects an intersection type to one of its constituent types.	`ts:IntersectionType`	`ts:Type`
`ts:hasUnionAlternative`	Connects a union to one of its alternatives.	`ts:Union`	`ts:UnionAlternative`
`ts:alternativeType`	The type admitted by a union alternative.	`ts:UnionAlternative`	`ts:Type`
`ts:nullableBaseType`	The non-null base type admitted by a nullable type.	`ts:NullableType`	`ts:Type`
`ts:admittedByUnion`	Connects a type to a union that admits values of that type.	`ts:Type`	`ts:Union`
`ts:unionVariantOf`	Connects a union variant to its owning union.	`ts:UnionVariant`	`ts:Union`
`ts:hasDiscriminator`	Connects a union to a discriminator used to distinguish its alternatives.	`ts:Union`	`ts:Discriminator`
`ts:discriminatorField`	Connects a discriminator to the field that carries the selector value.	`ts:Discriminator`	`ts:Field`
`ts:discriminatorValue`	Connects a union alternative or variant to its selector value.	`ts:UnionAlternative`	`ts:Value`
`ts:discriminatorEnvelope`	Connects a discriminator to its placement strategy.	`ts:Discriminator`	`ts:DiscriminatorEnvelope`
`ts:hasEnumMember`	Connects an enum to one of its members.	`ts:Enum`	`ts:EnumMember`
`ts:enumMemberType`	The value type used by an enum member.	`ts:EnumMember`	`ts:Type`
`ts:enumMemberValue`	The value denoted by an enum member.	`ts:EnumMember`	`ts:Value`
`ts:enumMemberOf`	Connects an enum member to its owning enum.	`ts:EnumMember`	`ts:Enum`
`ts:hasParameterSlot`	Connects a callable type to one of its parameter slots.	`ts:CallableType`	`ts:ParameterSlot`
`ts:hasResultSlot`	Connects a callable type to one of its result slots.	`ts:CallableType`	`ts:ResultSlot`
`ts:parameterType`	The value type accepted by a parameter slot.	`ts:ParameterSlot`	`ts:Type`
`ts:resultType`	The value type returned by a result slot.	`ts:ResultSlot`	`ts:Type`
`ts:hasCallable`	Connects a callable set type to a callable type.	`ts:CallableSetType`	`ts:CallableType`
`ts:membershipSet`	The callable set participating in a callable set membership.	`ts:CallableSetMembership`	`ts:CallableSetType`
`ts:membershipCallable`	The callable participating in a callable set membership.	`ts:CallableSetMembership`	`ts:CallableType`
`ts:literalBaseType`	The base type inhabited by a literal type.	`ts:LiteralType`	`ts:Type`
`ts:literalKind`	Connects a literal type to its controlled literal category.	`ts:LiteralType`	`ts:LiteralKind`
`ts:hasTemplatePart`	Connects a string template literal type to one of its ordered parts.	`ts:StringTemplateLiteralType`	`ts:StringTemplatePart`
`ts:templatePartValue`	The literal value carried by a string template part.	`ts:StringTemplatePart`	`ts:Value`
`ts:templatePartExpression`	The value expression interpolated by a string template part.	`ts:StringTemplatePart`	`ts:Value`
`ts:templatePartConformance`	A type relation proving that an interpolated value is string-compatible.	`ts:StringTemplatePart`	`ts:TypeRelation`
`ts:hasTemplateParameter`	Connects a generic type-system entity to one of its template parameters.	`ts:Entity`	`ts:TemplateParameter`
`ts:hasTypeParameter`	Connects a generic type-system entity to one of its type parameters.	`ts:Entity`	`ts:TypeParameter`
`ts:hasValueParameter`	Connects a generic type-system entity to one of its value parameters.	`ts:Entity`	`ts:ValueParameter`
`ts:hasTypeOrValueParameter`	Connects a generic type-system entity to one of its type-or-value parameters.	`ts:Entity`	`ts:TypeOrValueParameter`
`ts:typeParameterConstraint`	The type bound that a type parameter argument must satisfy.	`ts:TypeParameter`	`ts:Type`
`ts:typeParameterValueConstraint`	A value-space bound that a template parameter argument must satisfy.	`ts:TemplateParameter`	`ts:ValueOfType`
`ts:typeParameterDefaultType`	The default type used when a type parameter argument is omitted.	`ts:TypeParameter`	`ts:Type`
`ts:typeParameterDefaultValue`	The default value used when a value parameter argument is omitted.	`ts:TemplateParameter`	`ts:Value`
`ts:templateArgument`	Connects a template instantiation to one of its supplied arguments.	`ts:TemplateInstantiation`	`ts:TemplateArgument`
`ts:argumentParameter`	Connects a template argument to the parameter it satisfies.	`ts:TemplateArgument`	`ts:TemplateParameter`
`ts:argumentType`	The type supplied by a template argument.	`ts:TemplateArgument`	`ts:Type`
`ts:argumentValue`	The value supplied by a template argument.	`ts:TemplateArgument`	`ts:Value`
`ts:argumentExpression`	The raw type-system entity supplied as a template argument.	`ts:TemplateArgument`	`ts:Entity`
`ts:argumentConformance`	A type relation proving that a supplied template argument satisfies its parameter.	`ts:TemplateArgument`	`ts:TypeRelation`
`ts:parameterDefaultConformance`	A type relation proving that a template parameter default satisfies its constraint.	`ts:TemplateParameter`	`ts:TypeRelation`
`ts:instantiates`	Connects a template instantiation to the generic entity being instantiated.	`ts:TemplateInstantiation`	`ts:Entity`
`ts:resultingType`	The type produced by a template instantiation.	`ts:TemplateInstantiation`	`ts:Type`
`ts:valueOfBaseType`	The base type whose values satisfy a value-of type expression.	`ts:ValueOfType`	`ts:Type`
`ts:typeOfValue`	The value whose declared or inferred type is projected by a type-of expression.	`ts:TypeOfValue`	`ts:Value`
`ts:typeOfResultType`	The resolved result type of a type-of expression.	`ts:TypeOfValue`	`ts:Type`
`ts:hasInitializer`	Connects a scalar type to an initializer that can produce values for it.	`ts:Scalar`	`ts:ScalarInitializer`
`ts:initializerParameter`	Connects a scalar initializer to one of its parameter slots.	`ts:ScalarInitializer`	`ts:ParameterSlot`
`ts:initializerResult`	Connects a scalar initializer to the scalar type it produces.	`ts:ScalarInitializer`	`ts:Scalar`
`ts:initializerSemanticKind`	Connects a scalar initializer to its semantic category.	`ts:ScalarInitializer`	`ts:ScalarInitializerSemanticKind`
`ts:invokesInitializer`	Connects an initializer-call value to the scalar initializer it invokes.	`ts:ScalarInitializerCall`	`ts:ScalarInitializer`
`ts:hasInitializerArgument`	Connects an initializer-call value to one of its supplied arguments.	`ts:ScalarInitializerCall`	`ts:InitializerArgument`
`ts:initializerArgumentFor`	Connects an initializer argument to the parameter slot it satisfies.	`ts:InitializerArgument`	`ts:ParameterSlot`
`ts:initializerArgumentValue`	The value supplied for an initializer argument.	`ts:InitializerArgument`	`ts:Value`
`ts:objectMember`	Connects an object value to one of its members.	`ts:ObjectValue`	`ts:ObjectValueMember`
`ts:memberValue`	The value carried by an object member.	`ts:ObjectValueMember`	`ts:Value`
`ts:arrayItem`	Connects an array value to one of its ordered items.	`ts:ArrayValue`	`ts:ArrayValueItem`
`ts:itemValue`	The value carried by an array item.	`ts:ArrayValueItem`	`ts:Value`
`ts:matchSourceField`	The source field in a field match.	`ts:FieldMatch`	`ts:Field`
`ts:matchTargetField`	The target field in a field match.	`ts:FieldMatch`	`ts:Field`
`ts:fieldMatchRelation`	The field-level type relation proven by a field match.	`ts:FieldMatch`	`ts:TypeRelation`
`ts:matchSourceAlternative`	The source union alternative in an alternative match.	`ts:AlternativeMatch`	`ts:UnionAlternative`
`ts:matchTargetAlternative`	The target union alternative in an alternative match.	`ts:AlternativeMatch`	`ts:UnionAlternative`
`ts:alternativeMatchRelation`	The type relation proven by an alternative match.	`ts:AlternativeMatch`	`ts:TypeRelation`
`ts:matchSourceTupleElement`	The source tuple element in a tuple element match.	`ts:TupleElementMatch`	`ts:TupleElement`
`ts:matchTargetTupleElement`	The target tuple element in a tuple element match.	`ts:TupleElementMatch`	`ts:TupleElement`
`ts:tupleElementMatchRelation`	The element-level type relation proven by a tuple element match.	`ts:TupleElementMatch`	`ts:TypeRelation`
`ts:matchSourceElementType`	The source collection element type in a collection match.	`ts:CollectionElementTypeMatch`	`ts:Type`
`ts:matchTargetElementType`	The target collection element type in a collection match.	`ts:CollectionElementTypeMatch`	`ts:Type`
`ts:collectionElementMatchRelation`	The element-level type relation proven by a collection element type match.	`ts:CollectionElementTypeMatch`	`ts:TypeRelation`

Datatype Property Definitions

Datatype properties attach literal values such as key text, member names, numeric bounds, boolean flags, and ordering. Use them when a fact is scalar data rather than a link to another modeled resource.

Term	Definition	Domain	Range
`ts:keyText`	The textual key of a field key.	`ts:FieldKey`	`xsd:string`
`ts:lexicalValue`	The normalized lexical value represented by a literal or scalar value.	`ts:Entity`	`xsd:string`
`ts:memberName`	The local name of an enum member or union variant.	`ts:Entity`	`xsd:string`
`ts:literalValue`	The literal value represented by a literal type. This property intentionally has no fixed datatype range because literal types can represent string, numeric, boolean, null, or domain-specific literal values.	`ts:LiteralType`	Not constrained by this ontology
`ts:stringValue`	A concrete string value.	`ts:Entity`	`xsd:string`
`ts:numericValue`	A concrete numeric value.	`ts:Entity`	`xsd:decimal`
`ts:booleanValue`	A concrete boolean value.	`ts:Entity`	`xsd:boolean`
`ts:isIntegralNumericValue`	Whether a numeric literal value is integral.	`ts:NumericLiteralType`	`xsd:boolean`
`ts:ordinal`	A zero-based structural ordering number for a slot, alternative, member, or argument.	`ts:Entity`	`xsd:integer`
`ts:minCount`	The minimum number of values accepted by a typed slot.	`ts:TypedSlot`	`xsd:integer`
`ts:maxCount`	The maximum number of values accepted by a typed slot.	`ts:TypedSlot`	`xsd:integer`
`ts:isOptional`	Whether a typed slot can be omitted.	`ts:TypedSlot`	`xsd:boolean`
`ts:isVariadic`	Whether a typed slot accepts a variable number of values.	`ts:TypedSlot`	`xsd:boolean`
`ts:minValue`	A numeric lower bound for a type.	`ts:Type`	`xsd:decimal`
`ts:maxValue`	A numeric upper bound for a type.	`ts:Type`	`xsd:decimal`
`ts:numericBitWidth`	The bit width of a numeric scalar type.	`ts:NumericType`	`xsd:integer`
`ts:numericRadix`	The radix used to describe a numeric scalar representation.	`ts:NumericType`	`xsd:integer`
`ts:numericPrecisionDigits`	The number of significant digits represented by a numeric scalar type.	`ts:NumericType`	`xsd:integer`
`ts:numericMinFiniteMagnitude`	The smallest finite magnitude represented by an approximate numeric type.	`ts:NumericType`	`xsd:decimal`
`ts:numericMaxFiniteMagnitude`	The largest finite magnitude represented by an approximate numeric type.	`ts:NumericType`	`xsd:decimal`
`ts:minExponent`	The minimum exponent accepted by a decimal or floating numeric type.	`ts:NumericType`	`xsd:integer`
`ts:maxExponent`	The maximum exponent accepted by a decimal or floating numeric type.	`ts:NumericType`	`xsd:integer`
`ts:minLength`	A string length lower bound for a type.	`ts:Type`	`xsd:integer`
`ts:maxLength`	A string length upper bound for a type.	`ts:Type`	`xsd:integer`
`ts:minItems`	A collection item-count lower bound for a type.	`ts:Type`	`xsd:integer`
`ts:maxItems`	A collection item-count upper bound for a type.	`ts:Type`	`xsd:integer`
`ts:isExactType`	Whether a type has an exact closed shape or value space.	`ts:Type`	`xsd:boolean`
`ts:isAnonymous`	Whether a type is anonymous rather than declaration-named.	`ts:Type`	`xsd:boolean`
`ts:isBuiltInType`	Whether a type is supplied by the type system.	`ts:Type`	`xsd:boolean`
`ts:isUserDefinedType`	Whether a type is authored outside the built-in type set.	`ts:Type`	`xsd:boolean`
`ts:argumentName`	The supplied name of a named template argument.	`ts:TemplateArgument`	`xsd:string`
`ts:isNamedArgument`	Whether a template argument was supplied by name.	`ts:TemplateArgument`	`xsd:boolean`
`ts:argumentEvaluationOrdinal`	The parameter-order position used to evaluate a template argument.	`ts:TemplateArgument`	`xsd:integer`
`ts:evidenceRule`	A short rule label for type relation evidence.	`ts:TypeRelationEvidence`	`xsd:string`

Built-In Individual Definitions

Built-in individuals are reusable named resources for intrinsic types, controlled categories, and standard scalar value spaces. They should be referenced directly instead of recreated in an application namespace.

Term	Preferred label	Definition	Type
`ts:unknown`	`unknown`	Built-in placeholder for values whose specific type is unknown or unresolved.	`ts:UnknownType`, `ts:IntrinsicType`
`ts:any`	`any`	Built-in permissive type that suppresses normal assignability precision.	`ts:AnyType`, `ts:IntrinsicType`
`ts:void`	`void`	Built-in absence-of-result type for callables that do not return a value.	`ts:VoidType`, `ts:IntrinsicType`
`ts:never`	`never`	Built-in bottom type that no value can inhabit.	`ts:NeverType`, `ts:IntrinsicType`
`ts:null`	`null`	Built-in singleton null type.	`ts:NullType`, `ts:IntrinsicType`
`ts:stringLiteral`	`stringLiteral`	Literal-kind individual for exact string literal value spaces.	`ts:LiteralKind`
`ts:numericLiteral`	`numericLiteral`	Literal-kind individual for exact numeric literal value spaces.	`ts:LiteralKind`
`ts:booleanLiteral`	`booleanLiteral`	Literal-kind individual for exact boolean literal value spaces.	`ts:LiteralKind`
`ts:nullLiteral`	`nullLiteral`	Literal-kind individual for the exact null literal value space.	`ts:LiteralKind`
`ts:enumMemberReferenceLiteral`	`enumMemberReferenceLiteral`	Literal-kind individual for a literal type that references an enum member.	`ts:LiteralKind`
`ts:unionVariantReferenceLiteral`	`unionVariantReferenceLiteral`	Literal-kind individual for a literal type that references a union variant.	`ts:LiteralKind`
`ts:identifierFieldKey`	`identifier`	Field-key-kind individual for keys represented as ordinary identifiers.	`ts:FieldKeyKind`
`ts:escapedIdentifierFieldKey`	`escapedIdentifier`	Field-key-kind individual for identifier keys that require escaping.	`ts:FieldKeyKind`
`ts:stringLiteralFieldKey`	`stringLiteral`	Field-key-kind individual for keys represented as string literals.	`ts:FieldKeyKind`
`ts:calendarDateTemporalKind`	`calendarDate`	Temporal-kind individual for calendar-date value spaces.	`ts:TemporalKind`
`ts:clockTimeTemporalKind`	`clockTime`	Temporal-kind individual for clock-time value spaces.	`ts:TemporalKind`
`ts:dateTimeTemporalKind`	`dateTime`	Temporal-kind individual for date-time or instant value spaces.	`ts:TemporalKind`
`ts:durationTemporalKind`	`duration`	Temporal-kind individual for duration value spaces.	`ts:TemporalKind`
`ts:noZoneTemporalSemantics`	`noZone`	Temporal-zone-semantics individual for temporal values with no zone or offset.	`ts:TemporalZoneSemantics`
`ts:utcTemporalSemantics`	`utc`	Temporal-zone-semantics individual for temporal values normalized to UTC.	`ts:TemporalZoneSemantics`
`ts:offsetTemporalSemantics`	`offset`	Temporal-zone-semantics individual for temporal values carrying an explicit offset.	`ts:TemporalZoneSemantics`
`ts:notApplicableTemporalSemantics`	`notApplicable`	Temporal-zone-semantics individual used when zone semantics do not apply.	`ts:TemporalZoneSemantics`
`ts:envelopeObject`	`object`	Discriminator-envelope individual for object-shaped discriminated unions.	`ts:DiscriminatorEnvelope`
`ts:envelopeNone`	`none`	Discriminator-envelope individual for unions with no discriminator envelope.	`ts:DiscriminatorEnvelope`
`ts:scalarValueConversionInitializer`	`valueConversion`	Scalar-initializer semantic kind for value-conversion constructors.	`ts:ScalarInitializerSemanticKind`
`ts:isoLexicalParseInitializer`	`isoLexicalParse`	Scalar-initializer semantic kind for ISO lexical parsing.	`ts:ScalarInitializerSemanticKind`
`ts:currentTemporalInitializer`	`currentTemporal`	Scalar-initializer semantic kind for constructors that produce the current temporal value.	`ts:ScalarInitializerSemanticKind`
`ts:string`	`string`	Built-in textual scalar value space and the standard base scalar for string-like refinements.	`ts:StringType`, `ts:IntrinsicType`
`ts:url`	`url`	Built-in URL scalar refined from the string value space.	`ts:UrlType`, `ts:IntrinsicType`
`ts:bytes`	`bytes`	Built-in byte-sequence scalar value space.	`ts:BytesType`, `ts:IntrinsicType`
`ts:boolean`	`boolean`	Built-in true-or-false scalar value space.	`ts:BooleanType`, `ts:IntrinsicType`
`ts:numeric`	`numeric`	Built-in abstract numeric scalar value space.	`ts:NumericType`, `ts:IntrinsicType`
`ts:integer`	`integer`	Built-in whole-number numeric scalar value space.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:int8`	`int8`	Built-in 8-bit signed integer scalar with range -128 through 127.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:int16`	`int16`	Built-in 16-bit signed integer scalar with range -32768 through 32767.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:int32`	`int32`	Built-in 32-bit signed integer scalar with range -2147483648 through 2147483647.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:int64`	`int64`	Built-in 64-bit signed integer scalar with range -9223372036854775808 through 9223372036854775807.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:safeint`	`safeint`	Built-in integer scalar for exactly representable JavaScript-safe integers, with range -9007199254740991 through 9007199254740991.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:uint8`	`uint8`	Built-in 8-bit unsigned integer scalar with range 0 through 255.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:uint16`	`uint16`	Built-in 16-bit unsigned integer scalar with range 0 through 65535.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:uint32`	`uint32`	Built-in 32-bit unsigned integer scalar with range 0 through 4294967295.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:uint64`	`uint64`	Built-in 64-bit unsigned integer scalar with range 0 through 18446744073709551615.	`ts:IntegerType`, `ts:IntrinsicType`
`ts:float`	`float`	Built-in abstract floating-point scalar value space.	`ts:FloatType`, `ts:IntrinsicType`
`ts:float32`	`float32`	Built-in binary32 floating-point scalar with radix 2 and 24 significant binary digits.	`ts:FloatType`, `ts:IntrinsicType`
`ts:float64`	`float64`	Built-in binary64 floating-point scalar with radix 2 and 53 significant binary digits.	`ts:FloatType`, `ts:IntrinsicType`
`ts:decimal`	`decimal`	Built-in abstract decimal scalar value space.	`ts:DecimalType`, `ts:IntrinsicType`
`ts:decimal128`	`decimal128`	Built-in decimal128 scalar with radix 10, 34 significant digits, and exponent range -6143 through 6144.	`ts:DecimalType`, `ts:IntrinsicType`
`ts:plainDate`	`plainDate`	Built-in calendar-date scalar with no zone semantics.	`ts:DateType`, `ts:IntrinsicType`
`ts:plainTime`	`plainTime`	Built-in clock-time scalar with no zone semantics.	`ts:TimeType`, `ts:IntrinsicType`
`ts:utcDateTime`	`utcDateTime`	Built-in date-time scalar whose instants use UTC zone semantics.	`ts:DateTimeType`, `ts:IntrinsicType`
`ts:offsetDateTime`	`offsetDateTime`	Built-in date-time scalar that preserves an explicit offset.	`ts:DateTimeType`, `ts:IntrinsicType`
`ts:duration`	`duration`	Built-in temporal duration scalar.	`ts:DurationType`, `ts:IntrinsicType`
`ts:unixTimestamp32`	`unixTimestamp32`	Built-in UTC date-time represented as a signed 32-bit Unix timestamp over -2147483648 through 2147483647.	`ts:IntegerType`, `ts:DateTimeType`, `ts:IntrinsicType`

Terms	Use
`ts:hasDeclaration`, `ts:declares`, `ts:aliasTarget`	Vocabulary, namespace, declaration, and alias links.
`skos:prefLabel`, `ts:keyText`, `ts:lexicalValue`, `ts:memberName`	Preferred labels, field key text, normalized lexical values, and member name text.
`ts:isExactType`, `ts:isAnonymous`, `ts:isBuiltInType`, `ts:isUserDefinedType`	Boolean flags for exact, anonymous, built-in, and user-defined type identity.

Terms	Use
`ts:declaredType`, `ts:inferredType`, `ts:defaultValue`	Value typing and typed defaults.
`ts:subtypeOf`, `ts:assignableTo`, `ts:baseScalar`, `ts:standardBaseScalar`, `ts:numericRangeAssignableTo`	Type hierarchy, assignability, scalar refinement, and numeric widening.
`ts:temporalKind`, `ts:temporalZoneSemantics`	Temporal scalar value-space and zone semantics.
`ts:minValue`, `ts:maxValue`, `ts:numericBitWidth`, `ts:numericRadix`, `ts:numericPrecisionDigits`, `ts:numericMinFiniteMagnitude`, `ts:numericMaxFiniteMagnitude`, `ts:minExponent`, `ts:maxExponent`	Numeric scalar facets and bounds.
`ts:minLength`, `ts:maxLength`, `ts:minItems`, `ts:maxItems`, `ts:isIntegralNumericValue`	String length facets, collection item-count facets, and integral numeric literal flags.

Terms	Use
`ts:valueType`, `ts:fieldType`, `ts:tupleElementType`, `ts:indexerValueType`, `ts:parameterType`, `ts:resultType`, `ts:alternativeType`	Concrete subproperties that attach value spaces to typed slots.
`ts:hasField`, `ts:fieldKey`, `ts:fieldKeyKind`, `ts:tupleElement`, `ts:hasIndexerSlot`, `ts:indexerKeyType`	Record fields, field key kinds, tuple elements, and indexer keys.
`ts:elementType`, `ts:arrayValueType`, `ts:streamElementType`, `ts:recordKeyType`, `ts:recordValueType`, `ts:additionalPropertyType`, `ts:additionalPropertiesRecord`	Collection, array, stream, record-map, and additional-property value spaces.
`ts:intersectionConstituent`	Constituent type membership for intersection types.
`ts:ordinal`, `ts:minCount`, `ts:maxCount`, `ts:isOptional`, `ts:isVariadic`	Ordering and cardinality for fields, tuple elements, alternatives, parameters, results, and arguments.

Terms	Use
`ts:hasUnionAlternative`, `ts:nullableBaseType`, `ts:admittedByUnion`, `ts:unionVariantOf`	Union alternatives, nullable base type, union admission, and variant ownership.
`ts:hasDiscriminator`, `ts:discriminatorField`, `ts:discriminatorValue`, `ts:discriminatorEnvelope`	Discriminator facts for union alternatives.
`ts:hasEnumMember`, `ts:enumMemberType`, `ts:enumMemberValue`, `ts:enumMemberOf`	Enum membership, member value spaces, concrete member values, and enum ownership.

Terms	Use
`ts:hasParameterSlot`, `ts:hasResultSlot`, `ts:hasCallable`, `ts:membershipSet`, `ts:membershipCallable`	Callable signatures, callable-set members, and explicit membership facts.
`ts:hasTemplateParameter`, `ts:hasTypeParameter`, `ts:hasValueParameter`, `ts:hasTypeOrValueParameter`	Generic type-system parameter ownership.
`ts:typeParameterConstraint`, `ts:typeParameterValueConstraint`, `ts:typeParameterDefaultType`, `ts:typeParameterDefaultValue`	Template parameter constraints and defaults.
`ts:templateArgument`, `ts:argumentParameter`, `ts:argumentType`, `ts:argumentValue`, `ts:argumentExpression`, `ts:argumentConformance`, `ts:parameterDefaultConformance`	Supplied template arguments, raw argument expressions, and conformance evidence.
`ts:argumentName`, `ts:isNamedArgument`, `ts:argumentEvaluationOrdinal`	Named argument and argument ordering facts.
`ts:instantiates`, `ts:resultingType`, `ts:valueOfBaseType`, `ts:typeOfValue`, `ts:typeOfResultType`	Instantiation input/result and type-level value expressions.

Terms	Use
`ts:literalBaseType`, `ts:literalKind`, `ts:literalValue`, `ts:stringValue`, `ts:numericValue`, `ts:booleanValue`	Literal value spaces and scalar value content.
`ts:hasTemplatePart`, `ts:templatePartValue`, `ts:templatePartExpression`, `ts:templatePartConformance`	String template literal parts, interpolated expressions, and conformance checks.
`ts:objectMember`, `ts:memberValue`, `ts:arrayItem`, `ts:itemValue`	Object and array value structure.

Terms	Use
`ts:hasInitializer`, `ts:initializerParameter`, `ts:initializerResult`, `ts:initializerSemanticKind`	Scalar initializer availability, parameters, result scalar, and semantic kind.
`ts:invokesInitializer`, `ts:hasInitializerArgument`, `ts:initializerArgumentFor`, `ts:initializerArgumentValue`	Initializer calls and supplied argument values.

Terms	Use
`ts:relationSourceType`, `ts:relationTargetType`, `ts:hasEvidence`, `ts:evidenceRelation`, `ts:evidenceSourceType`, `ts:evidenceTargetType`, `ts:evidenceRule`	Type relation endpoints, attached evidence, and rule labels.
`ts:hasFieldMatch`, `ts:matchSourceField`, `ts:matchTargetField`, `ts:fieldMatchRelation`	Field-level structural relation evidence.
`ts:hasAlternativeMatch`, `ts:matchSourceAlternative`, `ts:matchTargetAlternative`, `ts:alternativeMatchRelation`	Union alternative coverage evidence.
`ts:hasTupleElementMatch`, `ts:matchSourceTupleElement`, `ts:matchTargetTupleElement`, `ts:tupleElementMatchRelation`	Tuple element structural relation evidence.
`ts:hasCollectionElementTypeMatch`, `ts:matchSourceElementType`, `ts:matchTargetElementType`, `ts:collectionElementMatchRelation`	Collection element type relation evidence.

Family	Individuals
Intrinsic	`ts:unknown`, `ts:any`, `ts:void`, `ts:never`, `ts:null`
Scalars	`ts:string`, `ts:url`, `ts:bytes`, `ts:boolean`, `ts:numeric`, `ts:integer`, `ts:int8`, `ts:int16`, `ts:int32`, `ts:int64`, `ts:safeint`, `ts:uint8`, `ts:uint16`, `ts:uint32`, `ts:uint64`, `ts:float`, `ts:float32`, `ts:float64`, `ts:decimal`, `ts:decimal128`, `ts:plainDate`, `ts:plainTime`, `ts:utcDateTime`, `ts:offsetDateTime`, `ts:duration`, `ts:unixTimestamp32`
Literal kinds	`ts:stringLiteral`, `ts:numericLiteral`, `ts:booleanLiteral`, `ts:nullLiteral`, `ts:enumMemberReferenceLiteral`, `ts:unionVariantReferenceLiteral`
Field key kinds	`ts:identifierFieldKey`, `ts:escapedIdentifierFieldKey`, `ts:stringLiteralFieldKey`
Temporal categories	`ts:calendarDateTemporalKind`, `ts:clockTimeTemporalKind`, `ts:dateTimeTemporalKind`, `ts:durationTemporalKind`, `ts:noZoneTemporalSemantics`, `ts:utcTemporalSemantics`, `ts:offsetTemporalSemantics`, `ts:notApplicableTemporalSemantics`
Discriminator envelopes	`ts:envelopeObject`, `ts:envelopeNone`
Initializer kinds	`ts:scalarValueConversionInitializer`, `ts:isoLexicalParseInitializer`, `ts:currentTemporalInitializer`

Namespace

Model Overview

Core Identity

Type Taxonomy

Structured Types

Choice Types

Callables And Templates

Literals And Values

Scalar Initializers

Type Relations

Class Model

Core Identity And Declarations

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Type Roots And Intrinsics

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Scalar And Temporal Types

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Structured And Collection Types

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Choice Types

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Modeling Notes

Callables, Templates, And Type Expressions

Modeling Notes