refactor: tidy structure of source files

Fixes #79

src/things/abstract/academic-degree.ts

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../../general/i18n';
+import {SCThing, SCThingMeta, SCThingWithoutReferences} from './thing';
+
+/**
+ * An academic degree without references
+ */
+export interface SCAcademicDegreeWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * The achievable academic degree
+   */
+  academicDegree: SCGermanAcademicDegree;
+
+  /**
+   * The achievable academic degree with academic field specification
+   * (eg. Master of Science)
+   *
+   * @keyword
+   */
+  academicDegreewithField: string;
+
+  /**
+   * The achievable academic degree with academic field specification
+   * shorted (eg. M.Sc.).
+   *
+   * @keyword
+   */
+  academicDegreewithFieldShort: string;
+}
+
+/**
+ * An academic degree
+ */
+export interface SCAcademicDegree
+  extends SCAcademicDegreeWithoutReferences, SCThing {
+  // noop
+}
+
+/**
+ * Meta information about academic degrees
+ */
+export class SCAcademicDegreeMeta
+  extends SCThingMeta implements SCMetaTranslations<SCAcademicDegree> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      academicDegree: 'Hochschulgrad',
+      academicDegreewithField: 'Abschlussbezeichnungen',
+      academicDegreewithFieldShort: 'Abschlussbezeichnungen (kurz)',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      academicDegree: 'academic degree',
+      academicDegreewithField: 'acedemic degree and discipline',
+      academicDegreewithFieldShort: 'acedemic degree and discipline (short)',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+      academicDegree: {
+        'bachelor': 'Bachelor',
+        'diploma': 'Diplom',
+        'doctor': 'Doktor',
+        'licentiate': 'Lizenziat',
+        'magister': 'Magister',
+        'master': 'Master',
+        'masterstudent': 'Meisterschüler',
+        'state examination': 'Staatsexamen',
+      },
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+}
+
+/**
+ * Types of (german) academic degrees
+ */
+export type SCGermanAcademicDegree =
+  'bachelor'
+  | 'diploma'
+  | 'doctor'
+  | 'licentiate'
+  | 'magister'
+  | 'master'
+  | 'master pupil'
+  | 'state examination' ;

src/things/abstract/academic-term.ts

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../../general/i18n';
+import {SCISO8601Date} from '../../general/time';
+import {SCThing, SCThingMeta, SCThingWithoutReferences} from './thing';
+
+/**
+ * An academic term without references
+ */
+export interface SCAcademicTermWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Short name of the academic term, using the given pattern
+   *
+   * @aggregatable
+   * @keyword
+   */
+  acronym: string;
+
+  /**
+   * End date of the academic term
+   */
+  endDate: SCISO8601Date;
+
+  /**
+   * End date of lectures in the academic term
+   */
+  eventsEndDate?: SCISO8601Date;
+
+  /**
+   * Start date of lectures in the academic term
+   */
+  eventsStartDate?: SCISO8601Date;
+
+  /**
+   * Start date of the academic term
+   */
+  startDate: SCISO8601Date;
+}
+
+/**
+ * An academic term
+ */
+export interface SCAcademicTerm
+  extends SCAcademicTermWithoutReferences, SCThing {
+  // noop
+}
+
+/**
+ * Meta information about academic terms
+ */
+export class SCAcademicTermWithoutReferencesMeta
+  extends SCThingMeta implements SCMetaTranslations<SCThing> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      acronym: 'Akronym',
+      endDate: 'Enddatum',
+      eventsEndDate: 'Enddatum der Veranstaltungen',
+      eventsStartDate: 'Startdatum der Veranstaltungen',
+      startDate: 'Startdatum',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      acronym: 'acronym',
+      endDate: 'end date',
+      eventsEndDate: 'end date of events',
+      eventsStartDate: 'start date of events',
+      startDate: 'start date',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+}

src/things/abstract/creative-work.ts

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCLanguage, SCMetaTranslations, SCTranslations} from '../../general/i18n';
+import {SCISO8601Date} from '../../general/time';
+import {SCOrganizationWithoutReferences} from '../organization';
+import {SCPersonWithoutReferences} from '../person';
+import {SCThingMeta, SCThingTranslatableProperties, SCThingWithoutReferences} from './thing';
+import {
+  SCAcademicPriceGroup,
+  SCThingThatCanBeOffered,
+  SCThingThatCanBeOfferedMeta,
+  SCThingThatCanBeOfferedTranslatableProperties,
+  SCThingThatCanBeOfferedWithoutReferences,
+} from './thing-that-can-be-offered';
+
+/**
+ * A creative work without references
+ */
+export interface SCCreativeWorkWithoutReferences
+  extends SCThingWithoutReferences, SCThingThatCanBeOfferedWithoutReferences {
+  /**
+   * Date the creative work was published
+   */
+  datePublished?: SCISO8601Date;
+
+  /**
+   * List of languages this creative work is written/recorded/... in
+   */
+  inLanguages?: SCLanguage[];
+
+  /**
+   * Keywords of the creative work
+   *
+   * @aggregatable
+   * @keyword
+   */
+  keywords?: string[];
+
+  /**
+   * Translated fields of the creative work
+   */
+  translations?: SCTranslations<SCCreativeWorkTranslatableProperties>;
+}
+
+/**
+ * A creative work
+ */
+export interface SCCreativeWork
+  extends SCCreativeWorkWithoutReferences, SCThingThatCanBeOffered<SCAcademicPriceGroup> {
+  /**
+   * Authors of the creative work
+   */
+  authors?: SCPersonWithoutReferences[];
+
+  /**
+   * List of publishers of the creative work
+   */
+  publishers?: Array<SCPersonWithoutReferences | SCOrganizationWithoutReferences>;
+
+  /**
+   * Translated fields of the creative work
+   */
+  translations?: SCTranslations<SCCreativeWorkTranslatableProperties>;
+}
+
+/**
+ * Translatable properties of creative works
+ */
+export interface SCCreativeWorkTranslatableProperties
+  extends SCThingTranslatableProperties, SCThingThatCanBeOfferedTranslatableProperties {
+  /**
+   * Translation of the keywords of the creative work
+   *
+   * @keyword
+   */
+  keywords?: string[];
+}
+
+/**
+ * Meta information about creative works
+ */
+export class SCCreativeWorkMeta
+  extends SCThingMeta implements SCMetaTranslations<SCCreativeWork> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance().fieldTranslations.de,
+      authors: 'Authoren',
+      datePublished: 'Veröffentlichungsdatum',
+      inLanguages: 'verfügbare Übersetzungen',
+      keywords: 'Schlagwörter',
+      publishers: 'Verleger',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance().fieldTranslations.en,
+      authors: 'authors',
+      datePublished: 'release date',
+      inLanguages: 'available Languages',
+      keywords: 'keywords',
+      publishers: 'publishers',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance().fieldValueTranslations.en,
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance().fieldValueTranslations.en,
+    },
+  };
+}

src/things/abstract/event.ts

@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../../general/i18n';
+import {SCCatalogWithoutReferences} from '../catalog';
+import {SCPersonWithoutReferences} from '../person';
+import {SCSemesterWithoutReferences} from '../semester';
+import {SCCreativeWorkWithoutReferences} from './creative-work';
+import {SCThing, SCThingMeta, SCThingWithoutReferences} from './thing';
+
+/**
+ * An event without references
+ */
+export interface SCEventWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Maximum number of participants of the event
+   *
+   * A maximum number of people that can participate in the event.
+   *
+   * @integer
+   */
+  maximumParticipants?: number;
+
+  /**
+   * Remaining attendee capacity of the event
+   *
+   * This number represents the remaining open spots.
+   *
+   * @integer
+   */
+  remainingAttendeeCapacity?: number;
+}
+
+/**
+ * An event
+ */
+export interface SCEvent
+  extends SCEventWithoutReferences, SCThing {
+  /**
+   * Academic terms that an event belongs to, e.g. semester(s).
+   */
+  academicTerms?: SCSemesterWithoutReferences[];
+
+  /**
+   * Catalogs to which an event belongs
+   */
+  catalogs?: SCCatalogWithoutReferences[];
+
+  /**
+   * A list of creative works that are associated with this event
+   *
+   * This can be recommended books, CDs that can be bought, etc.
+   */
+  creativeWorks?: SCCreativeWorkWithoutReferences[];
+
+  /**
+   * Organizers of the event
+   */
+  organizers?: SCPersonWithoutReferences[];
+
+  /**
+   * Performers of the event
+   */
+  performers?: SCPersonWithoutReferences[];
+}
+
+/**
+ * Meta information about events
+ */
+export class SCEventMeta
+  extends SCThingMeta implements SCMetaTranslations<SCEvent> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      academicTerms: 'Semester',
+      catalogs: 'Verzeichnis',
+      creativeWorks: 'begleitende Werke',
+      maximumParticipants: 'maximale Anzahl an Teilnehmern',
+      organizers: 'Origanisatoren',
+      performers: 'Vortragende',
+      remainingAttendeeCapacity: 'verfügbare Anzahl an Teilnehmern',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      academicTerms: 'academic terms',
+      catalogs: 'catalogs',
+      creativeWorks: 'related material',
+      maximumParticipants: 'maximum participants',
+      organizers: 'organizers',
+      performers: 'performers',
+      remainingAttendeeCapacity: 'remaining attendee capacity',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+}

src/things/abstract/place.ts

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+// tslint:disable-next-line:no-implicit-dependencies
+import {Point, Polygon} from 'geojson';
+import {SCMetaTranslations, SCTranslations} from '../../general/i18n';
+import {SCBuildingWithoutReferences} from '../building';
+import {SCPointOfInterestWithoutReferences} from '../point-of-interest';
+import {SCRoomWithoutReferences} from '../room';
+import {SCThing, SCThingMeta, SCThingTranslatableProperties, SCThingWithoutReferences} from './thing';
+
+/**
+ * Positional information
+ */
+export interface SCGeoInformation {
+  /**
+   * Center point of a place
+   */
+  point: Point;
+  /**
+   * Shape of a place
+   */
+  polygon?: Polygon;
+}
+
+/**
+ * A postal address
+ */
+export interface SCPostalAddress {
+  /**
+   * Country of the address
+   */
+  addressCountry: string;
+
+  /**
+   * City of the address
+   */
+  addressLocality: string;
+
+  /**
+   * State of the address
+   */
+  addressRegion?: string;
+
+  /**
+   * Zip code of the address
+   */
+  postalCode: string;
+
+  /**
+   * Optional post box number
+   */
+  postOfficeBoxNumber?: string;
+
+  /**
+   * Street of the address - with house number!
+   */
+  streetAddress: string;
+}
+
+/**
+ * A place without references
+ */
+export interface SCPlaceWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Address of the place
+   */
+  address?: SCPostalAddress;
+
+  /**
+   * Positional information of the place
+   *
+   * !!! BEWARE !!!
+   * Can not be a GeometryCollection because ElasticSearch does not allow distance filtering/sorting on other types
+   */
+  geo: SCGeoInformation;
+
+  /**
+   * Opening hours of the place
+   *
+   * @see http://wiki.openstreetmap.org/wiki/Key:opening_hours/specification
+   * @keyword
+   */
+  openingHours?: string;
+
+  /**
+   * Translated fields of a place
+   */
+  translations?: SCTranslations<SCPlaceWithoutReferencesTranslatableProperties>;
+}
+
+/**
+ * A place
+ */
+export interface SCPlace
+  extends SCPlaceWithoutReferences, SCThing {
+  /**
+   * Translated fields of a place
+   */
+  translations?: SCTranslations<SCPlaceWithoutReferencesTranslatableProperties>;
+}
+
+/**
+ * Translatable properties of a place without references
+ */
+export interface SCPlaceWithoutReferencesTranslatableProperties
+  extends SCThingTranslatableProperties {
+  /**
+   * Address of a place
+   */
+  address?: SCPostalAddress;
+}
+
+/**
+ * Meta information about creative works
+ */
+export class SCPlaceWithoutReferencesMeta
+  extends SCThingMeta implements SCMetaTranslations<SCPlaceWithoutReferences> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      address: 'Adresse',
+      geo: 'Geoinformation',
+      openingHours: 'Öffnungszeiten',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      address: 'address',
+      geo: 'geographic information',
+      openingHours: 'opening hours',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+}
+
+/**
+ * Something that is or happens in a place
+ *
+ * !Important!
+ * This is not a SCThing.
+ */
+export interface SCInPlace {
+  /**
+   * Place the thing is or happens in
+   */
+  inPlace?:
+    SCBuildingWithoutReferences
+    | SCPointOfInterestWithoutReferences
+    | SCRoomWithoutReferences;
+}

src/things/abstract/saveable-thing.ts

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCThing, SCThingUserOrigin, SCThingWithoutReferences} from './thing';
+
+/**
+ * An encapsulation of the data (e.g. a thing) that is saved, which provides additional information.
+ */
+export interface SCSaveableThingWithoutReferences
+  extends SCThingWithoutReferences {
+  // noop
+}
+
+/**
+ * An encapsulation of the data (e.g. a thing) that is saved, which provides additional information.
+ */
+export interface SCSaveableThing<T extends SCThingWithoutReferences>
+  extends SCSaveableThingWithoutReferences, SCThing {
+  /**
+   * The contained data
+   */
+  data: T;
+  /**
+   * Type of the origin
+   */
+  origin: SCThingUserOrigin;
+}

src/things/abstract/thing-in-place.ts

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../../general/i18n';
+import {SCInPlace} from './place';
+import {SCThing, SCThingMeta} from './thing';
+
+/**
+ * A thing that is or happens in a place
+ */
+export interface SCThingInPlace
+  extends SCThing, SCInPlace {
+  // noop
+}
+
+/**
+ * Meta information about thing in a place
+ */
+export class SCThingInPlaceMeta
+  extends SCThingMeta implements SCMetaTranslations<SCThingInPlace> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      inPlace: 'Ort',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      inPlace: 'location',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+}

src/things/abstract/thing-that-accepts-payments.ts

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../../general/i18n';
+import {SCThing, SCThingMeta, SCThingWithoutReferences} from './thing';
+
+/**
+ * Types of payment that are accepted at a place.
+ */
+export type SCThingThatAcceptsPaymentsAcceptedPayments =
+  'cash'
+  | 'credit'
+  | 'cafeteria card';
+
+/**
+ * A thing without references that accepts payments
+ */
+export interface SCThingThatAcceptsPaymentsWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Accepted payments of the place
+   */
+  paymentsAccepted?: SCThingThatAcceptsPaymentsAcceptedPayments[];
+}
+
+/**
+ * A thing that accepts payments
+ */
+export interface SCThingThatAcceptsPayments
+  extends SCThingThatAcceptsPaymentsWithoutReferences, SCThing {
+  // noop
+}
+
+/**
+ * Meta information about a thing without references that accepts payments
+ */
+export class SCThingThatAcceptsPaymentsWithoutReferencesMeta
+  extends SCThingMeta implements SCMetaTranslations<SCThingThatAcceptsPaymentsWithoutReferences> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      paymentsAccepted: 'Bezahlmethoden',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      paymentsAccepted: 'accepted payment methods',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+      paymentsAccepted: {
+        'cafeteria card': 'Mensakarte',
+        'cash': 'Bar',
+        'credit': 'Kreditkarte',
+      },
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+}

src/things/abstract/thing-that-can-be-offered.ts

@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../../general/i18n';
+import {SCISO8601Date} from '../../general/time';
+import {SCOrganizationWithoutReferences} from '../organization';
+import {SCPersonWithoutReferences} from '../person';
+import {SCInPlace} from './place';
+import {SCThing, SCThingMeta, SCThingTranslatableProperties, SCThingWithoutReferences} from './thing';
+
+/**
+ * Default price without distinction
+ */
+export interface SCPriceGroup {
+  /**
+   * Default price of the thing
+   *
+   * @sortable price
+   * @float
+   */
+  default: number;
+}
+
+/**
+ * Price distinctions for academic context
+ */
+export interface SCAcademicPriceGroup
+  extends SCPriceGroup {
+  /**
+   * Price for employees
+   *
+   * @sortable price
+   * @float
+   */
+  employee?: number;
+
+  /**
+   * Price for guests
+   *
+   * @sortable price
+   * @float
+   */
+  guest?: number;
+
+  /**
+   * Price for students
+   *
+   * @sortable price
+   * @float
+   */
+  student?: number;
+}
+
+/**
+ * A thing without references that can be offered
+ */
+export interface SCThingThatCanBeOfferedWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Translations of a thing that can be offered
+   */
+  translations?: SCTranslations<SCThingThatCanBeOfferedTranslatableProperties>;
+}
+
+/**
+ * A thing that can be offered
+ */
+export interface SCThingThatCanBeOffered<T extends SCPriceGroup>
+  extends SCThing, SCThingThatCanBeOfferedWithoutReferences {
+  /**
+   * List of offers for that thing
+   */
+  offers?: Array<SCThingThatCanBeOfferedOffer<T>>;
+
+  /**
+   * Translations of a thing that can be offered
+   */
+  translations?: SCTranslations<SCThingThatCanBeOfferedTranslatableProperties>;
+}
+
+/**
+ * Offer of a thing
+ */
+export interface SCThingThatCanBeOfferedOffer<T extends SCPriceGroup>
+  extends SCInPlace {
+  /**
+   * Availability of an offer
+   */
+  availability: SCThingThatCanBeOfferedAvailability;
+
+  /**
+   * The time when the thing becomes unavailable as an SCISO8601Date formatted string.
+   */
+  availabilityEnds?: SCISO8601Date;
+
+  /**
+   * The time when the thing becomes available as an SCISO8601Date formatted string.
+   */
+  availabilityStarts?: SCISO8601Date;
+
+  /**
+   * List of prices that are distinct for specific groups
+   */
+  prices: T;
+
+  /**
+   * Provider of an offer
+   */
+  provider: SCThingThatCanBeOfferedProvider;
+}
+
+/**
+ * Translatable properties of a thing that can be offered
+ */
+export interface SCThingThatCanBeOfferedTranslatableProperties
+  extends SCThingTranslatableProperties {
+  /**
+   * Availability of an offer
+   *
+   * @keyword
+   */
+  'offers[].availability'?: string;
+}
+
+/**
+ * Entity responsible for the offer
+ */
+export type SCThingThatCanBeOfferedProvider =
+  | SCOrganizationWithoutReferences
+  | SCPersonWithoutReferences;
+
+/**
+ * Availability of an Offer
+ */
+export type SCThingThatCanBeOfferedAvailability =
+  | 'in stock'
+  | 'out of stock'
+  | 'online only'
+  | 'limited availability';
+
+/**
+ * Meta information about a thing without references that accepts payments
+ */
+export class SCThingThatCanBeOfferedMeta<T extends SCPriceGroup>
+  implements SCMetaTranslations<SCThingThatCanBeOffered<T>> {
+
+  /**
+   * Instance
+   */
+  protected static _instance = new Map<string, unknown>();
+
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance().fieldTranslations.de,
+      offers: 'Angebote',
+    },
+    en: {
+      ...SCThingMeta.getInstance().fieldTranslations.en,
+      offers: 'offers',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+
+  // tslint:disable:static-this
+  /**
+   * Function to retrieve typed singleton instance (including generics)
+   */
+  public static getInstance<T extends SCPriceGroup>(): SCThingThatCanBeOfferedMeta<T> {
+    if (!SCThingThatCanBeOfferedMeta._instance.has(this.name)) {
+      SCThingThatCanBeOfferedMeta._instance.set(this.name, new SCThingThatCanBeOfferedMeta<T>());
+    }
+
+    return SCThingThatCanBeOfferedMeta._instance
+      .get(this.name) as SCThingThatCanBeOfferedMeta<T>;
+  }
+
+  protected constructor() {
+  }
+}

src/things/abstract/thing-with-categories.ts

@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../../general/i18n';
+import {SCMap} from '../../general/map';
+import {SCThing, SCThingMeta, SCThingTranslatableProperties, SCThingWithoutReferences} from './thing';
+
+/**
+ * A thing without references with categories
+ *
+ * !!! BEWARE !!!
+ * `T` should be a string literal union type - e.g. `T = 'foo' | 'bar' | 'foobar';`
+ */
+export interface SCThingWithCategoriesWithoutReferences<T, U extends SCThingWithCategoriesSpecificValues>
+  extends SCThingWithoutReferences {
+  /**
+   * Categories of a thing with categories
+   *
+   * @sortable ducet
+   * @aggregatable
+   */
+  categories: T[];
+
+  /**
+   * Use this to explicitly override general opening hours brought in scope by openingHoursSpecification or openingHours
+   *
+   * A map from categories to their specific values.
+   */
+  categorySpecificValues?: SCMap<U>;
+
+  /**
+   * Translated fields of a thing with categories
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+}
+
+/**
+ * A thing with categories
+ */
+export interface SCThingWithCategories<T, U extends SCThingWithCategoriesSpecificValues>
+  extends SCThing, SCThingWithCategoriesWithoutReferences<T, U> {
+  /**
+   * Translated fields of a thing with categories
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+}
+
+/**
+ * Translatable properties of a thing with categories
+ */
+export interface SCThingWithCategoriesTranslatableProperties
+  extends SCThingTranslatableProperties {
+  /**
+   * translations of the categories of a thing with categories
+   */
+  categories?: string[];
+}
+
+/**
+ * Category specific values of a thing with categories
+ *
+ * This interface contains properties that can be specific to a certain category.
+ */
+export interface SCThingWithCategoriesSpecificValues {
+  /**
+   * Category specific alternate names of a thing
+   *
+   * @keyword
+   */
+  alternateNames?: string[];
+
+  /**
+   * Category specific description of a thing
+   *
+   * @text
+   */
+  description?: string;
+
+  /**
+   * URL of a category specific image of a thing
+   *
+   * @keyword
+   */
+  image?: string;
+
+  /**
+   * Category specific name of a thing
+   *
+   * @text
+   */
+  name?: string;
+
+  /**
+   * Category specific URL of a thing
+   *
+   * @keyword
+   */
+  url?: string;
+}
+
+/**
+ * Meta information about a thing without references that accepts payments
+ * It intentionally does not extend the SCThingMeta implementation to be able to include generics.
+ */
+export class SCThingWithCategoriesWithoutReferencesMeta<T, U>
+  implements SCMetaTranslations<SCThingWithCategoriesWithoutReferences<T, U>> {
+
+  /**
+   * Instance
+   */
+  protected static _instance = new Map<string, unknown>();
+
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      categories: 'Kategorien',
+      categorySpecificValues: 'besondere Kategorien',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      categories: 'categories',
+      categorySpecificValues: 'category with specific values',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+    },
+  };
+
+  // tslint:disable:static-this
+  /**
+   * Function to retrieve typed singleton instance (including generics)
+   */
+  public static getInstance<T, U>(): SCThingWithCategoriesWithoutReferencesMeta<T, U> {
+    if (!SCThingWithCategoriesWithoutReferencesMeta._instance.has(this.name)) {
+      SCThingWithCategoriesWithoutReferencesMeta._instance
+        .set(this.name, new SCThingWithCategoriesWithoutReferencesMeta<T, U>());
+    }
+
+    return SCThingWithCategoriesWithoutReferencesMeta._instance
+      .get(this.name) as SCThingWithCategoriesWithoutReferencesMeta<T, U>;
+  }
+
+  protected constructor() {
+  }
+}

src/things/abstract/thing.ts

@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../../general/i18n';
+import {SCISO8601Date} from '../../general/time';
+import {SCUuid} from '../../general/uuid';
+import {SCOrganizationWithoutReferences} from '../organization';
+import {SCPersonWithoutReferences} from '../person';
+
+/**
+ * Types a thing can be
+ */
+export enum SCThingType {
+  AcademicEvent = 'academic event',
+  Article = 'article',
+  Book = 'book',
+  Building = 'building',
+  Catalog = 'catalog',
+  CourseOfStudies = 'course of studies',
+  DateSeries = 'date series',
+  Diff = 'diff',
+  Dish = 'dish',
+  Favorite = 'favorite',
+  Floor = 'floor',
+  Message = 'message',
+  Organization = 'organization',
+  Person = 'person',
+  PointOfInterest = 'point of interest',
+  Room = 'room',
+  Semester = 'semester',
+  Setting = 'setting',
+  SportCourse = 'sport course',
+  StudyModule = 'study module',
+  Ticket = 'ticket',
+  ToDo = 'todo',
+  Tour = 'tour',
+  Video = 'video',
+}
+
+/**
+ * A thing without references
+ */
+export interface SCThingWithoutReferences {
+  /**
+   * Alternate names of the thing
+   *
+   * @keyword
+   */
+  alternateNames?: string[];
+  /**
+   * Description of the thing
+   *
+   * @minLength 1
+   * @text
+   */
+  description?: string;
+  /**
+   * URL of an image of the thing
+   *
+   * @keyword
+   */
+  image?: string;
+  /**
+   * Name of the thing
+   *
+   * @minLength 1
+   * @sortable ducet
+   * @text
+   */
+  name: string;
+  /**
+   * Translations of specific values of the object
+   *
+   * Take precedence over "main" value for selected languages.
+   */
+  translations?: SCTranslations<SCThingTranslatableProperties>;
+  /**
+   * Type of the thing
+   *
+   * @sortable ducet
+   * @aggregatable
+   */
+  type: SCThingType;
+  /**
+   * Universally unique identifier of the thing
+   */
+  uid: SCUuid;
+  /**
+   * URL of the thing
+   */
+  url?: string;
+}
+
+/**
+ * A thing
+ */
+export interface SCThing extends SCThingWithoutReferences {
+  /**
+   * Origin of the thing
+   */
+  origin: SCThingRemoteOrigin | SCThingUserOrigin;
+}
+
+/**
+ * Possible types of an origin
+ */
+export enum SCThingOriginType {
+  Remote = 'remote',
+  User = 'user',
+}
+
+/**
+ * Origin of a thing
+ */
+export interface SCThingOrigin {
+  /**
+   * Maintainer of the origin
+   *
+   * e.g. restaurant of a dish
+   */
+  maintainer?: SCPersonWithoutReferences | SCOrganizationWithoutReferences;
+
+  /**
+   * When the thing was modified last in the origin
+   */
+  modified?: SCISO8601Date;
+
+  /**
+   * Type of the origin
+   */
+  type: SCThingOriginType;
+}
+
+/**
+ * Remote origin of a thing
+ */
+export interface SCThingRemoteOrigin extends SCThingOrigin {
+  /**
+   * When the thing was indexed last from the origin
+   */
+  indexed: SCISO8601Date;
+
+  /**
+   * Name of the origin
+   *
+   * @text
+   */
+  name: string;
+
+  /**
+   * Original ID of the thing in the origin
+   */
+  originalId?: string;
+
+  /**
+   * Entity that is responsible for the entity
+   *
+   * e.g. an organizer for an event
+   */
+  responsibleEntity?: SCPersonWithoutReferences | SCOrganizationWithoutReferences;
+
+  /**
+   * Type of the origin
+   */
+  type: SCThingOriginType.Remote;
+
+  /**
+   * Main URL of the origin
+   */
+  url?: string;
+}
+
+/**
+ * User origin of a thing (data created through user interaction)
+ */
+export interface SCThingUserOrigin extends SCThingOrigin {
+  /**
+   * When the thing was created
+   */
+  created: SCISO8601Date;
+
+  /**
+   * If it is deleted or not, defaults to false
+   */
+  deleted?: boolean;
+
+  /**
+   * Type of the origin
+   */
+  type: SCThingOriginType.User;
+
+  /**
+   * When the saved thing was last updated with the latest state (e.g. from the backend)
+   */
+  updated?: SCISO8601Date;
+}
+
+/**
+ * Translatable properties of things
+ */
+export interface SCThingTranslatableProperties {
+  /**
+   * Translation of the description of the thing
+   *
+   * @text
+   */
+  description?: string;
+  /**
+   * Translation of the name of the thing
+   *
+   * @text
+   */
+  name?: string;
+  /**
+   * Origin of the thing
+   */
+  origin?: SCThingTranslatablePropertyOrigin;
+}
+
+/**
+ * Translatable property of an origin
+ */
+export interface SCThingTranslatablePropertyOrigin {
+  /**
+   * Translation of the name of the origin
+   *
+   * @text
+   */
+  name: string;
+}
+
+/**
+ * Meta information about things
+ */
+export class SCThingMeta implements SCMetaTranslations<SCThing> {
+  /**
+   * Set type definiton for singleton instance
+   */
+  protected static _instance = new Map<string, unknown>();
+
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      alternateNames: 'alternative Namen',
+      description: 'Beschreibung',
+      image: 'Bild',
+      name: 'Name',
+      origin: 'Ursprung',
+      translations: 'Übersetzungen',
+      type: 'Typ',
+      uid: 'Identifikation',
+      url: 'URL',
+    },
+    en: {
+      alternateNames: 'alternate names',
+      description: 'description',
+      image: 'image',
+      name: 'name',
+      origin: 'origin',
+      translations: 'translations',
+      type: 'type',
+      uid: 'identification',
+      url: 'URL',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      type: 'Ding',
+    },
+    en: {
+      type: 'Thing',
+    },
+  };
+
+  // tslint:disable:static-this
+  /**
+   * Function to retrieve typed singleton instance
+   */
+  public static getInstance<T extends SCThingMeta>(): T {
+    if (!SCThingMeta._instance.has(this.name)) {
+      SCThingMeta._instance.set(this.name, new this());
+    }
+
+    return SCThingMeta._instance.get(this.name) as T;
+  }
+
+  protected constructor() {
+  }
+}

src/things/academic-event.ts

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCEvent, SCEventMeta, SCEventWithoutReferences} from './abstract/event';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * An academic event without references
+ */
+export interface SCAcademicEventWithoutReferences
+  extends SCEventWithoutReferences,
+    SCThingWithCategoriesWithoutReferences<SCAcademicEventCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Majors of the academic event that this event belongs to
+   *
+   * @aggregatable
+   * @keyword
+   */
+  majors?: string[];
+
+  /**
+   * Original unmapped category from the source of the academic event
+   *
+   * @keyword
+   */
+  originalCategory?: string;
+
+  /**
+   * Translated fields of an academic event
+   */
+  translations?: SCTranslations<SCAcademicEventTranslatableProperties>;
+
+  /**
+   * Type of an academic event
+   */
+  type: SCThingType.AcademicEvent;
+}
+
+/**
+ * An academic event
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCAcademicEvent
+  extends SCEvent, SCAcademicEventWithoutReferences,
+    SCThingWithCategories<SCAcademicEventCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Translated fields of an academic event
+   */
+  translations?: SCTranslations<SCAcademicEventTranslatableProperties>;
+
+  /**
+   * Type of an academic event
+   */
+  type: SCThingType.AcademicEvent;
+}
+
+/**
+ * Categories of academic events
+ */
+export type SCAcademicEventCategories =
+  'lecture'
+  | 'seminar'
+  | 'integrated course'
+  | 'written exam'
+  | 'oral exam'
+  | 'tutorial'
+  | 'project'
+  | 'colloquium'
+  | 'practicum'
+  | 'introductory class'
+  | 'course'
+  | 'practicum introduction'
+  | 'excursion'
+  | 'special';
+
+/**
+ * Translatable properties of an academic event
+ */
+export interface SCAcademicEventTranslatableProperties
+  extends SCThingWithCategoriesTranslatableProperties {
+  /**
+   * Translations of the majors of the academic event that this event belongs to
+   *
+   * @keyword
+   */
+  majors?: string[];
+
+  /**
+   * Translation of the original unmapped category from the source of the academic event
+   *
+   * @keyword
+   */
+  originalCategory?: string;
+}
+
+/**
+ * Meta information about academic events
+ */
+export class SCAcademicEventMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCAcademicEvent> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldTranslations.de,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCAcademicEventCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      majors: 'Hauptfächer',
+      originalCategory: 'ursprüngliche Kategorie',
+    },
+    en: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldTranslations.en,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCAcademicEventCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      majors: 'majors',
+      originalCategory: 'original category',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldValueTranslations.de,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCAcademicEventCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      categories: {
+        'colloquium': 'Kolloquium',
+        'course': 'Kurs',
+        'excursion': 'Exkursion',
+        'integrated course': '',
+        'introductory class': 'Einführungsveranstaltung',
+        'lecture': 'Vorlesung',
+        'oral exam': 'mündliche Prüfung',
+        'practicum': 'Praktikum',
+        'practicum introduction': 'Einführungspraktikum',
+        'project': 'Projekt',
+        'seminar': 'Seminar',
+        'special': 'Sonderveranstalltung',
+        'tutorial': 'Tutorium',
+        'written exam': 'Schriftilche Prüfung',
+      },
+      type: 'akademische Veranstaltung',
+    },
+    en: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldValueTranslations.en,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCAcademicEventCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      type: SCThingType.AcademicEvent,
+    },
+  };
+}

src/things/article.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {
+  SCCreativeWork,
+  SCCreativeWorkMeta,
+  SCCreativeWorkTranslatableProperties,
+  SCCreativeWorkWithoutReferences,
+} from './abstract/creative-work';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * An article without references
+ */
+export interface SCArticleWithoutReferences
+  extends SCCreativeWorkWithoutReferences,
+    SCThingWithCategoriesWithoutReferences<SCArticleCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Article itself as markdown
+   *
+   * @text
+   */
+  articleBody: string;
+
+  /**
+   * Translated fields of an article
+   */
+  translations?: SCTranslations<SCArticleTranslatableProperties>;
+
+  /**
+   * Type of an article
+   */
+  type: SCThingType.Article;
+}
+
+/**
+ * An article
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCArticle
+  extends SCCreativeWork, SCArticleWithoutReferences,
+    SCThingWithCategories<SCArticleCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Translated fields of an article
+   */
+  translations?: SCTranslations<SCArticleTranslatableProperties>;
+
+  /**
+   * Type of an article
+   */
+  type: SCThingType.Article;
+}
+
+/**
+ * Categories of articles
+ */
+export type SCArticleCategories = 'unipedia';
+
+/**
+ * Translatable properties of creative works
+ */
+export interface SCArticleTranslatableProperties
+  extends SCThingWithCategoriesTranslatableProperties, SCCreativeWorkTranslatableProperties {
+  /**
+   * Translation of the article itself as markdown
+   *
+   * @text
+   */
+  articleBody?: string[];
+}
+
+/**
+ * Meta information about an article
+ */
+export class SCArticleMeta
+  extends SCThingMeta implements SCMetaTranslations<SCArticle> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .de,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCArticleCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      articleBody: 'Artikelinhalt',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .en,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCArticleCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      articleBody: 'article body',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.de,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCArticleCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      categories: {
+        'unipedia': 'Unipedia',
+      },
+      type: 'Artikel',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.en,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCArticleCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      type: SCThingType.Article,
+    },
+  };
+}

src/things/book.ts

@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {
+  SCCreativeWork,
+  SCCreativeWorkMeta,
+  SCCreativeWorkTranslatableProperties,
+  SCCreativeWorkWithoutReferences,
+} from './abstract/creative-work';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {SCThingWithCategoriesTranslatableProperties} from './abstract/thing-with-categories';
+import {SCPersonWithoutReferences} from './person';
+
+/**
+ * A book without references
+ */
+export interface SCBookWithoutReferences
+  extends SCCreativeWorkWithoutReferences {
+  /**
+   * Edition of a book
+   *
+   * @keyword
+   */
+  bookEdition?: string;
+
+  /**
+   * ISBN of a book
+   *
+   * @keyword
+   */
+  isbn: string;
+
+  /**
+   * Number of pages of a book
+   *
+   * @integer
+   */
+  numberOfPages?: number;
+
+  /**
+   * Translated properties of a book
+   */
+  translations?: SCTranslations<SCBookTranslatableFields>;
+
+  /**
+   * Type of a book
+   */
+  type: SCThingType.Book;
+}
+
+/**
+ * A book
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCBook
+  extends SCCreativeWork, SCBookWithoutReferences {
+  /**
+   * Authors of the creative work
+   */
+  authors: SCPersonWithoutReferences[];
+
+  /**
+   * Translated properties of a book
+   */
+  translations?: SCTranslations<SCBookTranslatableFields>;
+
+  /**
+   * Type of a book
+   */
+  type: SCThingType.Book;
+}
+
+/**
+ * Translatable properties of a book
+ */
+export interface SCBookTranslatableFields
+  extends SCThingWithCategoriesTranslatableProperties, SCCreativeWorkTranslatableProperties {
+  /**
+   * Translation of an edition of a book
+   *
+   * @keyword
+   */
+  bookEdition?: string;
+}
+
+/**
+ * Meta information about a book
+ */
+export class SCBookMeta extends SCThingMeta implements SCMetaTranslations<SCBook> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .de,
+      bookEdition: 'Buchausgabe',
+      isbn: 'ISBN',
+      numberOfPages: 'Seitenzahl',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .en,
+      bookEdition: 'book edition',
+      isbn: 'ISBN',
+      numberOfPages: 'number of pages',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.de,
+      type: 'Buch',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Book,
+    },
+  };
+}

src/things/building.ts

@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {
+  SCPlace,
+  SCPlaceWithoutReferences,
+  SCPlaceWithoutReferencesMeta,
+  SCPlaceWithoutReferencesTranslatableProperties,
+} from './abstract/place';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+export type SCBuildingCategories =
+  'cafe'
+  | 'education'
+  | 'library'
+  | 'office'
+  | 'canteen'
+  | 'student canteen'
+  | 'restaurant'
+  | 'restroom';
+
+export interface SCBuildingWithoutReferences
+  extends SCThingWithCategoriesWithoutReferences<SCBuildingCategories, SCThingWithCategoriesSpecificValues>,
+    SCPlaceWithoutReferences {
+  /**
+   * Categories of a building
+   *
+   * @sortable ducet
+   * @aggregatable
+   */
+  categories: SCBuildingCategories[];
+
+  /**
+   * List of floor names of the place
+   *
+   * @keyword
+   */
+  floors?: string[];
+
+  /**
+   * Translated fields of a building
+   */
+  translations?: SCTranslations<SCBuildingTranslatableProperties>;
+
+  /**
+   * Type of the building
+   */
+  type: SCThingType.Building;
+}
+
+/**
+ * A building
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCBuilding
+  extends SCBuildingWithoutReferences, SCPlace,
+    SCThingWithCategories<SCBuildingCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Translated fields of a building
+   */
+  translations?: SCTranslations<SCBuildingTranslatableProperties>;
+
+  /**
+   * Type of the building
+   */
+  type: SCThingType.Building;
+}
+
+export interface SCBuildingTranslatableProperties
+  extends SCPlaceWithoutReferencesTranslatableProperties, SCThingWithCategoriesTranslatableProperties {
+  /**
+   * @see SCBuilding.floors
+   */
+  floors?: string[];
+}
+
+/**
+ * Meta information about a place
+ */
+export class SCBuildingMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCBuilding> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCBuildingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldTranslations.de,
+      floors: 'Etagen',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCBuildingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldTranslations.en,
+      floors: 'floors',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCBuildingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldValueTranslations.de,
+      categories: {
+        'cafe': 'Café',
+        'canteen': 'Kantine',
+        'education': 'Bildung',
+        'library': 'Bibliothek',
+        'office': 'Büro',
+        'restaurant': 'Restaurant',
+        'restroom': 'Toilette',
+        'student canteen': 'Mensa',
+      },
+      type: 'Gebäude',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCBuildingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldValueTranslations.en,
+      type: SCThingType.Building,
+    },
+  };
+}

src/things/catalog.ts

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCAcademicTermWithoutReferences} from './abstract/academic-term';
+import {SCThing, SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * A catalog without references
+ */
+export interface SCCatalogWithoutReferences
+  extends SCThingWithCategoriesWithoutReferences<SCCatalogCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Level of the catalog (0 for 'root catalog', 1 for its subcatalog, 2 for its subcatalog etc.)
+   *
+   * Needed for keeping order in catalog inheritance array.
+   *
+   * @integer
+   */
+  level: number;
+
+  /**
+   * Type of a catalog
+   */
+  type: SCThingType.Catalog;
+}
+
+/**
+ * A catalog
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCCatalog
+  extends SCCatalogWithoutReferences, SCThing,
+    SCThingWithCategories<SCCatalogCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Academic term that a catalog belongs to (e.g. semester)
+   */
+  academicTerm?: SCAcademicTermWithoutReferences;
+
+  /**
+   * The direct parent of a catalog
+   */
+  superCatalog?: SCCatalogWithoutReferences;
+
+  /**
+   * An array of catalogs from the 'level 0' (root) catalog to the direct parent
+   */
+  superCatalogs?: SCCatalogWithoutReferences[];
+
+  /**
+   * Translated fields of a catalog
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+
+  /**
+   * Type of a catalog
+   */
+  type: SCThingType.Catalog;
+}
+
+/**
+ * Catalog meta data
+ */
+export class SCCatalogMeta
+  extends SCThingMeta implements SCMetaTranslations<SCCatalog> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCCatalogCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      academicTerm: 'Semester',
+      level: 'Ebene',
+      superCatalog: 'übergeordnetes Verzeichniss',
+      superCatalogs: 'übergeordnete Verzeichnisse',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCCatalogCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      academicTerm: 'academic term',
+      level: 'level',
+      superCatalog: 'parent catalog',
+      superCatalogs: 'parent catalogs',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCCatalogCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      categories: {
+        'university events': 'Universitätsveranstaltung',
+      },
+      type: 'Verzeichnis',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCCatalogCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      type: SCThingType.Catalog,
+    },
+  };
+}
+
+/**
+ * Categories of catalogs
+ */
+export type SCCatalogCategories = 'university events';

src/things/course-of-studies.ts

@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCLanguage, SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCAcademicDegree, SCAcademicDegreeMeta, SCAcademicDegreeWithoutReferences} from './abstract/academic-degree';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCAcademicPriceGroup,
+  SCThingThatCanBeOffered,
+  SCThingThatCanBeOfferedMeta,
+  SCThingThatCanBeOfferedTranslatableProperties,
+  SCThingThatCanBeOfferedWithoutReferences,
+} from './abstract/thing-that-can-be-offered';
+import {SCDateSeriesWithoutReferences} from './date-series';
+import {SCOrganizationWithoutReferences} from './organization';
+
+/**
+ * A course of studies without references
+ */
+export interface SCCourseOfStudiesWithoutReferences
+  extends SCAcademicDegreeWithoutReferences, SCThingThatCanBeOfferedWithoutReferences {
+  /**
+   * The main language in which the course of studies
+   * is beeing offered
+   */
+  mainLanguage: SCLanguage;
+
+  /**
+   * Actual major of the course of studies (eg. physics)
+   *
+   * @keyword
+   */
+  major: string;
+
+  /**
+   * The modes the course of studies is offered in
+   */
+  mode: SCCourseOfStudiesMode;
+
+  /**
+   * The time modes the course of studies is offered in
+   */
+  timeMode: SCCourseOfStudiesTimeMode;
+
+  /**
+   * Translated fields of a dish
+   */
+  translations?: SCTranslations<SCCourseOfStudiesTranslatableProperties>;
+
+  /**
+   * Type of the course of studies
+   */
+  type: SCThingType.CourseOfStudies;
+}
+
+/**
+ * A course of studies
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCCourseOfStudies
+  extends SCCourseOfStudiesWithoutReferences, SCThingThatCanBeOffered<SCAcademicPriceGroup>, SCAcademicDegree {
+  /**
+   * The department that manages the course of studies
+   */
+  department: SCOrganizationWithoutReferences;
+
+  /**
+   * The secretary that administers requests and
+   * questions concerning the course of studies
+   */
+  secretary: SCOrganizationWithoutReferences;
+
+  /**
+   * Dates at which the course of studies is planned to start
+   */
+  startDates?: SCDateSeriesWithoutReferences[];
+
+  /**
+   * Translated fields of a course of studies
+   */
+  translations?: SCTranslations<SCCourseOfStudiesTranslatableProperties>;
+
+  /**
+   * Type of the course of studies
+   */
+  type: SCThingType.CourseOfStudies;
+}
+
+/**
+ * Translatable properties of a course of studies
+ */
+export interface SCCourseOfStudiesTranslatableProperties
+  extends SCThingThatCanBeOfferedTranslatableProperties {
+  // noop
+}
+
+/**
+ * Meta information about a course of studies
+ */
+export class SCCourseOfStudiesMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCCourseOfStudies> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCAcademicDegreeMeta.getInstance<SCAcademicDegreeMeta>()
+        .fieldTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldTranslations.de,
+      department: 'Fachbereich',
+      mainLanguage: 'Unterrichtssprache',
+      major: 'Studienfach',
+      mode: 'Studiengangsart',
+      secretary: 'Sekretariat',
+      startDates: 'Startdatum',
+      timeMode: 'Zeitmodell',
+    },
+    en: {
+      ...SCAcademicDegreeMeta.getInstance<SCAcademicDegreeMeta>()
+        .fieldTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldTranslations.de,
+      department: 'department',
+      mainLanguage: 'main language',
+      major: 'major',
+      mode: 'mode',
+      secretary: 'secretary',
+      startDates: 'start dates',
+      timeMode: 'time mode',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCAcademicDegreeMeta.getInstance().fieldValueTranslations.de,
+      modes: {
+        combination: 'Kombinationsstudiengang',
+        'double-degree': 'Doppelstudium',
+        dual: 'duales Studium',
+        standard: 'Studium',
+      },
+      timeMode: {
+        fulltime: 'Vollzeitstudiengang',
+        parttime: 'Teilzeitstudiengang',
+      },
+      type: 'Studiengang',
+    },
+    en: {
+      ...SCAcademicDegreeMeta.getInstance().fieldValueTranslations.en,
+      modes: {
+        combination: 'combination course of studies',
+        'double-degree': 'double degree course of studies',
+        dual: 'dual course of studies',
+        standard: 'course of studies',
+      },
+      timeMode: {
+        fulltime: 'full-time',
+        parttime: 'part-time',
+      },
+      type: SCThingType.CourseOfStudies,
+    },
+  };
+}
+
+/**
+ * Types of (german) course of studies modes
+ */
+export type SCCourseOfStudiesMode = 'combination'
+  | 'dual'
+  | 'double-degree'
+  | 'standard' ;
+
+/**
+ * Types of (german) course of studies time modes
+ */
+export type SCCourseOfStudiesTimeMode = 'fulltime'
+  | 'parttime' ;

src/things/date-series.ts

@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCISO8601Date, SCISO8601Duration} from '../general/time';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {SCThingInPlace, SCThingInPlaceMeta} from './abstract/thing-in-place';
+import {
+  SCAcademicPriceGroup,
+  SCThingThatCanBeOffered,
+  SCThingThatCanBeOfferedMeta,
+  SCThingThatCanBeOfferedTranslatableProperties,
+  SCThingThatCanBeOfferedWithoutReferences,
+} from './abstract/thing-that-can-be-offered';
+import {SCAcademicEventWithoutReferences} from './academic-event';
+import {SCPersonWithoutReferences} from './person';
+import {SCSportCourseWithoutReferences} from './sport-course';
+
+/**
+ * Price groups for sport courses
+ */
+export interface SCSportCoursePriceGroup
+  extends SCAcademicPriceGroup {
+  /**
+   * Price for alumnis
+   *
+   * @float
+   */
+  alumni?: number;
+}
+
+/**
+ * A date without references
+ */
+export interface SCDateSeriesWithoutReferences
+  extends SCThingThatCanBeOfferedWithoutReferences {
+  /**
+   * Dates of the date series that are initially planned to be held
+   */
+  dates: SCISO8601Date[];
+
+  /**
+   * Duration of the date series
+   */
+  duration: SCISO8601Duration;
+
+  /**
+   * Dates that where initially planned to be held but are cancelled
+   */
+  exceptions?: SCISO8601Date[];
+
+  /**
+   * Frequency of the date series
+   *
+   * @keyword
+   */
+  frequency: string;
+
+  /**
+   * Translated properties
+   */
+  translations?: SCTranslations<SCDateSeriesTranslatableProperties>;
+
+  /**
+   * Type of a date series
+   */
+  type: SCThingType.DateSeries;
+}
+
+/**
+ * A date series
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCDateSeries
+  extends SCDateSeriesWithoutReferences,
+    SCThingInPlace,
+    SCThingThatCanBeOffered<SCSportCoursePriceGroup> {
+  /**
+   * Event to which the date series belongs
+   */
+  event: SCAcademicEventWithoutReferences
+    | SCSportCourseWithoutReferences;
+
+  /**
+   * Performers of the date series
+   */
+  performers?: SCPersonWithoutReferences[];
+
+  /**
+   * Translated properties
+   */
+  translations?: SCTranslations<SCDateSeriesTranslatableProperties>;
+
+  /**
+   * Type of a date series
+   */
+  type: SCThingType.DateSeries;
+}
+
+/**
+ * Meta information about a date series
+ */
+export class SCDateSeriesMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCDateSeries> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .de,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCSportCoursePriceGroup>()
+        .fieldTranslations.de,
+      dates: 'Einzeltermine',
+      duration: 'Dauer',
+      event: 'Event',
+      exceptions: 'Ausnahmen',
+      frequency: 'Frequenz',
+      performers: 'Vortragende',
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .en,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCSportCoursePriceGroup>()
+        .fieldTranslations.en,
+      dates: 'dates',
+      duration: 'duration',
+      event: 'event',
+      exceptions: 'exceptions',
+      frequency: 'frequency',
+      performers: 'performers',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCSportCoursePriceGroup>()
+        .fieldValueTranslations.de,
+      type: 'Terminserie',
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCSportCoursePriceGroup>()
+        .fieldValueTranslations.en,
+      type: SCThingType.DateSeries,
+    },
+  };
+}
+
+/**
+ * Translatable properties of date series'
+ */
+export interface SCDateSeriesTranslatableProperties
+  extends SCThingThatCanBeOfferedTranslatableProperties {
+  /**
+   * @see SCDateSeriesWithoutReferences.frequency
+   */
+  frequency?: string;
+}

src/things/diff.ts

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import * as jsonpatch from 'json-patch';
+import {SCMetaTranslations} from '../general/i18n';
+import {SCISO8601Date} from '../general/time';
+import {SCThingsWithoutDiff} from '../meta';
+import {SCThing, SCThingMeta, SCThingType, SCThingWithoutReferences} from './abstract/thing';
+
+/**
+ * A diff without references
+ */
+export interface SCDiffWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Action of the diff
+   */
+  action: 'changed' | 'removed';
+
+  /**
+   * Diff patch. Only when action === 'changed'
+   */
+  changes?: jsonpatch.OpPatch[];
+
+  /**
+   * Creation date of the diff.
+   */
+  dateCreated: SCISO8601Date;
+
+  /**
+   * Type of a diff
+   */
+  type: SCThingType.Diff;
+}
+
+/**
+ * A diff
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCDiff
+  extends SCDiffWithoutReferences, SCThing {
+  /**
+   * Original object the diff was generated on
+   */
+  object: SCThingsWithoutDiff;
+
+  /**
+   * Type of a diff
+   */
+  type: SCThingType.Diff;
+}
+
+/**
+ * Meta information about a diff
+ */
+export class SCDiffMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCDiff> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      action: 'Aktion',
+      changes: 'Änderungen',
+      dateCreated: 'Erstellungsdatum',
+      object: 'Objekt',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      action: 'action',
+      changes: 'changes',
+      dateCreated: 'date created',
+      object: 'object',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance().fieldValueTranslations.de,
+      action: {
+        'changed': 'geändert',
+        'removed': 'gelöscht',
+      },
+      type: 'Unterschied',
+    },
+    en: {
+      ...SCThingMeta.getInstance().fieldValueTranslations.en,
+      type: SCThingType.Diff,
+    },
+  };
+}

src/things/dish.ts

@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCAcademicPriceGroup,
+  SCThingThatCanBeOffered,
+  SCThingThatCanBeOfferedMeta,
+  SCThingThatCanBeOfferedTranslatableProperties,
+  SCThingThatCanBeOfferedWithoutReferences,
+} from './abstract/thing-that-can-be-offered';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * A dish without references
+ */
+export interface SCDishWithoutReferences
+  extends SCThingThatCanBeOfferedWithoutReferences,
+    SCThingWithCategoriesWithoutReferences<SCDishCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Additives of the dish
+   *
+   * @keyword
+   */
+  additives?: string[];
+
+  /**
+   * Category of the dish
+   *
+   * @sortable ducet
+   * @aggregatable
+   */
+  categories: SCDishCategories[];
+
+  /**
+   * Characteristics of the dish
+   */
+  characteristics?: SCDishCharacteristic[];
+
+  /**
+   * Nutrition information (calories and nutrients with amounts)
+   */
+  nutrition?: SCNutritionInformation;
+
+  /**
+   * Translated fields of a dish
+   */
+  translations?: SCTranslations<SCDishTranslatableProperties>;
+
+  /**
+   * Type of a dish
+   */
+  type: SCThingType.Dish;
+}
+
+/**
+ * A dish
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCDish
+  extends SCDishWithoutReferences, SCThingThatCanBeOffered<SCAcademicPriceGroup>,
+    SCThingWithCategories<SCDishCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Dishes ("Beilagen") that are served with the dish (if only certain supplement dishes can be taken with a dish)
+   */
+  dishAddOns?: SCDishWithoutReferences[];
+
+  /**
+   * Translated fields of a dish
+   */
+  translations?: SCTranslations<SCDishTranslatableProperties>;
+
+  /**
+   * Type of a dish
+   */
+  type: SCThingType.Dish;
+}
+
+export interface SCDishTranslatableProperties
+  extends SCThingWithCategoriesTranslatableProperties, SCThingThatCanBeOfferedTranslatableProperties {
+  /**
+   * Characteristics of the dish
+   */
+  characteristics?: SCDishCharacteristic[];
+}
+
+/**
+ * Composition of properties of a food characteristic
+ */
+export interface SCDishCharacteristic {
+  /**
+   * URL of an image of the characteristic
+   *
+   * @keyword
+   */
+  image?: string;
+
+  /**
+   * Name of the characteristic
+   *
+   * @text
+   */
+  name: string;
+}
+
+/**
+ * A list of categories for dishes
+ */
+export type SCDishCategories =
+  | 'appetizer'
+  | 'salad'
+  | 'main dish'
+  | 'dessert'
+  | 'soup'
+  | 'side dish';
+
+/**
+ * Type definition for SCNutritionInformation
+ *
+ * @see https://schema.org/NutritionInformation
+ */
+export interface SCNutritionInformation {
+  /**
+   * Number of calories contained (in kcal)
+   *
+   * @float
+   */
+  calories?: number;
+
+  /**
+   * Content of carbohydrates (in grams)
+   *
+   * @float
+   */
+  carbohydrateContent?: number;
+
+  /**
+   * Content of fat (in grams)
+   *
+   * @float
+   */
+  fatContent?: number;
+
+  /**
+   * Content of proteins (in grams)
+   *
+   * @float
+   */
+  proteinContent?: number;
+
+  /**
+   * Content of salt (in grams)
+   *
+   * @float
+   */
+  saltContent?: number;
+
+  /**
+   * Content of saturated fat (in grams)
+   *
+   * @float
+   */
+  saturatedFatContent?: number;
+
+  /**
+   * Content of sugar (in grams)
+   *
+   * @float
+   */
+  sugarContent?: number;
+}
+
+/**
+ * Meta information about a dish
+ */
+export class SCDishMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCDish> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCDishCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldTranslations.de,
+      additives: 'Zusatzstoffe',
+      characteristics: 'Merkmale',
+      dishAddOns: 'Beilagen',
+      nutrition: 'Nährwertangaben',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCDishCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldTranslations.en,
+      additives: 'additives',
+      characteristics: 'characteristics',
+      dishAddOns: 'side dishes',
+      nutrition: 'nutrition information',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCDishCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldValueTranslations.de,
+      categories: {
+        appetizer: 'Vorspeise',
+        dessert: 'Nachtisch',
+        'main dish': 'Hauptgericht',
+        salad: 'Salat',
+        'side dish': 'Beilage',
+        soup: 'Suppe',
+      },
+      type: 'Essen',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCDishCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Dish,
+    },
+  };
+}

src/things/favorite.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCSaveableThing, SCSaveableThingWithoutReferences} from './abstract/saveable-thing';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {SCAcademicEventWithoutReferences} from './academic-event';
+import {SCArticleWithoutReferences} from './article';
+import {SCBookWithoutReferences} from './book';
+import {SCBuildingWithoutReferences} from './building';
+import {SCPersonWithoutReferences} from './person';
+import {SCPointOfInterestWithoutReferences} from './point-of-interest';
+import {SCRoomWithoutReferences} from './room';
+import {SCSportCourseWithoutReferences} from './sport-course';
+import {SCToDoWithoutReferences} from './todo';
+
+/**
+ * Types that can be made a favorite (added as a favorite)
+ */
+export type SCFavoriteDataTypes = SCAcademicEventWithoutReferences
+  | SCArticleWithoutReferences
+  | SCBookWithoutReferences
+  | SCBuildingWithoutReferences
+  | SCPersonWithoutReferences
+  | SCPointOfInterestWithoutReferences
+  | SCRoomWithoutReferences
+  | SCSportCourseWithoutReferences
+  | SCToDoWithoutReferences;
+
+/**
+ * A favorite without references
+ */
+export interface SCFavoriteWithoutReferences
+  extends SCSaveableThingWithoutReferences {
+  // noop
+}
+
+/**
+ * A favorite
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCFavorite
+  extends SCSaveableThing<SCFavoriteDataTypes>, SCFavoriteWithoutReferences {
+  /**
+   * Type of a favorite
+   */
+  type: SCThingType.Favorite;
+}
+
+/**
+ * Meta information about a favorite
+ */
+export class SCFavoriteMeta
+  extends SCThingMeta {
+}

src/things/floor.ts

@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+// tslint:disable-next-line:no-implicit-dependencies
+import {Feature, FeatureCollection, GeometryObject, LineString} from 'geojson';
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCThingMeta, SCThingTranslatableProperties, SCThingType, SCThingWithoutReferences} from './abstract/thing';
+import {SCThingInPlace, SCThingInPlaceMeta} from './abstract/thing-in-place';
+import {SCPointOfInterestWithoutReferences} from './point-of-interest';
+import {SCRoomWithoutReferences} from './room';
+
+/**
+ * A floor without references
+ */
+export interface SCFloorWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Floor name in the place it is in e.g. "first floor", "ground floor". This doesn't reference the building name.
+   *
+   * @text
+   */
+  floorName: string;
+
+  /**
+   * Floor plan
+   */
+  plan: SCFloorFeatureCollectionWithPlaces<LineString>;
+
+  /**
+   * Translated fields of a floor
+   */
+  translations?: SCTranslations<SCFloorTranslatableProperties>;
+
+  /**
+   * Type of a floor
+   */
+  type: SCThingType.Floor;
+}
+
+/**
+ * A floor
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCFloor
+  extends SCFloorWithoutReferences, SCThingInPlace {
+  /**
+   * Translated fields of a floor
+   */
+  translations?: SCTranslations<SCFloorTranslatableProperties>;
+
+  /**
+   * Type of a floor
+   */
+  type: SCThingType.Floor;
+}
+
+/**
+ * A feature collection
+ */
+export interface SCFloorFeatureCollectionWithPlaces<T extends GeometryObject>
+  extends FeatureCollection<T> {
+  /**
+   * Features of the collection
+   */
+  features: Array<SCFloorFeatureWithPlace<T>>;
+}
+
+/***
+ * A feature with a place
+ */
+export interface SCFloorFeatureWithPlace<T extends GeometryObject>
+  extends Feature<T> {
+  /**
+   * The place of the feature
+   */
+  place?: SCRoomWithoutReferences | SCPointOfInterestWithoutReferences;
+}
+
+/**
+ * Translatable properties of a floor
+ */
+export interface SCFloorTranslatableProperties
+  extends SCThingTranslatableProperties {
+  /**
+   * Translation of the floor name
+   *
+   * @text
+   */
+  floorName?: string;
+}
+
+/**
+ * Meta information about floors
+ */
+export class SCFloorMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCFloor> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .de,
+      floorName: 'Etagenbezeichnung',
+      plan: 'Grundriss',
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .en,
+      floorName: 'floor name',
+      plan: 'plan',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.de,
+      type: 'Etage',
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Floor,
+    },
+  };
+}

src/things/message.ts

@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCISO8601Date} from '../general/time';
+import {
+  SCCreativeWork,
+  SCCreativeWorkMeta,
+  SCCreativeWorkTranslatableProperties,
+  SCCreativeWorkWithoutReferences,
+} from './abstract/creative-work';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {SCThingThatCanBeOfferedTranslatableProperties} from './abstract/thing-that-can-be-offered';
+
+/**
+ * A message without references
+ */
+export interface SCMessageWithoutReferences
+  extends SCCreativeWorkWithoutReferences {
+  /**
+   * Audience of the message
+   */
+  audiences: SCMessageAudience[];
+
+  /**
+   * When the message was created
+   */
+  dateCreated?: SCISO8601Date;
+
+  /**
+   * Message itself
+   *
+   * @text
+   */
+  messageBody: string;
+
+  /**
+   * Translated fields of a message
+   */
+  translations?: SCTranslations<SCMessageTranslatableProperties>;
+
+  /**
+   * Type of a message
+   */
+  type: SCThingType.Message;
+}
+
+/**
+ * A message
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCMessage
+  extends SCCreativeWork, SCMessageWithoutReferences {
+  /**
+   * Translated fields of a message
+   */
+  translations?: SCTranslations<SCMessageTranslatableProperties>;
+
+  /**
+   * Type of a message
+   */
+  type: SCThingType.Message;
+}
+
+/**
+ * Audiences for messages
+ */
+export type SCMessageAudience =
+  'students'
+  | 'employees'
+  | 'guests';
+
+/**
+ * Translatable properties of a message
+ */
+export interface SCMessageTranslatableProperties
+  extends SCCreativeWorkTranslatableProperties, SCThingThatCanBeOfferedTranslatableProperties {
+  /**
+   * Message itself
+   *
+   * @text
+   */
+  messageBody?: string;
+}
+
+/**
+ * Meta information about messages
+ */
+export class SCMessageMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCMessage> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .de,
+      audiences: 'Zielgruppen',
+      dateCreated: 'Erstellungsdatum',
+      messageBody: 'Nachrichteninhalt',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .en,
+      audiences: 'audiences',
+      dateCreated: 'date created',
+      messageBody: 'message body',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.de,
+      audiences: {
+        'employees': 'Angestellte',
+        'guests': 'Gäste',
+        'students': 'Studenten',
+      },
+      type: 'Nachricht',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Message,
+    },
+  };
+}

src/things/organization.ts

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../general/i18n';
+import {SCThingMeta, SCThingType, SCThingWithoutReferences} from './abstract/thing';
+import {SCThingInPlace, SCThingInPlaceMeta} from './abstract/thing-in-place';
+
+/**
+ * An organization without references
+ */
+export interface SCOrganizationWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Type of an organization
+   */
+  type: SCThingType.Organization;
+}
+
+/**
+ * An organization
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCOrganization
+  extends SCOrganizationWithoutReferences, SCThingInPlace {
+  /**
+   * Type of an organization
+   */
+  type: SCThingType.Organization;
+}
+
+/**
+ * Meta information about an organization
+ */
+export class SCOrganizationMeta
+  extends SCThingMeta implements SCMetaTranslations<SCOrganization> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations.de,
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations.en,
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldValueTranslations.de,
+      type: 'Einrichtung',
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldValueTranslations.en,
+      type: SCThingType.Organization,
+    },
+  };
+}

src/things/person.ts

@@ -0,0 +1,275 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCNationality} from '../general/i18n';
+import {SCISO8601Date} from '../general/time';
+import {SCThing, SCThingMeta, SCThingType, SCThingWithoutReferences} from './abstract/thing';
+import {SCBuildingWithoutReferences} from './building';
+import {SCOrganizationWithoutReferences} from './organization';
+import {SCPointOfInterestWithoutReferences} from './point-of-interest';
+import {SCRoomWithoutReferences} from './room';
+
+/**
+ * A person without references
+ */
+export interface SCPersonWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Additional first names of the person.
+   *
+   * @keyword
+   */
+  additionalName?: string;
+
+  /**
+   * The birth date of the person.
+   */
+  birthDate?: SCISO8601Date;
+
+  /**
+   * The private email address of the person.
+   *
+   * @TJS-format email
+   *
+   * @keyword
+   */
+  email?: string;
+
+  /**
+   * The family name of the person.
+   *
+   * @keyword
+   */
+  familyName: string;
+
+  /**
+   * The private fax number of the person.
+   *
+   * @keyword
+   */
+  faxNumber?: string;
+
+  /**
+   * The gender of the person.
+   */
+  gender?: SCPersonGender;
+
+  /**
+   * The first name of the person.
+   *
+   * @keyword
+   */
+  givenName: string;
+
+  /**
+   * Honorific prefix of the person.
+   *
+   * @keyword
+   */
+  honorificPrefix?: string;
+
+  /**
+   * Honorific suffix of the person.
+   *
+   * @keyword
+   */
+  honorificSuffix?: string;
+
+  /**
+   * Titles of jobs that the person has.
+   *
+   * @keyword
+   */
+  jobTitles?: string[];
+
+  /**
+   * The complete name of the person combining all the parts of the name into one.
+   *
+   * @text
+   */
+  name: string;
+
+  /**
+   * The nationality of the person.
+   */
+  nationality?: SCNationality;
+
+  /**
+   * The private telephone number of the person.
+   *
+   * @keyword
+   */
+  telephone?: string;
+
+  /**
+   * Type of a person
+   */
+  type: SCThingType.Person;
+}
+
+/**
+ * A person
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCPerson
+  extends SCPersonWithoutReferences, SCThing {
+  /**
+   * Organization the person works for
+   */
+  affiliations?: SCOrganizationWithoutReferences[];
+
+  /**
+   * A list of homes of the person
+   */
+  homeLocations?: Array<SCBuildingWithoutReferences
+    | SCPointOfInterestWithoutReferences
+    | SCRoomWithoutReferences>;
+
+  /**
+   * Type of a person
+   */
+  type: SCThingType.Person;
+
+  /**
+   * Locations where the person performs her/his work
+   */
+  workLocations?: SCContactPoint[];
+}
+
+/**
+ * Meta information about a person
+ */
+export class SCPersonMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCPerson> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      additionalName: 'Zusatzname',
+      affiliations: 'Zugehörigkeiten',
+      birthDate: 'Geburtsdatum',
+      email: 'E-Mail',
+      familyName: 'Nachname',
+      faxNumber: 'Faxnummer',
+      gender: 'Geschlecht',
+      givenName: 'Vorname',
+      homeLocations: 'Heimatstandorte',
+      honorificPrefix: 'Ehrentitel',
+      honorificSuffix: 'Ehrentitel (Suffix)',
+      jobTitles: 'Berufsbezeichnungen',
+      nationality: 'Staatsangehörigkeit',
+      telephone: 'Telefonnummer',
+      workLocations: 'Arbeitsorte',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      additionalName: 'additional name',
+      affiliations: 'affiliations',
+      birthDate: 'birth date',
+      email: 'email',
+      familyName: 'family name',
+      faxNumber: 'fax',
+      gender: 'gender',
+      givenName: 'given name',
+      homeLocations: 'home locations',
+      honorificPrefix: 'honorific title',
+      honorificSuffix: 'honorific title (suffix)',
+      jobTitles: 'job titles',
+      nationality: 'nationality',
+      telephone: 'telephone',
+      workLocations: 'work locations',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+      gender: {
+        'female': 'weiblich',
+        'inter': 'divers',
+        'male': 'männlich',
+        'undefined': 'undefiniert',
+      },
+      type: 'Person',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+      type: SCThingType.Person,
+    },
+  };
+}
+
+/**
+ * A contact point
+ *
+ * @see http://schema.org/ContactPoint
+ */
+export interface SCContactPoint {
+  /**
+   * Exact place where work is performed
+   */
+  areaServed?: SCRoomWithoutReferences;
+
+  /**
+   * E-mail at the work location
+   *
+   * @keyword
+   */
+  email?: string;
+
+  /**
+   * Fax number at the work location
+   *
+   * @keyword
+   */
+  faxNumber?: string;
+
+  /**
+   * Times available for contacting at the work location
+   *
+   * @keyword
+   */
+  hoursAvailable?: string;
+
+  /**
+   * Contact number at the work location
+   *
+   * @keyword
+   */
+  telephone?: string;
+
+  /**
+   * URL at the work location
+   *
+   * @keyword
+   */
+  url?: string;
+}
+
+/**
+ * Gender of a person
+ */
+export type SCPersonGender =
+  'male'
+  | 'female'
+  | 'inter'
+  | 'undefined';

src/things/point-of-interest.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCPlace, SCPlaceWithoutReferences, SCPlaceWithoutReferencesMeta} from './abstract/place';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {SCThingInPlace, SCThingInPlaceMeta} from './abstract/thing-in-place';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * A point of interest without references
+ */
+export interface SCPointOfInterestWithoutReferences
+  extends SCThingWithCategoriesWithoutReferences<SCPointOfInterestCategories, SCThingWithCategoriesSpecificValues>,
+    SCPlaceWithoutReferences {
+  /**
+   * Translated properties of a point of interest
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+
+  /**
+   * Type of a point of interest
+   */
+  type: SCThingType.PointOfInterest;
+}
+
+/**
+ * A point of interest
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCPointOfInterest
+  extends SCPointOfInterestWithoutReferences, SCThingInPlace, SCPlace,
+    SCThingWithCategories<SCPointOfInterestCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Translated properties of a point of interest
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+
+  /**
+   * Type of a point of interest
+   */
+  type: SCThingType.PointOfInterest;
+}
+
+/**
+ * Categories of a point of interest
+ */
+export type SCPointOfInterestCategories =
+  'computer'
+  | 'validator'
+  | 'card charger'
+  | 'printer'
+  | 'disabled access';
+
+/**
+ * Meta information about points of interest
+ */
+export class SCPointOfInterestMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCPointOfInterest> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCPointOfInterestCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldTranslations.de,
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .de,
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCPointOfInterestCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldTranslations.en,
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .en,
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCPointOfInterestCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldValueTranslations.de,
+      categories: {
+        'card charger': 'Kartenaufwerter',
+        'computer': 'Computer',
+        'disabled access': 'barrierefreier Zugang',
+        'printer': 'Drucker',
+        'validator': 'Validierer',
+      },
+      type: 'Sonderziel',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCPointOfInterestCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldValueTranslations.en,
+      type: SCThingType.PointOfInterest,
+    },
+  };
+}

src/things/room.ts

@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCMap} from '../general/map';
+import {SCPlace, SCPlaceWithoutReferences, SCPlaceWithoutReferencesMeta} from './abstract/place';
+
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {SCThingInPlace, SCThingInPlaceMeta} from './abstract/thing-in-place';
+import {
+  SCThingThatAcceptsPayments,
+  SCThingThatAcceptsPaymentsWithoutReferences,
+  SCThingThatAcceptsPaymentsWithoutReferencesMeta,
+} from './abstract/thing-that-accepts-payments';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * Categories of a room
+ */
+export type SCRoomCategories =
+  'cafe'
+  | 'canteen'
+  | 'computer'
+  | 'education'
+  | 'laboratory'
+  | 'learn'
+  | 'library'
+  | 'lounge'
+  | 'office'
+  | 'restaurant'
+  | 'restroom'
+  | 'student canteen'
+  | 'student union';
+
+/**
+ * A room without references
+ */
+export interface SCRoomWithoutReferences
+  extends SCPlaceWithoutReferences, SCThingThatAcceptsPaymentsWithoutReferences,
+    SCThingWithCategoriesWithoutReferences<SCRoomCategories, SCRoomSpecificValues> {
+  /**
+   * The name of the floor in which the room is in.
+   *
+   * @text
+   */
+  floorName?: string;
+
+  /**
+   * The inventory of the place/room as a list of items and their quantity.
+   */
+  inventory?: SCMap<number>;
+
+  /**
+   * Translations of specific values of the object
+   *
+   * Take precedence over "main" value for selected languages.
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+
+  /**
+   * Type of the room
+   */
+  type: SCThingType.Room;
+}
+
+/**
+ * A room
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCRoom
+  extends SCRoomWithoutReferences, SCThingInPlace, SCThingThatAcceptsPayments, SCPlace,
+    SCThingWithCategories<SCRoomCategories, SCRoomSpecificValues> {
+  /**
+   * Translations of specific values of the object
+   *
+   * Take precedence over "main" value for selected languages.
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+
+  /**
+   * Type of the room
+   */
+  type: SCThingType.Room;
+}
+
+/**
+ * Category specific values of a room
+ */
+export interface SCRoomSpecificValues
+  extends SCThingWithCategoriesSpecificValues {
+  /**
+   * Category specific opening hours of the room
+   *
+   * @keyword
+   */
+  openingHours?: string;
+}
+
+/**
+ * Meta information about a place
+ */
+export class SCRoomMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCRoom> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldTranslations.de,
+      ...SCThingThatAcceptsPaymentsWithoutReferencesMeta.getInstance<SCThingThatAcceptsPaymentsWithoutReferencesMeta>()
+        .fieldTranslations.de,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCRoomCategories,
+        SCRoomSpecificValues>().fieldTranslations.de,
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .de,
+      floorName: 'Etagenbezeichnung',
+      inventory: 'Bestand',
+    },
+    en: {
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldTranslations.en,
+      ...SCThingThatAcceptsPaymentsWithoutReferencesMeta.getInstance<SCThingThatAcceptsPaymentsWithoutReferencesMeta>()
+        .fieldTranslations.en,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCRoomCategories,
+        SCRoomSpecificValues>().fieldTranslations.en,
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .en,
+      floorName: 'floor name',
+      inventory: 'inventory',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldValueTranslations.de,
+      ...SCThingThatAcceptsPaymentsWithoutReferencesMeta.getInstance<SCThingThatAcceptsPaymentsWithoutReferencesMeta>()
+        .fieldValueTranslations.de,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCRoomCategories,
+        SCRoomSpecificValues>().fieldValueTranslations.de,
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.de,
+      categories: {
+        'cafe': 'Café',
+        'canteen': 'Kantine',
+        'computer': 'PC-Pool',
+        'education': 'Bildung',
+        'laboratory': 'Labor',
+        'learn': 'Lernen',
+        'library': 'Bibliothek',
+        'lounge': 'Lounge',
+        'office': 'Büro',
+        'restaurant': 'Restaurant',
+        'restroom': 'Toilette',
+        'student canteen': 'Mensa',
+        'student union': 'Studentenvereinigung',
+      },
+      type: 'Raum',
+    },
+    en: {
+      ...SCPlaceWithoutReferencesMeta.getInstance<SCPlaceWithoutReferencesMeta>().fieldValueTranslations.en,
+      ...SCThingThatAcceptsPaymentsWithoutReferencesMeta.getInstance<SCThingThatAcceptsPaymentsWithoutReferencesMeta>()
+        .fieldValueTranslations.en,
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCRoomCategories,
+        SCRoomSpecificValues>().fieldValueTranslations.en,
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Room,
+    },
+  };
+}

src/things/semester.ts

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../general/i18n';
+import {
+  SCAcademicTerm,
+  SCAcademicTermWithoutReferences,
+  SCAcademicTermWithoutReferencesMeta,
+} from './abstract/academic-term';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+
+/**
+ * A semester without references
+ */
+export interface SCSemesterWithoutReferences
+  extends SCAcademicTermWithoutReferences {
+  /**
+   * The short name of the semester, using the given pattern.
+   *
+   * @pattern ^(WS|SS) [0-9]{4}(/[0-9]{2})?$
+   * @keyword
+   */
+  acronym: string;
+
+  /**
+   * Type of the semester
+   */
+  type: SCThingType.Semester;
+}
+
+/**
+ * A semester
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCSemester
+  extends SCSemesterWithoutReferences, SCAcademicTerm {
+  /**
+   * Type of the semester
+   */
+  type: SCThingType.Semester;
+}
+
+/**
+ * Meta information about a semester
+ */
+export class SCSemesterMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCSemester> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCAcademicTermWithoutReferencesMeta.getInstance<SCAcademicTermWithoutReferencesMeta>().fieldTranslations.de,
+      acronym: 'Abkürzung',
+      endDate: 'Ende',
+      eventsEndDate: 'Vorlesungsschluss',
+      eventsStartDate: 'Vorlesungsbeginn',
+      startDate: 'Beginn',
+    },
+    en: {
+      ...SCAcademicTermWithoutReferencesMeta.getInstance<SCAcademicTermWithoutReferencesMeta>().fieldTranslations.en,
+      acronym: 'acronym',
+      endDate: 'end date',
+      eventsEndDate: 'semester ending',
+      eventsStartDate: 'semester beginning',
+      startDate: 'start date',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCAcademicTermWithoutReferencesMeta.getInstance<SCAcademicTermWithoutReferencesMeta>()
+        .fieldValueTranslations.de,
+      type: 'Semester',
+    },
+    en: {
+      ...SCAcademicTermWithoutReferencesMeta.getInstance<SCAcademicTermWithoutReferencesMeta>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Semester,
+    },
+  };
+}

src/things/setting.ts

@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCThing, SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * A setting without references
+ */
+export interface SCSettingWithoutReferences
+  extends SCThingWithCategoriesWithoutReferences<SCSettingCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Categories of a setting
+   */
+  categories: SCSettingCategories[];
+  /**
+   * The default value of a setting
+   */
+  defaultValue: SCSettingValue | SCSettingValues;
+  /**
+   * The input type of this setting
+   */
+  inputType: SCSettingInputType;
+  /**
+   * The order number this setting should show up in its category list
+   *
+   * @integer
+   */
+  order: number;
+  /**
+   * Translated fields of a setting
+   */
+  translations?: SCTranslations<SCSettingValueTranslatableProperties>;
+  /**
+   * The type of this model
+   */
+  type: SCThingType.Setting;
+  /**
+   * The key of a value of a setting
+   */
+  value?: SCSettingValue | SCSettingValues;
+  /**
+   * The possible values of a setting
+   */
+  values?: SCSettingValues;
+}
+
+/**
+ * A list of categories for settings
+ */
+export type SCSettingCategories =
+  'profile'
+  | 'privacy'
+  | 'credentials'
+  | 'others';
+
+/**
+ * The types of input/value a setting object can carry
+ */
+export enum SCSettingInputType {
+  SingleChoice = 'single choice',
+  MultipleChoice = 'multiple choice',
+  Number = 'number',
+  Text = 'text',
+  Password = 'password',
+}
+
+/**
+ * A setting with references
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCSetting
+  extends SCSettingWithoutReferences, SCThing,
+    SCThingWithCategories<SCSettingCategories, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Translated fields of a setting
+   */
+  translations?: SCTranslations<SCSettingValueTranslatableProperties>;
+  /**
+   * The type of this model
+   */
+  type: SCThingType.Setting;
+}
+
+/**
+ * The type a value of a setting can have
+ */
+export type SCSettingValue = string | number | boolean;
+
+/**
+ * The type of multiple values a setting can have
+ */
+export type SCSettingValues = SCSettingValue[];
+
+/**
+ * Translatable properties of a setting
+ */
+export interface SCSettingValueTranslatableProperties extends SCThingWithCategoriesTranslatableProperties {
+  /**
+   * The translations of the possible values of a setting
+   *
+   * @keyword
+   */
+  values?: string[];
+}
+
+/**
+ * Meta information about settings
+ */
+export class SCSettingMeta extends SCThingMeta implements SCMetaTranslations<SCSetting> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCSettingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      defaultValue: 'Standard Wert',
+      inputType: 'Eingabetyp',
+      order: 'Position',
+      value: 'Wert',
+      values: 'Werte',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCSettingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      defaultValue: 'default value',
+      inputType: 'input type',
+      order: 'position',
+      value: 'value',
+      values: 'values',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCSettingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      categories: {
+        credentials: 'Anmeldedaten',
+        others: 'Andere',
+        privacy: 'Privatsphäre',
+        profile: 'Profil',
+      },
+      inputType: {
+        'multiple choice': 'mehrfach Auswahl',
+        number: 'Zahl',
+        password: 'Passwort',
+        'single choice': 'einfache Auswahl',
+        text: 'Text',
+      },
+      type: 'Einstellung',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<SCSettingCategories,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      type: SCThingType.Setting,
+    },
+  };
+}

src/things/sport-course.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../general/i18n';
+import {SCEvent, SCEventMeta, SCEventWithoutReferences} from './abstract/event';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+
+/**
+ * A sport course without references
+ */
+export interface SCSportCourseWithoutReferences
+  extends SCEventWithoutReferences {
+  /**
+   * Type of a sport course
+   */
+  type: SCThingType.SportCourse;
+}
+
+/**
+ * A sport course
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCSportCourse
+  extends SCEvent, SCSportCourseWithoutReferences {
+  /**
+   * Type of a sport course
+   */
+  type: SCThingType.SportCourse;
+}
+
+/**
+ * Meta information about a sport course
+ */
+export class SCSportCourseMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCSportCourse> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldTranslations.de,
+    },
+    en: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldTranslations.en,
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldValueTranslations.de,
+      type: 'Sportkurs',
+    },
+    en: {
+      ...SCEventMeta.getInstance<SCEventMeta>().fieldValueTranslations.en,
+      type: SCThingType.SportCourse,
+    },
+  };
+}

src/things/study-module.ts

@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCLanguage, SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCMap} from '../general/map';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCAcademicPriceGroup,
+  SCThingThatCanBeOffered,
+  SCThingThatCanBeOfferedMeta,
+  SCThingThatCanBeOfferedTranslatableProperties,
+  SCThingThatCanBeOfferedWithoutReferences,
+} from './abstract/thing-that-can-be-offered';
+import {SCAcademicEventWithoutReferences} from './academic-event';
+import {SCOrganizationWithoutReferences} from './organization';
+import {SCPersonWithoutReferences} from './person';
+
+/**
+ * A study module without references
+ */
+export interface SCStudyModuleWithoutReferences
+  extends SCThingThatCanBeOfferedWithoutReferences {
+
+  /**
+   * ECTS points (European Credit Transfer System)
+   *
+   * @float
+   */
+  ects: number;
+
+  /**
+   * The language in which the study module is offered
+   */
+  language: SCLanguage;
+
+  /**
+   * Majors that this study module is meant for
+   *
+   * @keyword
+   */
+  majors: string[];
+
+  /**
+   * Represents the modules necessity for each given major (of the major property)
+   */
+  necessity: SCMap<SCStudyModuleNecessity>;
+
+  /**
+   * Translated fields of a study module
+   */
+  translations?: SCTranslations<SCStudyModuleTranslatableProperties>;
+
+  /**
+   * Type of the study module
+   */
+  type: SCThingType.StudyModule;
+}
+
+/**
+ * A study module
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCStudyModule
+  extends SCStudyModuleWithoutReferences, SCThingThatCanBeOffered<SCAcademicPriceGroup> {
+  /**
+   * Academic events that make up a study module
+   */
+  academicEvents: SCAcademicEventWithoutReferences[];
+
+  /**
+   * The faculty that manages and curates the study module
+   */
+  faculty: SCOrganizationWithoutReferences;
+
+  /**
+   * Study modules needed for each others fulfillment
+   */
+  partnerModules?: SCStudyModuleWithoutReferences[];
+
+  /**
+   * Study modules required beforehand
+   */
+  requiredModules?: SCStudyModuleWithoutReferences[];
+
+  /**
+   * The secretary that administers requests and
+   * questions concerning the study module by eg. students
+   */
+  secretary: SCOrganizationWithoutReferences | SCPersonWithoutReferences;
+
+  /**
+   * Translated fields of a study module
+   */
+  translations?: SCTranslations<SCStudyModuleTranslatableProperties>;
+
+  /**
+   * Type of the study module
+   */
+  type: SCThingType.StudyModule;
+}
+
+export interface SCStudyModuleTranslatableProperties
+  extends SCThingThatCanBeOfferedTranslatableProperties {
+  /**
+   * Translations of the majors that this study module is meant for
+   *
+   * @keyword
+   */
+  majors?: string[];
+
+  /**
+   * Translations of the modules necessity for each given major (of the major property)
+   */
+  necessity: SCMap<SCStudyModuleNecessity>;
+}
+
+/**
+ * Represents a modules necessity (in a major) as it may be required, optional or
+ * is in a pool of n optional modules were m out of them have to be taken/completed.
+ * Hence the elective option.
+ */
+export enum SCStudyModuleNecessity {
+  Required = 'required',
+  Elective = 'elective',
+  Optional = 'optional',
+}
+
+/**
+ * Study module meta data
+ */
+export class SCStudyModuleMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCStudyModule> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance().fieldTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldTranslations.de,
+      academicEvents: 'Veranstaltungen',
+      ects: 'ECTS-Punkte',
+      faculty: 'Fachbereich',
+      language: 'Unterrichtssprache',
+      majors: 'Fachrichtungen',
+      necessity: 'Erforderlichkeit',
+      partnerModules: 'Partnermodule',
+      requiredModules: 'Benötigte Module',
+      secretary: 'Sekretariat',
+    },
+    en: {
+      ...SCThingMeta.getInstance().fieldTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldTranslations.en,
+      academicEvents: 'academic events',
+      ects: 'ECTS points',
+      faculty: 'faculty',
+      language: 'teaching language',
+      majors: 'majors',
+      necessity: 'necessity',
+      partnerModules: 'partner modules',
+      requiredModules: 'required modules',
+      secretary: 'secretary',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldValueTranslations.de,
+      necessity: {
+        'elective': 'Wahlfach',
+        'optional': 'optional',
+        'required': 'benötigt',
+      },
+      type: 'Studiengangmodul',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+      ...SCThingThatCanBeOfferedMeta.getInstance<SCAcademicPriceGroup>()
+        .fieldValueTranslations.en,
+      type: SCThingType.StudyModule,
+    },
+  };
+}

src/things/ticket.ts

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../general/i18n';
+import {SCISO8601Duration} from '../general/time';
+import {SCThingMeta, SCThingType, SCThingWithoutReferences} from './abstract/thing';
+import {SCThingInPlace, SCThingInPlaceMeta} from './abstract/thing-in-place';
+
+/**
+ * A ticket without references
+ */
+export interface SCTicketWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Approximate wait time
+   */
+  approxWaitingTime: SCISO8601Duration;
+
+  /**
+   * Waiting number of the ticket
+   *
+   * @keyword
+   */
+  currentTicketNumber: string;
+
+  /**
+   * Service type of the ticket
+   */
+  serviceType: string;
+
+  /**
+   * Type of a ticket
+   */
+  type: SCThingType.Ticket;
+}
+
+/**
+ * A ticket
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCTicket
+  extends SCTicketWithoutReferences, SCThingInPlace {
+  /**
+   * Type of a ticket
+   */
+  type: SCThingType.Ticket;
+}
+
+/**
+ * Meta information about a ticket
+ */
+export class SCTicketMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCTicket> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .de,
+      approxWaitingTime: 'ungefähre Wartezeit',
+      currentTicketNumber: 'aktuelle Ticketnummer',
+      serviceType: 'Service Kategorie',
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>().fieldTranslations
+        .en,
+      approxWaitingTime: 'approximate waiting time',
+      currentTicketNumber: 'current ticket number',
+      serviceType: 'type of service',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.de,
+      type: 'Ticket',
+    },
+    en: {
+      ...SCThingInPlaceMeta.getInstance<SCThingInPlaceMeta>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Ticket,
+    },
+  };
+}

src/things/todo.ts

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations, SCTranslations} from '../general/i18n';
+import {SCISO8601Date} from '../general/time';
+import {SCThing, SCThingMeta, SCThingType} from './abstract/thing';
+import {
+  SCThingWithCategories,
+  SCThingWithCategoriesSpecificValues,
+  SCThingWithCategoriesTranslatableProperties,
+  SCThingWithCategoriesWithoutReferences,
+  SCThingWithCategoriesWithoutReferencesMeta,
+} from './abstract/thing-with-categories';
+
+/**
+ * A "to do" without references
+ */
+export interface SCToDoWithoutReferences
+  extends SCThingWithCategoriesWithoutReferences<string, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Whether or not the "to do" is already done
+   */
+  done: boolean;
+
+  /**
+   * A date when the "to do" is due
+   */
+  dueDate?: SCISO8601Date;
+
+  /**
+   * Priority of the "to do"
+   */
+  priority: SCToDoPriority;
+
+  /**
+   * Type of the "to do"
+   */
+  type: SCThingType.ToDo;
+}
+
+/**
+ * A "to do"
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCToDo
+  extends SCToDoWithoutReferences, SCThing, SCThingWithCategories<string, SCThingWithCategoriesSpecificValues> {
+  /**
+   * Translated fields of a thing with categories
+   */
+  translations?: SCTranslations<SCThingWithCategoriesTranslatableProperties>;
+
+  /**
+   * Type of the "to do"
+   */
+  type: SCThingType.ToDo;
+}
+
+/**
+ * A priority of a "to do"
+ */
+export enum SCToDoPriority {
+  LOW = 0,
+  NORMAL = 2,
+  HIGH = 5,
+}
+
+/**
+ * Meta information about todo
+ */
+export class SCToDoMeta extends SCThingMeta implements SCMetaTranslations<SCToDo> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<string,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.de,
+      done: 'Erledigt',
+      dueDate: 'Fälligkeitsdatum',
+      priority: 'Priorität',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<string,
+        SCThingWithCategoriesSpecificValues>().fieldTranslations.en,
+      done: 'done',
+      dueDate: 'due date',
+      priority: 'priority',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<string,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.de,
+      type: 'ToDo',
+    },
+    en: {
+      ...SCThingWithCategoriesWithoutReferencesMeta.getInstance<string,
+        SCThingWithCategoriesSpecificValues>().fieldValueTranslations.en,
+      type: SCThingType.ToDo,
+    },
+  };
+}

src/things/tour.ts

@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCMetaTranslations} from '../general/i18n';
+import {SCThing, SCThingMeta, SCThingType, SCThingWithoutReferences} from './abstract/thing';
+
+/**
+ * A tour without references
+ */
+export interface SCTourWithoutReferences
+  extends SCThingWithoutReferences {
+  /**
+   * Init script for the tour
+   *
+   * @text
+   */
+  init?: string;
+
+  /**
+   * Steps of a tour
+   *
+   * @keyword
+   */
+  steps: SCTourStep[];
+
+  /**
+   * Type of a tour
+   *
+   * @keyword
+   */
+  type: SCThingType.Tour;
+}
+
+/**
+ * A tour
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCTour
+  extends SCTourWithoutReferences, SCThing {
+  /**
+   * Type of a tour
+   */
+  type: SCThingType.Tour;
+}
+
+/**
+ * Meta information about a tour
+ */
+export class SCTourMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCTour> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.de,
+      init: 'Initiales Skript',
+      steps: 'Schritte',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldTranslations.en,
+      init: 'initial script',
+      steps: 'steps',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.de,
+      type: 'Tour',
+    },
+    en: {
+      ...SCThingMeta.getInstance<SCThingMeta>().fieldValueTranslations.en,
+      type: SCThingType.Tour,
+    },
+  };
+}
+
+/**
+ * A step in a tour
+ */
+export type SCTourStep =
+  SCTourStepMenu
+  | SCTourStepLocation
+  | SCTourStepTooltip;
+
+/**
+ * A location of a tour step
+ */
+export interface SCTourStepLocation {
+  /**
+   * Location to go to
+   *
+   * @keyword
+   */
+  location: string;
+
+  /**
+   * Type of the step
+   */
+  type: 'location';
+}
+
+/**
+ * A tooltip in a tour step
+ */
+export interface SCTourStepTooltip {
+  /**
+   * Whether the tooltip may fail or not
+   */
+  canFail?: boolean;
+
+  /**
+   * Element that the tooltip shall be pointing at or a list of elements to try in the specified order
+   *
+   * @keyword
+   */
+  element: string | string[];
+
+  /**
+   * Position of the tooltip
+   */
+  position?: 'bottom' | 'left' | 'right' | 'top';
+
+  /**
+   * How the step shall be resolved
+   */
+  resolved?: SCTourResolvedElement | SCTourResolvedEvent | SCTourResolvedLocation | SCTourResolvedMenu;
+
+  /**
+   * Text that the tooltip shall contain
+   *
+   * @text
+   */
+  text: string;
+
+  /**
+   * How often it shall be retried
+   *
+   * @integer
+   */
+  tries?: number;
+
+  /**
+   * Type of the step
+   */
+  type: 'tooltip';
+}
+
+/**
+ * Menu interaction of a tour step
+ */
+export interface SCTourStepMenu {
+  /**
+   * The action that needs to be completed on the menu
+   */
+  action: 'close';
+
+  /**
+   * The side of the menu that the step refers to
+   */
+  side: 'right';
+
+  /**
+   * The type of the step
+   */
+  type: 'menu';
+}
+
+/**
+ * Tour step resolved by an element
+ */
+export interface SCTourResolvedElement {
+  /**
+   * Element name
+   *
+   * @keyword
+   */
+  element: string;
+}
+
+/**
+ * Tour step resolved by an event
+ */
+export interface SCTourResolvedEvent {
+  /**
+   * Event name
+   *
+   * @keyword
+   */
+  event: string;
+}
+
+/**
+ * Tour step resolved by a location
+ */
+export interface SCTourResolvedLocation {
+  /**
+   * Matching location
+   */
+  location: SCTourResolvedLocationTypeIs | SCTourResolvedLocationTypeMatch;
+}
+
+/**
+ * Tour step resolved by a location for a specific location
+ */
+export interface SCTourResolvedLocationTypeIs {
+  /**
+   * Specific location name
+   *
+   * @keyword
+   */
+  is: string;
+}
+
+/**
+ * Tour step resolved by a location for a specific location
+ */
+export interface SCTourResolvedLocationTypeMatch {
+  /**
+   * Regex location name
+   *
+   * @keyword
+   */
+  match: string;
+}
+
+/**
+ * Tour step resolved by interacting with a menu
+ */
+export interface SCTourResolvedMenu {
+  /**
+   * Menu location
+   */
+  menu: 'open-left' | 'open-right';
+}

src/things/video.ts

@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCLanguage, SCMetaTranslations} from '../general/i18n';
+import {SCISO8601Duration} from '../general/time';
+import {SCCreativeWork, SCCreativeWorkMeta, SCCreativeWorkWithoutReferences} from './abstract/creative-work';
+import {SCThingMeta, SCThingType} from './abstract/thing';
+import {SCPersonWithoutReferences} from './person';
+
+/**
+ * A video without references
+ */
+export interface SCVideoWithoutReferences
+  extends SCCreativeWorkWithoutReferences {
+  /**
+   * The Duration of the Video
+   */
+  duration?: SCISO8601Duration;
+
+  /**
+   * Downloadable/Streamable Files of the Video
+   */
+  sources?: SCVideoSource[];
+
+  /**
+   * URLs to a thumbnails for the Video
+   *
+   * @keyword
+   */
+  thumbnails?: string[];
+
+  /**
+   * Track Files for the Video
+   */
+  tracks?: SCVideoTrack;
+
+  /**
+   * A Transcript of the Video
+   *
+   * @text
+   */
+  transcript?: string;
+
+  /**
+   * Type of an Video
+   */
+  type: SCThingType.Video;
+}
+
+export interface SCVideoSource {
+  /**
+   * Pixel Height of the Video
+   *
+   * @integer
+   */
+  height?: number;
+
+  /**
+   * MIME-Type of the source File
+   */
+  mimeType: SCVideoMimeType;
+
+  /**
+   * Size of the Video File in bytes
+   *
+   * @integer
+   */
+  size?: number;
+
+  /**
+   * URL to the Video File
+   *
+   * @keyword
+   */
+  url: string;
+
+  /**
+   * Pixel Width of the Video
+   *
+   * @integer
+   */
+  width?: number;
+}
+
+export interface SCVideoTrack {
+  /**
+   * Language of the Subtitle
+   */
+  language: SCLanguage;
+
+  /**
+   * Content Type of the Track File
+   */
+  type: SCVideoTrackTypes;
+
+  /**
+   * URL to the Track File
+   *
+   * @keyword
+   */
+  url: string;
+}
+
+/**
+ * A video
+ *
+ * @validatable
+ * @indexable
+ */
+export interface SCVideo
+  extends SCCreativeWork, SCVideoWithoutReferences {
+  /**
+   * Persons acting in the Video
+   */
+  actors?: SCPersonWithoutReferences[];
+
+  /**
+   * Type of a video
+   */
+  type: SCThingType.Video;
+}
+
+/**
+ * Meta information about a video
+ */
+export class SCVideoMeta
+  extends SCThingMeta
+  implements SCMetaTranslations<SCVideo> {
+  /**
+   * Translations of fields
+   */
+  fieldTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .de,
+      actors: 'Darsteller',
+      duration: 'Dauer',
+      sources: 'Quellen',
+      thumbnails: 'Vorschaubilder',
+      tracks: 'Spuren',
+      transcript: 'Transkript',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>().fieldTranslations
+        .en,
+      actors: 'actors',
+      duration: 'duration',
+      sources: 'sources',
+      thumbnails: 'thumbnails',
+      tracks: 'tracks',
+      transcript: 'transcript',
+    },
+  };
+
+  /**
+   * Translations of values of fields
+   */
+  fieldValueTranslations = {
+    de: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.de,
+      type: 'Video',
+    },
+    en: {
+      ...SCCreativeWorkMeta.getInstance<SCCreativeWorkMeta>()
+        .fieldValueTranslations.en,
+      type: SCThingType.Video,
+    },
+  };
+}
+
+/**
+ * Video Encoding Formats
+ */
+export type SCVideoMimeType =
+  'video/mp4'
+  | 'video/ogg'
+  | 'video/webm'
+  | 'application/vnd.apple.mpegurl'
+  | 'application/dash+xml';
+
+/**
+ * Video Track Types
+ */
+export type SCVideoTrackTypes =
+  'closed captions'
+  | 'chapters'
+  | 'description'
+  | 'metadata'
+  | 'subtitles';