activitystreams/activitystreams.scm \

  http-signature/ontology.scm \

;;;; Copyright (C) 2020 Julien Lepiller <julien@lepiller.eu>

;;;; 

;;;; This library is free software; you can redistribute it and/or

;;;; modify it under the terms of the GNU Lesser General Public

;;;; License as published by the Free Software Foundation; either

;;;; version 3 of the License, or (at your option) any later version.

;;;; 

;;;; This library is distributed in the hope that it will be useful,

;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of

;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

;;;; Lesser General Public License for more details.

;;;; 

;;;; You should have received a copy of the GNU Lesser General Public

;;;; License along with this library; if not, write to the Free Software

;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

;;;; 

(define-module (activitystreams activitystreams)

  #:use-module (ice-9 match)

  #:use-module (srfi srfi-9)

  #:export (as:type

            as:type?

            as:type-label

            as:type-uri

            as:type-comment

            as:type-subclass-of

            as:property

            as:property?

            as:property-label

            as:property-uri

            as:property-range

            as:property-domain

            as:property-functional?

            as:property-subproperty-of

            as:property-comment

            make-as-type

            make-as-property

            make-ontological-parser

            as-ref

            as:type-of-type?

            as:property-of-type?))

(define as:vocab "https://www.w3.org/ns/activitystreams#")

(define-record-type as:type

  (make-as:type label uri comment subclass-of)

  as:type?

  (label       as:type-label)

  (uri         as:type-uri)

  (comment     as:type-comment)

  (subclass-of as:type-subclass-of))

(define* (make-as-type label #:key (uri (string-append as:vocab label))

                       (comment "") (subclass-of '()))

  (make-as:type label uri comment subclass-of))

(define-record-type as:property

  (make-as:property label uri range domain functional? subproperty-of comment)

  as:property?

  (label          as:property-label)

  (uri            as:property-uri)

  (domain         as:property-domain)

  (range          as:property-range)

  (functional?    as:property-functional?)

  (subproperty-of as:property-subproperty-of)

  (comment        as:property-comment))

(define* (make-as-property label domain range

                           #:key (uri (string-append as:vocab label))

                           (functional? #f) (subproperty-of '()) (comment ""))

  (make-as:property label uri range domain functional? subproperty-of comment))

(define (make-ontological-parser ontology)

  "Creates a parser from an ontology: takes json document as input and outputs

the best possible document as an alist (or array of alists) whose keys are an

as:property and value is the associated expanded value.  It also perfoms type

checking to ensure the document is well-parsed.  When the document doesn't respect

the ontology, throws an exception.  Type is in the key @type and its value

is a as:type."

  (define (candidate-type type)

    (filter

      (lambda (o)

        (and

          (as:type? o)

          (equal? (as:type-uri o) type)))

      ontology))

  (define (candidate-property name)

    (filter

      (lambda (p)

        (and

          (as:property? p)

          (equal? (as:property-uri p) name)))

      ontology))

  (define (in-range property value)

    (match (as:property-range property)

      ((? string? type)

       (as:type-of-type? (assoc-ref value "@type") type))

      ((? procedure? proc)

       (proc value))

      (()

       #f)

      ((? list? l)

       (or (in-range (car l) value) (in-range (cdr l) value)))

      (range (throw 'invalid-property-range range))))

  (define (in-domain property type)

    (match (as:property-domain property)

      ((? string? parent)

       (as:type-of-type? type parent))

      ((? procedure? proc)

       (proc type))

      (()

       #f)

      ((? list? l)

       (or (in-domain (car l) type) (in-domain (cdr l) type)))))

  (define (parse json)

    (if (assoc-ref json "@value")

      json

      ;; TODO: there might be more than one @type...

      (let ((type (car (candidate-type (assoc-ref json "@type")))))

        (let loop ((result `(("@type" . ,type))) (json json))

          (match json

            (() result)

            (((k . v) json ...)

             (let ((candidates (candidate-property k)))

               (cond

                 ((equal? k "@type")

                  (loop result json))

                 ((null? candidates)

                  (loop result json))

                 (else

                   (let ((property (car candidates))

                         (value (parse v)))

                     (unless (in-range property value)

                       (throw 'value-type-mismatch property value))

                     (unless (in-domain property type)

                       (throw 'property-not-supported property value))

                     (loop (cons (cons property value) result) json)))))))))))

  parse)

(define (as:property-of-type? property label)

  (or (equal? (as:property-label property) label)

      (let loop ((subproperties (as:property-subproperty-of property)))

        (match subproperties

          (() #f)

          ((property subproperties ...)

           (or (as:property-of-type? property label)

               (loop subproperties)))))))

(define (as:type-of-type? type label)

  (or (equal? (as:type-label type) label)

      (let loop ((subclasses (as:type-subclass-of type)))

        (match subclasses

          (() #f)

          ((type subclasses ...)

           (or (as:type-of-type? type label)

               (loop subclasses)))))))

(define (as-ref document key)

  "Takes a parsed document and returns the value associated with the property.

This takes care of subproperties: if you look for a property that's not in the

document directly, but the document has a subproperty of it, this will be

returned.  The key must be a proper label as defined in the ontology."

  (define (is-candidate kv)

    (match kv

      ((k . v)

       (as:property-of-type? k key))))

  (let ((candidates (filter is-candidate document)))

    (map cdr candidates)))

;;;; Copyright (C) 2020 Julien Lepiller <julien@lepiller.eu>

;;;;

;;;;

;;;; Note that most of this file is a direct translation of the activitystreams

;;;; vocabulary specification (esp. comments in as:type and as:property) which

;;;; is under these terms:

;;;;

;;;;    Copyright ?? 2017 Activity Streams Working Group, IBM & W3C?? (MIT,

;;;;    ERCIM, Keio, Beihang). W3C liability, trademark and permissive

;;;;    document license rules apply.

;;;;

;;;; You should have received a copy of the Permissive Document License along

;;;; with this library; if not, that document license is accessible online at:

;;;; https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document

;;;;

;;;; The origin document used to develop this can be found at:

;;;; https://www.w3.org/TR/activitystreams-vocabulary

  #:use-module (activitystreams activitystreams)

  #:use-module (web uri)

  #:export (activitystreams-ontology))

;; Core types

(define as:Object

  (make-as-type

    "Object"

    #:comment

    "Describes an object of any kind.  The Object type serves as the base type

for most of the other kinds of objects defined in the Activity Vocabulary,

including other Core types such as Activity, IntransitiveActivity, Collection

and OrderedCollection."))

(define as:Link

  (make-as-type

    "Link"

    #:comment

    "A Link is an indirect, qualified reference to a resource identified by a

URL.  The fundamental model for links is established by [RFC5988].  Many of the

properties defined by the Activity Vocabulary allow values that are either

instances of Object or Link.  When a Link is used, it establishes a qualified

relation connecting the subject (the containing object) to the resource

identified by the href.  Properties of the Link are properties of the

reference as opposed to properties of the resource."))

(define as:Activity

  (make-as-type

    "Activity"

    #:subclass-of (list as:Object)

    #:comment

    "An Activity is a subtype of Object that describes some form of action that

may happen, is currently happening, or has already happened.  The Activity type

itself serves as an abstract base type for all types of activities.  It is

important to note that the Activity type itself does not carry any specific

semantics about the kind of action being taken."))

(define as:IntransitiveActivity

  (make-as-type

    "IntrasitiveActivity"

    #:subclass-of (list as:Activity)

    #:comment

    "Instances of IntransitiveActivity are a subtype of Activity representing

intransitive actions.  The object property is therefore inappropriate for

these activities."))

(define as:Collection

  (make-as-type

    "Collection"

    #:subclass-of (list as:Object)

    #:comment

    "A Collection is a subtype of Object that represents ordered or unordered

sets of Object or Link instances.  Refer to the Activity Streams 2.0 Core

specification for a complete description of the Collection type."))

(define as:OrderedCollection

  (make-as-type

    "OrderedCollection"

    #:subclass-of (list as:Collection)

    #:comment

    "A subtype of Collection in which members of the logical collection are

assumed to always be strictly ordered."))

(define as:CollectionPage

  (make-as-type

    "CollectionPage"

    #:subclass-of (list as:Collection)

    #:comment

    "Used to represent distinct subsets of items from a Collection.  Refer to

the Activity Streams 2.0 Core for a complete description of the CollectionPage

object."))

(define as:OrderedCollectionPage

  (make-as-type

    "OrderedCollectionPage"

    #:subclass-of (list as:OrderedCollection as:CollectionPage)

    #:comment

    "Used to represent ordered subsets of items from an OrderedCollection.

Refer to the Activity Streams 2.0 Core for a complete description of the

OrderedCollectionPage object."))

(define as-core-types (list as:Object as:Link as:Activity as:IntransitiveActivity

                            as:Collection as:OrderedCollection as:CollectionPage

                            as:OrderedCollectionPage))

;; Extended Types

;; Activity Types

(define as:Accept

  (make-as-type

    "Accept"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor accepts the object.  The target property can be

used in certain circumstances to indicate the context into which the object has

been accepted."))

(define as:TentativeAccept

  (make-as-type

    "TentativeAccept"

    #:subclass-of (list as:Accept)

    #:comment

    "A specialization of Accept indicating that the acceptance is tentative."))

(define as:Add

  (make-as-type

    "Add"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has added the object to the target.  If the target

property is not explicitly specified, the target would need to be determined

implicitly by context.  The origin can be used to identify the context from

which the object originated."))

(define as:Arrive

  (make-as-type

    "Arrive"

    #:subclass-of (list as:IntransitiveActivity)

    #:comment

    "An IntransitiveActivity that indicates that the actor has arrived at the

location.  The origin can be used to identify the context from which the actor

originated.  The target typically has no defined meaning."))

(define as:Create

  (make-as-type

    "Create"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has created the object."))

(define as:Delete

  (make-as-type

    "Delete"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has deleted the object.  If specified, the origin

indicates the context from which the object was deleted."))

(define as:Follow

  (make-as-type

    "Follow"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is ``following'' the object.  Following is defined

in the sense typically used within Social systems in which the actor is

interested in any activity performed by or on the object.  The target and

origin typically have no defined meaning."))

(define as:Ignore

  (make-as-type

    "Ignore"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is ignoring the object.  The target and origin

typically have no defined meaning."))

(define as:Join

  (make-as-type

    "Join"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has joined the object.  The target and origin

typically have no defined meaning."))

(define as:Leave

  (make-as-type

    "Leave"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has left the object.  The target and origin

typically have no meaning."))

(define as:Like

  (make-as-type

    "Like"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor likes, recommends or endorses the object.  The

target and origin typically have no defined meaning."))

(define as:Offer

  (make-as-type

    "Offer"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is offering the object.  If specified, the target

indicates the entity to which the object is being offered."))

(define as:Invite

  (make-as-type

    "Invite"

    #:subclass-of (list as:Offer)

    #:comment

    "A specialization of Offer in which the actor is extending an invitation

for the object to the target."))

(define as:Reject

  (make-as-type

    "Reject"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is rejecting the object.  The target and origin

typically have no defined meaning."))

(define as:TentativeReject

  (make-as-type

    "TentativeReject"

    #:subclass-of (list as:Reject)

    #:comment

    "A specialization of Reject in which the rejection is considered tentative."))

(define as:Remove

  (make-as-type

    "Remove"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is removing the object.  If specified, the

origin indicates the context from which the object is being removed."))

(define as:Undo

  (make-as-type

    "Undo"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is undoing the object.  In most cases, the object

will be an Activity describing some previously performed action (for instance,

a person may have previously ``liked'' an article but, for whatever reason,

might choose to undo that like at some later point in time).  The target and

origin typically have no defined meaning."))

(define as:Update

  (make-as-type

    "Update"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has updated the object.  Note, however, that this

vocabulary does not define a mechanism for describing the actual set of

modifications made to object.  The target and origin typically have no defined

meaning."))

(define as:View

  (make-as-type

    "View"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has viewed the object."))

(define as:Listen

  (make-as-type

    "Listen"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has listened to the object."))

(define as:Read

  (make-as-type

    "Read"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has read the object."))

(define as:Move

  (make-as-type

    "Move"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor has moved object from origin to target.  If the

origin or target are not specified, either can be determined by context."))

(define as:Travel

  (make-as-type

    "Travel"

    #:subclass-of (list as:IntransitiveActivity)

    #:comment

    "Indicates that the actor is traveling to target from origin.  Travel is

an IntransitiveObject whose actor specifies the direct object.  If the target

or origin are not specified, either can be determined by context."))

(define as:Announce

  (make-as-type

    "Announce"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is calling the target's attention the object.  The

origin typically has no defined meaning."))

(define as:Block

  (make-as-type

    "Block"

    #:subclass-of (list as:Ignore)

    #:comment

    "Indicates that the actor is blocking the object.  Blocking is a stronger

form of Ignore.  The typical use is to support social systems that allow one

user to block activities or content of other users.  The target and origin

typically have no defined meaning."))

(define as:Flag

  (make-as-type

    "Flag"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor is ``flagging'' the object.  Flagging is defined

in the sense common to many social platforms as reporting content as being

inappropriate for any number of reasons."))

(define as:Dislike

  (make-as-type

    "Dislike"

    #:subclass-of (list as:Activity)

    #:comment

    "Indicates that the actor dislikes the object."))

(define as:Question

  (make-as-type

    "Question"

    #:subclass-of (list as:IntransitiveActivity)

    #:comment

    "Represents a question being asked.  Question objects are an extension of

IntransitiveActivity.  That is, the Question object is an Activity, but the

direct object is the question itself and therefore it would not contain an

object property.  Either of the anyOf and oneOf properties MAY be used to

express possible answers, but a Question object MUST NOT have both properties."))

(define as-activity-types

  (list as:Accept as:Add as:Announce as:Arrive as:Block as:Create as:Delete

        as:Dislike as:Flag as:Follow as:Ignore as:Invite as:Join as:Leave

        as:Like as:Listen as:Move as:Offer as:Question as:Reject as:Read

        as:Remove as:TentativeReject as:TentativeAccept as:Travel as:Undo

        as:Update as:View))

;; Actor Types

(define as:Application

  (make-as-type

    "Application"

    #:subclass-of (list as:Object)

    #:comment

    "Describes a software application."))

(define as:Group

  (make-as-type

    "Group"

    #:subclass-of (list as:Object)

    #:comment

    "Represents a formal or informal collective of Actors."))

(define as:Organisation

  (make-as-type

    "Organisation"

    #:subclass-of (list as:Object)

    #:comment

    "Represents an organization."))

(define as:Person

  (make-as-type

    "Person"

    #:subclass-of (list as:Object)

    #:comment

    "Represents an individual person."))

(define as:Service

  (make-as-type

    "Service"

    #:subclass-of (list as:Object)

    #:comment

    "Represents a service of any kind."))

(define as-actor-types

  (list as:Application as:Group as:Organisation as:Person as:Service))

;; 

(define as:Relationship

  (make-as-type

    "Relationship"

    #:subclass-of (list as:Object)

    #:comment

    "Describes a relationship between two individuals.  The subject and object

properties are used to identify the connected individuals.  See 5.2 Representing

Relationships Between Entities for additional information."))

(define as:Article

  (make-as-type

    "Article"

    #:subclass-of (list as:Object)

    #:comment

    "Represents any kind of multi-paragraph written work."))

(define as:Document

  (make-as-type

    "Document"

    #:subclass-of (list as:Object)

    #:comment

    "Represents a document of any kind."))

(define as:Audio

  (make-as-type

    "Audio"

    #:subclass-of (list as:Document)

    #:comment

    "Represents an audio document of any kind."))

(define as:Image

  (make-as-type

    "Image"

    #:subclass-of (list as:Document)

    #:comment

    "An image document of any kind."))

(define as:Video

  (make-as-type

    "Video"

    #:subclass-of (list as:Document)

    #:comment

    "Represents a video document of any kind."))

(define as:Note

  (make-as-type

    "Note"

    #:subclass-of (list as:Object)

    #:comment

    "Represents a short written work typically less than a single paragraph in

length."))

(define as:Page

  (make-as-type

    "Page"

    #:subclass-of (list as:Document)

    #:comment

    "Represents a Web Page."))

(define as:Event

  (make-as-type

    "Event"

    #:subclass-of (list as:Object)

    #:comment

    "Represents any kind of event."))

(define as:Place

  (make-as-type

    "Place"

    #:subclass-of (list as:Object)

    #:comment

    "Represents a logical or physical location.  See 5.3 Representing Places

for additional information."))

(define as:Mention

  (make-as-type

    "Mention"

    #:subclass-of (list as:Link)

    #:comment

    "A specialized Link that represents an @mention."))

(define as:Profile

  (make-as-type

    "Profile"

    #:subclass-of (list as:Object)

    #:comment

    "A Profile is a content object that describes another Object, typically

used to describe Actor Type objects.  The describes property is used to

reference the object being described by the profile"))

(define as:Tombstone

  (make-as-type

    "Tombstone"

    #:subclass-of (list as:Object)

    #:comment

    "A Tombstone represents a content object that has been deleted.  It can be

used in Collections to signify that there used to be an object at this

position, but it has been deleted."))

(define as-object-and-link-types

  (list as:Article as:Audio as:Document as:Event as:Image as:Note as:Page

        as:Place as:Profile as:Relationship as:Tombstone as:Video as:Mention))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                Properties                                 ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; procedures for type checking

(define (any l proc)

  (match l

    (() #t)

    ((p l ...)

     (or (proc p) (any l proc)))

    (#(p l ...)

     (or (proc p) (any l proc)))))

(define (forall l proc)

  (match l

    (() #t)

    ((p l ...)

     (and (proc p) (forall l proc)))

    (#(p l ...)

     (and (proc p) (forall l proc)))))

(define (string-or-lang-string? s)

  (match s

    ((("@value" . s)) (string? s))

    ((("@value" . s) ("@language" . l)) (string? s))

    ((("@language" . l) ("@value" . s)) (string? s))))

(define (uri? s)

  (if (list? s)

      (forall s uri?)

      (and (string? s) (string->uri s))))

(define (bool? s)

  (and (json-object? s)

       (json-has-key? s "@value")

       (member (assoc-ref s "@value") '(#t #f))))

;; TODO: really specify these

(define (date? s)

  (and (json-object? s)

       (json-has-key? s "@value")

       (string? (assoc-ref s "@value"))))

(define (link-relation? s)

  (and (json-object? s)

       (json-has-key? s "@value")

       (string? (assoc-ref s "@value"))))

(define (duration? s)

  (and (json-object? s)

       (json-has-key? s "@value")

       (string? (assoc-ref s "@value"))))

(define (langtag? s)

  (and (json-object? s)

       (json-has-key? s "@value")

       (string? (assoc-ref s "@value"))))

(define (mime-type? s)

  (and (json-object? s)

       (json-has-key? s "@value")

       (string? (assoc-ref s "@value"))))

(define (non-negative-integer? i)

  (and (integer? i)

       (>= i 0)))

(define (float? i)

  (number? i))

;; Properties

(define as:id

  (make-as-property

    "id" '("Object" "Link") uri?

    #:uri "@id"

    #:comment "Provides the globally unique identifier for an Object or Link."

    #:functional? #t))

(define as:type

  (make-as-property

    "type" '("Object" "Link") uri?

    #:uri "@type"

    #:comment "Identifies the Object or Link type.  Multiple values may be

specified."))

(define as:actor

  (make-as-property

    "actor" "Activity" '("Object" "Link")

    #:subproperty-of '("attributedTo")

    #:comment

    "Describes one or more entities that either performed or are expected to

perform the activity.  Any single activity can have multiple actors.  The actor

MAY be specified using an indirect Link."))

(define as:attachment

  (make-as-property

    "attachment" "Object" '("Object" "Link")

    #:comment

    "Identifies a resource attached or related to an object that potentially

requires special handling.  The intent is to provide a model that is at least

semantically similar to attachments in email."))

(define as:attributedTo

  (make-as-property

    "attributedTo" '("Link" "Object") '("Link" "Object")

    #:comment

    "Identifies one or more entities to which this object is attributed.  The

attributed entities might not be Actors.  For instance, an object might be

attributed to the completion of another activity."))

(define as:audience

  (make-as-property

    "audience" "Object" '("Object" "Link")

    #:comment

    "Identifies one or more entities that represent the total population of

entities for which the object can considered to be relevant."))

(define as:bcc

  (make-as-property

    "bcc" "Object" '("Object" "Link")

    #:comment

    "Identifies one or more Objects that are part of the private secondary

audience of this Object."))

(define as:bto

  (make-as-property

    "bto" "Object" '("Object" "Link")

    #:comment

    "Identifies an Object that is part of the private primary audience of this

Object."))

(define as:cc

  (make-as-property

    "cc" "Object" '("Object" "Link")

    #:comment

    "Identifies an Object that is part of the public secondary audience of

this Object."))

(define as:context

  (make-as-property

    "context" "Object" '("Object" "Link")

    #:comment

    "Identifies the context within which the object exists or an activity was

performed.  The notion of ``context'' used is intentionally vague.  The

intended function is to serve as a means of grouping objects and activities

that share a common originating context or purpose.  An example could be all

activities relating to a common project or event."))

(define as:current

  (make-as-property

    "current" "Collection" '("CollectionPage" "Link")

    #:functional? #t

    #:comment

    "In a paged Collection, indicates the page that contains the most recently

updated member items."))

(define as:first

  (make-as-property

    "first" "Collection" '("CollectionPage" "Link")

    #:functional? #t

    #:comment

    "In a paged Collection, indicates the furthest preceeding page of items in

the collection."))

(define as:generator

  (make-as-property

    "generator" "Object" '("Object" "Link")

    #:comment

    "Identifies the entity (e.g. an application) that generated the object."))

(define as:icon

  (make-as-property

    "icon" "Object" '("Image" "Link")

    #:comment

    "Indicates an entity that describes an icon for this object.  The image

should have an aspect ratio of one (horizontal) to one (vertical) and should

be suitable for presentation at a small size."))

(define as:image

  (make-as-property

    "image" "Object" '("Image" "Link")

    #:comment

    "Indicates an entity that describes an image for this object.  Unlike the

icon property, there are no aspect ratio or display size limitations assumed."))

(define as:inReplyTo

  (make-as-property

    "inReplyTo" "Object" '("Object" "Link")

    #:comment

    "Indicates one or more entities for which this object is considered a

response."))

(define as:instrument

  (make-as-property

    "instrument" "Activity" '("Object" "Link")

    #:comment

    "Identifies one or more objects used (or to be used) in the completion of

an Activity."))

(define as:last

  (make-as-property

    "last" "Collection" '("CollectionPage" "Link")

    #:functional? #t

    #:comment

    ""))

(define as:location

  (make-as-property

    "location" "Object" '("Object" "Link")

    #:comment

    "Indicates one or more physical or logical locations associated with the

object."))

(define as:items

  (make-as-property

    "items" "Collection" '("Object" "Link")

    #:comment

    "Identifies the items contained in a collection. The items might be ordered

or unordered."))

(define as:oneOf

  (make-as-property

    "oneOf" "Question" '("Object" "Link")

    #:comment

    "Identifies an exclusive option for a Question.  Use of oneOf implies that

the Question can have only a single answer.  To indicate that a Question can

have multiple answers, use anyOf."))

(define as:anyOf

  (make-as-property

    "oneOf" "Question" '("Object" "Link")

    #:comment

    "Identifies an inclusive option for a Question.  Use of anyOf implies that

the Question can have multiple answers.  To indicate that a Question can have

only one answer, use oneOf."))

(define as:closed

  (make-as-property

    "closed" "Question" '("Object" "Link" date? boolean?)

    #:comment

    "Indicates that a question has been closed, and answers are no longer

accepted."))

(define as:origin

  (make-as-property

    "origin" "Activity" '("Object" "Link")

    #:comment

    "Describes an indirect object of the activity from which the activity is

directed.  The precise meaning of the origin is the object of the English

preposition ``from''.  For instance, in the activity ``John moved an item to

List B from List A'', the origin of the activity is ``List A''."))

(define as:next

  (make-as-property

    "next" "CollectionPage" '("CollectionPage" "Link")

    #:functional? #t

    #:comment

    "In a paged Collection, indicates the next page of items."))

(define as:object

  (make-as-property

    "object" '("Activity" "Relationship") '("Object" "Link")

    #:comment

    "When used within an Activity, describes the direct object of the activity.

For instance, in the activity ``John added a movie to his wishlist'', the

object of the activity is the movie added.  When used within a Relationship

describes the entity to which the subject is related."))

(define as:prev

  (make-as-property

    "prev" "CollectionPage" '("CollectionPage" "Link")

    #:functional? #t

    #:comment

    "In a paged Collection, identifies the previous page of items."))

(define as:preview

  (make-as-property

    "preview" '("Object" "Link") '("Object" "Link")

    #:comment

    "Identifies an entity that provides a preview of this object."))

(define as:result

  (make-as-property

    "result" "Activity" '("Object" "Link")

    #:comment

    "Describes the result of the activity.  For instance, if a particular

action results in the creation of a new resource, the result property can be

used to describe that new resource."))

(define as:replies

  (make-as-property

    "replise" "Object" "Collection"

    #:functional? #t

    #:comment

    "Identifies a Collection containing objects considered to be responses to

this object."))

(define as:tag

  (make-as-property

    "tag" "Object" '("Object" "Link")

    #:comment

    "One or more ``tags'' that have been associated with an object.  A tag can

be any kind of Object.  The key difference between attachment and tag is that

the former implies association by inclusion, while the latter implies

associated by reference."))

(define as:target

  (make-as-property

    "target" "Activity" '("Object" "Link")

    #:comment

    "Describes the indirect object, or target, of the activity.  The precise

meaning of the target is largely dependent on the type of action being

described but will often be the object of the English preposition ``to''.  For

instance, in the activity ``John added a movie to his wishlist'', the target

of the activity is John's wishlist. An activity can have more than one target."))

(define as:to

  (make-as-property

    "to" "Object" '("Object" "Link")

    #:comment

    "Identifies an entity considered to be part of the public primary audience

of an Object."))

(define as:url

  (make-as-property

    "url" "Object" '(uri? "Link")

    #:comment

    "Identifies one or more links to representations of the object."))

(define as:accuracy

  (make-as-property

    "accuracy" "Place" float?

    #:comment

    "Indicates the accuracy of position coordinates on a Place objects.

Expressed in properties of percentage.  e.g. ``94.0'' means ``94.0% accurate''."))

(define as:altitude

  (make-as-property

    "altitude" "Object" float?

    #:functional? #t

    #:comment

    "Indicates the altitude of a place.  The measurement units is indicated

using the units property.  If units is not specified, the default is assumed

to be ``m'' indicating meters."))

(define as:content

  (make-as-property

    "content" "Object" string-or-lang-string?

    #:comment

    "The content or textual representation of the Object encoded as a JSON

string.  By default, the value of content is HTML.  The mediaType property can

be used in the object to indicate a different content type.  The content MAY

be expressed using multiple language-tagged values."))

(define as:name

  (make-as-property

    "name" '("Object" "Link") string-or-lang-string?

    #:comment

    "A simple, human-readable, plain-text name for the object.  HTML markup

MUST NOT be included.  The name MAY be expressed using multiple language-tagged

values."))

(define as:duration

  (make-as-property

    "duration" "Object" duration?

    #:functional? #t

    #:comment

    "When the object describes a time-bound resource, such as an audio or video,

a meeting, etc, the duration property indicates the object's approximate

duration.  The value MUST be expressed as an xsd:duration as defined by

[xmlschema11-2], section 3.3.6 (e.g. a period of 5 seconds is represented as

``PT5S'')."))

(define as:height

  (make-as-property

    "height" "Link" non-negative-integer?

    #:functional? #t

    #:comment

    "On a Link, specifies a hint as to the rendering height in device-independent

pixels of the linked resource."))

(define as:href

  (make-as-property

    "href" "Link" uri?

    #:functional? #t

    #:comment

    "The target resource pointed to by a Link."))

(define as:hreflang

  (make-as-property

    "hreflang" "Link" langtag?

    #:functional? #t

    #:comment

    "Hints as to the language used by the target resource.  Value MUST be a

[BCP47] Language-Tag."))

(define as:partOf

  (make-as-property

    "partOf" "CollectionPage" '("Collection" "Link")

    #:functional? #t

    #:comment

    "Identifies the Collection to which a CollectionPage objects items belong."))

(define as:latitude

  (make-as-property

    "latitude" "Place" float?

    #:functional? #t

    #:comment

    "The latitude of a place."))

(define as:longitude

  (make-as-property

    "longitude" "Place" float?

    #:functional? #t

    #:comment

    "The longitude of a place."))

(define as:mediaType

  (make-as-property

    "mediaType" '("Link" "Object") mime-type?

    #:functional? #t

    #:comment

    "When used on a Link, identifies the MIME media type of the referenced

resource.  When used on an Object, identifies the MIME media type of the value

of the content property.  If not specified, the content property is assumed to

contain text/html content."))

(define as:endTime

  (make-as-property

    "endTime" "Object" date?

    #:functional? #t

    #:comment

    "The date and time describing the actual or expected ending time of the