@metreeca/blue - v0.12.0
    Preparing search index...

    Type Alias Property<R, L, U>

    Property: PropertyConstraints<Reference> & {
        kind: "property";
        range: Range<R, L, U>;
    }

    A member carrying values of its own.

    Holds the range its values are drawn from, stating their shape and how many of them a resource may carry, alongside the predicate the values are stored under and the labels the member is presented by. The predicate is an absolute IRI: a Namespace shorthand stated where the member is declared is resolved by the time the shape is built.

    Localised text stands apart from the cardinality: a member ranging over a dictionary carries the language map whole, never in an array, whatever bounds it states; one ranging over a dictionary alongside other alternatives carries either the map or the values of those alternatives, never both, and the bounds count the latter alone.

    Inheritance

    Where a shape extends the ones it lists as parents, members stated on both sides are merged according to the following rules. The child is the extending shape; the parent is the inherited one.

    Field Override Rule
    kind Cannot be overridden
    hidden Inherited; conflicting parents without a child override are reported as an error
    foreign Cannot be overridden
    captive Cannot be overridden
    name Cannot be overridden
    description Cannot be overridden
    forward Cannot be overridden
    reverse Cannot be overridden
    range Child may only narrow the inherited range, bound by bound and shape by shape

    A child narrows the range it inherits by raising its lower bound, lowering its upper bound or restricting its shape, and never the other way round. A bound left unstated leaves that end unbounded rather than unsaid, so a child stating none inherits the bound the parent states.

    A child narrowing a resource range states a shape belonging to every class the inherited range declares, whether stated in its own right or inherited, so that a value of the narrowed member is a value of the inherited one, class included.

    A child overriding a polymorphic range either narrows it to the single alternative it restricts, restating no wrapper of its own, or states a union of its own whose every branch narrows a distinct inherited alternative, dropping the ones left unclaimed; a branch restricting none, or several, is rejected as ambiguous.

    Cross-field validation

    • the merged lower bound must not exceed the merged upper bound, which each may narrow on its own and still cross

    Type Parameters

    • R extends Lazy<Shape> = Lazy<Shape>

      The shape the values are drawn from, possibly deferred to break definition cycles

    • L extends Optional<number> = Optional<number>

      The least number of values admitted

    • U extends Optional<number> = Optional<number>

      The greatest number of values admitted

    Type Declaration

    • Readonlykind: "property"

      Discriminator identifying this as a member carrying values.

      Inheritance — cannot be overridden.

    • Readonlyrange: Range<R, L, U>

      Value set the property carries.

      States the shape every value is drawn from and how many of them a resource may carry. A path resolved through the property yields a Range of the same form, so the range a property states and the one a path reaches are read alike.

      Inheritance — child may only narrow the inherited range, bound by bound and shape by shape.