@quatrain/core 1.0.0-beta25 → 1.0.0-beta26

package/lib/Core.d.ts

@@ -1,24 +1,14 @@
-import { AbstractAuthAdapter } from './authentication';
-import { AbstractAdapter } from './backends/AbstractAdapter';
 import { User } from './components/User';
 import { DataObjectClass } from './components/types/DataObjectClass';
-export type BackendRegistry<T extends AbstractAdapter> = {
-    [x: string]: T;
-};
-export interface AuthAdapter extends AbstractAuthAdapter {
-}
 export declare class Core {
     static storage: any;
     static storagePrefix: string;
-    static defaultBackend: string;
     static userClass: typeof User;
     static classRegistry: {
         [key: string]: any;
     };
     static logger: Console;
-    static auth: AuthAdapter | AbstractAuthAdapter;
     static timestamp: () => string;
-    protected static _backends: BackendRegistry<any>;
     static definition(key: string): {
         manifest: {
             type: StringConstructor;
@@ -27,8 +17,6 @@ export declare class Core {
     };
     static addConfig(key: string, value: any): Promise<void>;
     static getConfig(key: string): Promise<any>;
-    static addBackend(backend: AbstractAdapter, alias: string, setDefault?: boolean): void;
-    static getBackend<T extends AbstractAdapter>(alias?: string): T;
     static addClass(name: string, obj: any): void;
     static getClass(name: string): any;
     /**

package/lib/Core.js

@@ -37,20 +37,6 @@ class Core {
             return yield this.storage.get(`${this.storagePrefix}_${key}`);
         });
     }
-    static addBackend(backend, alias, setDefault = false) {
-        Core._backends[alias] = backend;
-        if (setDefault) {
-            Core.defaultBackend = alias;
-        }
-    }
-    static getBackend(alias = this.defaultBackend) {
-        if (this._backends[alias]) {
-            return this._backends[alias];
-        }
-        else {
-            throw new Error(`Unknown backend alias: '${alias}'`);
-        }
-    }
     static addClass(name, obj) {
         Core.classRegistry[name] = obj;
     }
@@ -78,10 +64,8 @@ class Core {
 exports.Core = Core;
 Core.storage = require('node-persist');
 Core.storagePrefix = 'core';
-Core.defaultBackend = '@default';
 Core.userClass = User_1.User;
 Core.classRegistry = {};
 Core.logger = console;
 // How timestamp are formatted
 Core.timestamp = () => new Date().toISOString();
-Core._backends = {};

package/lib/components/AbstractObject.d.ts

@@ -23,7 +23,7 @@ export declare abstract class AbstractObject {
     get _(): any;
     get uri(): import("./ObjectUri").ObjectUri;
     toJSON(): {
-        backend: string;
+        backend: string | undefined;
         ref: string;
         label: string;
     };

package/lib/components/BaseObjectCore.d.ts

@@ -1,36 +1,7 @@
-import { ObjectUri } from './ObjectUri';
-import { DataObjectClass } from './types/DataObjectClass';
-import { BaseObjectClass } from './types/BaseObjectClass';
-import { AbstractObject } from './AbstractObject';
-import { BaseObject } from './BaseObject';
-import { Query } from '../backends/Query';
-import { DataObject } from './DataObject';
-import { Persisted } from './types/Persisted';
-import { Proxy } from './types/ProxyConstructor';
-import { DataObjectProperties } from '../properties';
-export declare class BaseObjectCore extends AbstractObject implements BaseObjectClass {
-    static PROPS_DEFINITION: DataObjectProperties;
-    static getProperty(key: string): (import("../properties").NumberPropertyType & {
-        type: string;
-    }) | (import("../properties").BooleanPropertyType & {
-        type: string;
-    }) | (import("../properties").EnumPropertyType & {
-        type: string;
-    }) | (import("../properties").ObjectPropertyType & {
-        type: string;
-    }) | (import("../properties").StringPropertyType & {
-        type: string;
-    }) | (import("../properties").HashPropertyType & {
-        type: string;
-    }) | (import("../properties").DateTimeProperty & {
-        type: string;
-    }) | (import("../properties").ArrayPropertyType & {
-        type: string;
-    }) | (import("../properties").MapPropertyType & {
-        type: string;
-    }) | (import("../properties").CollectionPropertyType & {
-        type: string;
-    }) | undefined;
+import { ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject } from '../';
+export declare class BaseObjectCore extends AbstractObject {
+    static PROPS_DEFINITION: any;
+    static getProperty(key: string): any;
     static fillProperties(child?: any): DataObject;
     static daoFactory(src?: string | ObjectUri | DataObjectClass<any> | undefined, child?: any): Promise<DataObjectClass<any>>;
     /**
@@ -46,7 +17,7 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      * @param path
      * @returns
      */
-    static fromBackend<T>(path: string): Promise<Persisted<T>>;
+    static fromBackend<T>(path: string): Promise<T>;
     /**
      * Instantiates from a DataObject
      * @param dao
@@ -57,17 +28,5 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
      */
-    protected toProxy<T extends BaseObject>(): Proxy<Proxy<T>>;
     asReference(): any;
-    /**
-     * Create a query based on given class where parent is current instance
-     * @param obj
-     * @returns Query
-     */
-    query(obj: any): Query<any>;
-    /**
-     * Create a query based on current class
-     * @returns Query
-     */
-    static query(): Query<typeof BaseObjectCore>;
 }

package/lib/components/BaseObjectCore.js

@@ -10,13 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseObjectCore = void 0;
-const ObjectUri_1 = require("./ObjectUri");
-const AbstractObject_1 = require("./AbstractObject");
-const BaseObject_1 = require("./BaseObject");
-const Query_1 = require("../backends/Query");
-const DataObject_1 = require("./DataObject");
-const ProxyConstructor_1 = require("./types/ProxyConstructor");
-class BaseObjectCore extends AbstractObject_1.AbstractObject {
+const __1 = require("../");
+class BaseObjectCore extends __1.AbstractObject {
     static getProperty(key) {
         return BaseObjectCore.PROPS_DEFINITION.find((prop) => prop.name === key);
     }
@@ -33,7 +28,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
                 base.push(property);
             }
         });
-        const dao = DataObject_1.DataObject.factory({
+        const dao = __1.DataObject.factory({
             properties: base,
             parentProp: this.PARENT_PROP,
         });
@@ -43,7 +38,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
     static daoFactory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
             const dao = this.fillProperties(child);
-            if (src instanceof ObjectUri_1.ObjectUri) {
+            if (src instanceof __1.ObjectUri) {
                 dao.uri = src;
                 yield dao.read();
             }
@@ -62,7 +57,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
      */
     static fromObject(src, child = this) {
         const dao = this.fillProperties(child);
-        dao.uri = new ObjectUri_1.ObjectUri(`${this.COLLECTION}${ObjectUri_1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
+        dao.uri = new __1.ObjectUri(`${this.COLLECTION}${__1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
         dao.uri.class = child;
         dao.populateFromData(src);
         const obj = new this(dao);
@@ -71,12 +66,12 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
     static factory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (typeof src == 'object' && !(src instanceof ObjectUri_1.ObjectUri)) {
+                if (typeof src == 'object' && !(src instanceof __1.ObjectUri)) {
                     return this.fromObject(src);
                 }
                 const dao = yield this.daoFactory(src, child);
                 const constructedObject = Reflect.construct(this, [dao]);
-                return constructedObject.toProxy();
+                return constructedObject;
             }
             catch (err) {
                 throw new Error(`Unable to build instance for '${this.name}': ${err.message}`);
@@ -109,61 +104,47 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
      */
-    toProxy() {
-        return new ProxyConstructor_1.ProxyConstructor(this, {
-            get: (target, prop) => {
-                if (prop === 'uid') {
-                    return target.uid;
-                }
-                if (prop === 'uri') {
-                    return target.uri;
-                }
-                if (prop == 'toJSON') {
-                    return target.toJSON;
-                }
-                if (prop == 'save') {
-                    return target.save;
-                }
-                if (prop == 'constructor') {
-                    return target.constructor;
-                }
-                if (prop === 'core') {
-                    return target;
-                }
-                // i don't know why and i shouldn't have to wonder why
-                // but everything crashes unless we do this terribleness
-                if (prop == 'then') {
-                    return;
-                }
-                return target.val(prop);
-            },
-            set(target, prop, newValue) {
-                if (prop === 'uid' || prop === 'core') {
-                    throw new Error(`Property '${prop}' is readonly`);
-                }
-                target.set(prop, newValue);
-                return true;
-            },
-        });
-    }
+    // protected toProxy<T extends BaseObject>() {
+    //    return new ProxyConstructor<this, Proxy<T>>(this, {
+    //       get: (target, prop) => {
+    //          if (prop === 'uid') {
+    //             return target.uid
+    //          }
+    //          if (prop === 'uri') {
+    //             return target.uri
+    //          }
+    //          if (prop == 'toJSON') {
+    //             return target.toJSON
+    //          }
+    //          if (prop == 'save') {
+    //             return target.save
+    //          }
+    //          if (prop == 'constructor') {
+    //             return target.constructor
+    //          }
+    //          if (prop === 'core') {
+    //             return target
+    //          }
+    //          // i don't know why and i shouldn't have to wonder why
+    //          // but everything crashes unless we do this terribleness
+    //          if (prop == 'then') {
+    //             return
+    //          }
+    //          return target.val(prop as string)
+    //       },
+    //       set(target, prop, newValue) {
+    //          if (prop === 'uid' || prop === 'core') {
+    //             throw new Error(`Property '${prop}' is readonly`)
+    //          }
+    //          target.set(prop as string, newValue)
+    //          return true
+    //       },
+    //    })
+    // }
     asReference() {
         return this._dataObject.toReference();
     }
-    /**
-     * Create a query based on given class where parent is current instance
-     * @param obj
-     * @returns Query
-     */
-    query(obj) {
-        return new Query_1.Query(obj, this);
-    }
-    /**
-     * Create a query based on current class
-     * @returns Query
-     */
-    static query() {
-        return new Query_1.Query(this);
-    }
 }
 exports.BaseObjectCore = BaseObjectCore;
-BaseObjectCore.PROPS_DEFINITION = BaseObject_1.BaseObjectProperties;
+// implements BaseObjectClass {
+BaseObjectCore.PROPS_DEFINITION = __1.BaseObjectProperties;

package/lib/components/DataObject.d.ts

@@ -26,8 +26,8 @@ export declare class DataObject implements DataObjectClass<any> {
     protected _objectUri: ObjectUri;
     protected _uid: string | undefined;
     protected _properties: Properties;
-    protected _persisted: boolean;
     protected _populated: boolean;
+    protected _persisted: boolean;
     protected _parentProp: string | undefined;
     protected _proxied: any;
     /**
@@ -40,6 +40,7 @@ export declare class DataObject implements DataObjectClass<any> {
      */
     protected constructor(params: DataObjectParams | undefined);
     protected _init(properties: any[]): void;
+    isPersisted(): boolean;
     /**
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
@@ -68,13 +69,7 @@ export declare class DataObject implements DataObjectClass<any> {
     populateFromData(data: {
         [x: string]: unknown;
     }): this;
-    /**
-     * Populate data object from backend query
-     * @param data
-     */
-    populateFromBackend(): Promise<DataObject>;
     isPopulated(): boolean;
-    isPersisted(): boolean;
     get properties(): Properties;
     get backend(): string | undefined;
     get path(): string;

package/lib/components/DataObject.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataObject = void 0;
-const Core_1 = require("../Core");
 const Property_1 = require("../properties/Property");
 const ObjectUri_1 = require("./ObjectUri");
 const ResourcesErrors_1 = require("../common/ResourcesErrors");
@@ -27,8 +26,8 @@ class DataObject {
     constructor(params) {
         this._uid = undefined;
         this._properties = {};
-        this._persisted = false;
         this._populated = false;
+        this._persisted = false;
         /**
          * Has data been modified since last backend operation?
          */
@@ -54,6 +53,9 @@ class DataObject {
             this._properties[prop.name] = Property_1.Property.factory(prop, this);
         });
     }
+    isPersisted() {
+        return this._persisted;
+    }
     /**
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
@@ -108,9 +110,8 @@ class DataObject {
             if (this._populated === false) {
                 if (data) {
                     this.populateFromData(data);
-                }
-                else if (this.path !== '/' && this.path !== '') {
-                    yield this.populateFromBackend();
+                    // } else if (this.path !== '/' && this.path !== '') {
+                    //    await this.populateFromBackend()
                 }
                 this._populated = true;
                 if (Reflect.get(this._properties, 'name')) {
@@ -150,30 +151,9 @@ class DataObject {
         }
         return this;
     }
-    /**
-     * Populate data object from backend query
-     * @param data
-     */
-    populateFromBackend() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._populated === false) {
-                if (this.path !== '/' && this.path !== '') {
-                    yield Core_1.Core.getBackend(this._objectUri.backend).read(this);
-                }
-                this._populated = true;
-                if (Reflect.get(this._properties, 'name')) {
-                    this.uri.label = this.val('name');
-                }
-            }
-            return this;
-        });
-    }
     isPopulated() {
         return this._populated;
     }
-    isPersisted() {
-        return this._persisted;
-    }
     get properties() {
         return this._properties;
     }
@@ -198,7 +178,7 @@ class DataObject {
     set uri(uri) {
         this._objectUri = uri;
         if (this._objectUri.collection !== ObjectUri_1.ObjectUri.MISSING_COLLECTION) {
-            this._persisted = true;
+            //  this._persisted = true
         }
     }
     get uri() {
@@ -304,27 +284,15 @@ class DataObject {
     }
     read() {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield Core_1.Core.getBackend().read(this); //this.populate()
-            }
-            catch (err) {
-                console.log(err.message);
-                throw new Error(err.message);
-            }
+            throw new Error(`This is just a stub, please use DataObject from @quatrain/backend to persist`);
         });
     }
     save() {
-        const backend = Core_1.Core.getBackend(this.backend || Core_1.Core.defaultBackend);
-        this._persisted = true;
-        this._modified = false;
-        return this.uid ? backend.update(this) : backend.create(this);
+        throw new Error(`This is just a stub, please use DataObject from @quatrain/backend to persist`);
     }
     delete() {
         return __awaiter(this, void 0, void 0, function* () {
-            const backend = Core_1.Core.getBackend(this.backend || Core_1.Core.defaultBackend);
-            this._persisted = false;
-            this._modified = false;
-            return yield backend.delete(this);
+            throw new Error(`This is just a stub, please use DataObject from @quatrain/backend to persist`);
         });
     }
     /**

package/lib/components/ObjectUri.d.ts

@@ -4,7 +4,7 @@ export declare class ObjectUri {
     protected _str: string;
     protected _pairs: Array<string>;
     protected _literal: string;
-    protected _backend: string;
+    protected _backend: string | undefined;
     protected _path: string;
     protected _uid: string | undefined;
     protected _collection: string | undefined;
@@ -21,7 +21,7 @@ export declare class ObjectUri {
     constructor(str?: string, label?: string | undefined);
     set class(objClass: any);
     get class(): any;
-    get backend(): string;
+    get backend(): string | undefined;
     /**
      * Returns the full path of the resource
      * including optional parents' path
@@ -57,7 +57,7 @@ export declare class ObjectUri {
         label: string | undefined;
     };
     toJSON(): {
-        backend: string;
+        backend: string | undefined;
         ref: string;
         label: string;
     };

package/lib/components/ObjectUri.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectUri = void 0;
-const Core_1 = require("../Core");
 class ObjectUri {
     /**
      * create object uri from string:
@@ -13,7 +12,6 @@ class ObjectUri {
     constructor(str = '', label = '') {
         this._pairs = [];
         this._literal = '';
-        this._backend = Core_1.Core.defaultBackend;
         this._path = ObjectUri.DEFAULT;
         this._uid = undefined;
         this._collection = undefined;
@@ -22,7 +20,7 @@ class ObjectUri {
         this._label = label;
         if (str.includes(':')) {
             const [backend, path] = str.split(':');
-            this._backend = backend || Core_1.Core.defaultBackend;
+            this._backend = backend;
             this._path = path;
         }
         else {

package/lib/components/index.d.ts

@@ -2,9 +2,7 @@ import { DataObject, DataObjectParams } from './DataObject';
 import { DataObjectClass } from './types/DataObjectClass';
 import { ObjectUri } from './ObjectUri';
 import { AbstractObject } from './AbstractObject';
-import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObjectProperties } from './BaseObject';
-import BaseRepository from './BaseRepository';
 import { User, UserProperties } from './User';
 import { Entity } from './Entity';
-export { DataObject, DataObjectParams, DataObjectClass, ObjectUri, AbstractObject, BaseObjectCore, BaseRepository, User, Entity, BaseObjectProperties, UserProperties, };
+export { DataObject, DataObjectParams, DataObjectClass, ObjectUri, AbstractObject, User, Entity, BaseObjectProperties, UserProperties, };

package/lib/components/index.js

@@ -1,21 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserProperties = exports.BaseObjectProperties = exports.Entity = exports.User = exports.BaseRepository = exports.BaseObjectCore = exports.AbstractObject = exports.ObjectUri = exports.DataObject = void 0;
+exports.UserProperties = exports.BaseObjectProperties = exports.Entity = exports.User = exports.AbstractObject = exports.ObjectUri = exports.DataObject = void 0;
 const DataObject_1 = require("./DataObject");
 Object.defineProperty(exports, "DataObject", { enumerable: true, get: function () { return DataObject_1.DataObject; } });
 const ObjectUri_1 = require("./ObjectUri");
 Object.defineProperty(exports, "ObjectUri", { enumerable: true, get: function () { return ObjectUri_1.ObjectUri; } });
 const AbstractObject_1 = require("./AbstractObject");
 Object.defineProperty(exports, "AbstractObject", { enumerable: true, get: function () { return AbstractObject_1.AbstractObject; } });
-const BaseObjectCore_1 = require("./BaseObjectCore");
-Object.defineProperty(exports, "BaseObjectCore", { enumerable: true, get: function () { return BaseObjectCore_1.BaseObjectCore; } });
 const BaseObject_1 = require("./BaseObject");
 Object.defineProperty(exports, "BaseObjectProperties", { enumerable: true, get: function () { return BaseObject_1.BaseObjectProperties; } });
-const BaseRepository_1 = __importDefault(require("./BaseRepository"));
-exports.BaseRepository = BaseRepository_1.default;
 const User_1 = require("./User");
 Object.defineProperty(exports, "User", { enumerable: true, get: function () { return User_1.User; } });
 Object.defineProperty(exports, "UserProperties", { enumerable: true, get: function () { return User_1.UserProperties; } });

package/lib/index.d.ts

@@ -1,14 +1,15 @@
 import { Core } from './Core';
 import * as statuses from './common/statuses';
-import * as utils from './utils';
 import { Property } from './properties/Property';
 import { BaseProperty, BasePropertyType } from './properties/BaseProperty';
 import { StringProperty, StringPropertyType } from './properties/StringProperty';
 import { EnumProperty, EnumPropertyType } from './properties/EnumProperty';
 import { BooleanProperty, BooleanPropertyType } from './properties/BooleanProperty';
-import { ObjectProperty, ObjectPropertyType } from './properties/ObjectProperty';
+import { ObjectProperty, ObjectPropertyType, returnAs } from './properties/ObjectProperty';
 import { DateTimeProperty, DateTimePropertyType } from './properties/DateTimeProperty';
 import { HashProperty, HashPropertyType } from './properties/HashProperty';
+import { CollectionProperty, CollectionPropertyType } from './properties/CollectionProperty';
+import { ArrayProperty, ArrayPropertyType } from './properties/ArrayProperty';
 import { AbstractObject } from './components/AbstractObject';
 import { ObjectUri } from './components/ObjectUri';
 import { DataObjectClass } from './components/types/DataObjectClass';
@@ -16,20 +17,7 @@ import { DataObject } from './components/DataObject';
 import { BaseObjectCore } from './components/BaseObjectCore';
 import { BaseObject, BaseObjectProperties } from './components/BaseObject';
 import { Proxy } from './components/types/ProxyConstructor';
-import { InjectMetaMiddleware } from './backends/middlewares/InjectMetaMiddleware';
-import { InjectKeywordsMiddleware } from './backends/middlewares/InjectKeywordsMiddleware';
-import RepositoryClass from './components/types/RepositoryClass';
-import BaseRepository from './components/BaseRepository';
-import { BackendAction, BackendParameters, BackendParametersKeys, BackendRecordType } from './Backend';
-import Middleware from './backends/middlewares/Middleware';
 import { UserType, User } from './components/User';
-import UserRepository from './components/UserRepository';
 import { EntityType, Entity } from './components/Entity';
-import EntityRepository from './components/EntityRepository';
-import { AuthAction, AuthParameters, AuthParametersKeys } from './Auth';
-import { AuthInterface, AbstractAuthAdapter, AuthenticationError } from './authentication';
-import { AbstractAdapter, MockAdapter, BackendError, Query, QueryMetaType, QueryResultType, Filter, Filters, Limits, Sorting, SortAndLimit } from './backends';
 import { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError } from './common/ResourcesErrors';
-import { DatabaseTriggerType } from './wrappers/cloud/types/DatabaseTriggerType';
-import { AbstractCloudWrapper } from './wrappers/cloud/AbstractCloudWrapper';
-export { statuses, utils, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, AbstractAdapter, RepositoryClass, MockAdapter, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, AuthAction, AuthParameters, AuthParametersKeys, AuthInterface, AbstractAuthAdapter, AuthenticationError, BackendParameters, BackendParametersKeys, BackendRecordType, BackendAction, BaseRepository, BackendError, Query, QueryMetaType, QueryResultType, Filter, Filters, Limits, Sorting, SortAndLimit, Middleware, InjectMetaMiddleware, InjectKeywordsMiddleware, User, UserType, Proxy, UserRepository, Entity, EntityType, EntityRepository, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError, DatabaseTriggerType, AbstractCloudWrapper, };
+export { statuses, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, CollectionProperty, CollectionPropertyType, ArrayProperty, ArrayPropertyType, ObjectProperty, ObjectPropertyType, returnAs, StringProperty, StringPropertyType, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, User, UserType, Proxy, Entity, EntityType, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError, };